added boolean returns for begin, format, unmount

cristidragomir97 · cristidragomir97 · commit ad673619be2a · 2023-09-05T18:02:34.000+03:00
diff --git a/src/Arduino_UnifiedStorage.h b/src/Arduino_UnifiedStorage.h
@@ -36,20 +36,20 @@ class Arduino_UnifiedStorage {
          * 
          * @return 1 if successful, 0 if failed.
          */
-        virtual int begin() = 0;
+        virtual bool begin() = 0;
 
         /**
           * Initializes the  storage with the specified file system.
           * @param fs The desired file system (FS_FAT or FS_LITTLEFS).
           * @return 1 if successful, 0 if failed.
           */
-        virtual int begin(FileSystems fs) = 0;
+        virtual bool begin(FileSystems fs) = 0;
 
         /**
          * Unmounts the storage.
          * @return 1 if successful, 0 if failed.
          */
-        virtual int unmount() = 0;
+        virtual bool unmount() = 0;
 
         /**
          * Retrieves the root folder of the storage.
@@ -61,7 +61,7 @@ class Arduino_UnifiedStorage {
          * Formats the storage with the selected file system.
          * @return 1 if successful, 0 if failed.
          */
-        virtual int format(FileSystems fs) = 0;
+        virtual bool format(FileSystems fs) = 0;
 
 };
 
diff --git a/src/InternalStorage.cpp b/src/InternalStorage.cpp
@@ -17,12 +17,12 @@ InternalStorage::InternalStorage(int partition, const char * name, FileSystems f
     this -> fs = fs;
 }
 
-int InternalStorage::begin(FileSystems fs){
+bool InternalStorage::begin(FileSystems fs){
   this -> fs = fs;
-  this -> begin();
+  return this -> begin();
 }
 
-int InternalStorage::begin(){
+bool InternalStorage::begin(){
     #if defined(ARDUINO_PORTENTA_C33)
         this -> blockDevice = BlockDevice::get_default_instance();
         this -> userData = new MBRBlockDevice(this->blockDevice, this->partitionNumber);
@@ -51,13 +51,13 @@ int InternalStorage::begin(){
             this -> userDataFileSystem = new mbed::LittleFileSystem(this->partitionName);
         }
         int err = this -> userDataFileSystem -> mount(this -> userData);
-        if(err == 0) return 1;
+        return err == 0 ? true : false;
     #endif
 }
 
-int InternalStorage::unmount(){
-     int err = this -> userDataFileSystem -> unmount();
-     if(err == 0) return 1;
+bool InternalStorage::unmount(){
+    int err = this -> userDataFileSystem -> unmount();
+    return err == 0 ? true : false;
 }
 
 Folder InternalStorage::getRootFolder(){
@@ -72,7 +72,7 @@ void InternalStorage::setQSPIPartitionName(const char * name){
     this -> partitionName = (char *)name;
 }
 
-int InternalStorage::format(FileSystems fs){
+bool InternalStorage::format(FileSystems fs){
     this -> begin();
     this -> unmount();
     this -> fs = fs;
@@ -81,18 +81,18 @@ int InternalStorage::format(FileSystems fs){
     if(fs == FS_FAT){
         #if defined(ARDUINO_PORTENTA_C33)
             this -> userDataFileSystem = new FATFileSystem(this->partitionName);
-            return this -> userDataFileSystem -> reformat(this-> userData);
+            return this -> userDataFileSystem -> reformat(this-> userData)  == 0 ? true : false;
         #elif defined(ARDUINO_PORTENTA_H7_M7) ||  defined(ARDUINO_OPTA) 
             this -> userDataFileSystem =  new mbed::FATFileSystem(this->partitionName);
-            return this -> userDataFileSystem -> reformat(this-> userData);
+            return this -> userDataFileSystem -> reformat(this-> userData)  == 0 ? true : false;
         #endif
     } if (fs == FS_LITTLEFS) {
         #if defined(ARDUINO_PORTENTA_C33)
             this -> userDataFileSystem = new LittleFileSystem(this->partitionName);
-            return this -> userDataFileSystem -> reformat(this-> userData);
+            return this -> userDataFileSystem -> reformat(this-> userData)  == 0 ? true : false;
         #elif defined(ARDUINO_PORTENTA_H7_M7) ||  defined(ARDUINO_OPTA) 
             this -> userDataFileSystem =  new mbed::LittleFileSystem(this->partitionName);
-            return this -> userDataFileSystem -> reformat(this-> userData);
+            return this -> userDataFileSystem -> reformat(this-> userData)  == 0 ? true : false;
         #endif
     }
 }
diff --git a/src/InternalStorage.h b/src/InternalStorage.h
@@ -27,22 +27,22 @@ class InternalStorage : public Arduino_UnifiedStorage {
      * 
      * @return 1 if successful, 0 if failed.
      */
-    int begin() override;
+    bool begin() override;
 
     /**
      * Initializes the internal storage with the specified file system.
      * 
      * @param fs The desired file system (FS_FAT or FS_LITTLEFS).
      * @return 1 if successful, 0 if failed.
      */
-    int begin(FileSystems fs) override;
+    bool begin(FileSystems fs) override;
 
     /**
      * Unmounts the internal storage.
      * 
      * @return 1 if successful, 0 if failed.
      */
-    int unmount() override;
+    bool unmount() override;
 
     /**
      * Retrieves the root folder of the internal storage.
@@ -70,7 +70,7 @@ class InternalStorage : public Arduino_UnifiedStorage {
      * 
      * @return 1 if successful, 0 if failed.
      */
-    int format(FileSystems fs) override;
+    bool format(FileSystems fs) override;
 
 
     /**
@@ -100,8 +100,8 @@ class InternalStorage : public Arduino_UnifiedStorage {
         int partitionNumber = 3;
         #endif
 
-        char * partitionName = "user";
-        FileSystems fs = FS_FAT;
+        char * partitionName;
+        FileSystems fs;
 };
 
 #endif
diff --git a/src/SDStorage.cpp b/src/SDStorage.cpp
@@ -8,36 +8,38 @@ SDStorage::SDStorage(){
 
 }
 
-int SDStorage::begin(){
-  return mount(DEV_SDCARD, this->fileSystem, MNT_DEFAULT) == 0;
+bool SDStorage::begin(){
+  return mount(DEV_SDCARD, this->fileSystem, MNT_DEFAULT)== 0 ? true : false;
 }
 
-int SDStorage::begin(FileSystems fs){
+bool SDStorage::begin(FileSystems fs){
   this -> fileSystem = fs;
-  this -> begin();
+  return this -> begin();
 }
 
-int SDStorage::unmount(){
-  return umount(DEV_SDCARD) == 0;
+bool SDStorage::unmount(){
+    return umount(DEV_SDCARD) == 0 ? true : false;
 }
 
 Folder SDStorage::getRootFolder(){
     return Folder("/sdcard");
 }
 
-int SDStorage::format(FileSystems fs){
+bool SDStorage::format(FileSystems fs){
+    int err = 0;
     if(fs == FS_FAT){
         this -> begin();
         this -> unmount();
         this -> fileSystem = FS_FAT;
-        return mkfs(DEV_SDCARD, FS_FAT);
+        err = mkfs(DEV_SDCARD, FS_FAT);
     } else if (fs == FS_LITTLEFS) {
         this -> begin();
         this -> unmount();
         this -> fileSystem = FS_LITTLEFS;
-        return mkfs(DEV_SDCARD, FS_LITTLEFS);
+        err =  mkfs(DEV_SDCARD, FS_LITTLEFS);
     }
 
+    return err == 0 ? true : false;
 }
 
 
diff --git a/src/SDStorage.h b/src/SDStorage.h
@@ -22,22 +22,22 @@ class SDStorage: public Arduino_UnifiedStorage  {
          * 
          * @return 1 if successful, 0 if failed.
          */
-        int begin() override ;
+        bool begin() override ;
 
         /**
          * Initializes the SD card storage with the specified file system.
          * 
          * @param fs The desired file system (FS_FAT or FS_LITTLEFS).
          * @return 1 if successful, 0 if failed.
          */
-        int begin(FileSystems fs) override;
+        bool begin(FileSystems fs) override;
 
         /**
          * Unmounts the SD card storage.
          * 
          * @return 1 if successful, 0 if failed.
          */
-        int unmount() override;
+        bool unmount() override;
 
         /**
          * Retrieves the root folder of the SD card storage.
@@ -51,7 +51,7 @@ class SDStorage: public Arduino_UnifiedStorage  {
          * 
          * @return 1 if successful, 0 if failed.
          */
-        int format(FileSystems fs) override;
+        bool format(FileSystems fs) override;
         
     private:
         FileSystems fileSystem = FS_FAT;
diff --git a/src/UFile.cpp b/src/UFile.cpp
@@ -269,8 +269,6 @@ bool UFile::moveTo(Folder destinationFolder, bool overwrite) {
 bool UFile::moveTo(const char* destinationPath, bool overwrite){
     std::string newPath = replaceFirstPathComponent(path, destinationPath);
 
-    FILE* destinationFile = fopen(newPath.c_str(), "r");
-
     fclose(filePointer);
     if (!copyTo(destinationPath, overwrite)) {
         return false; // Return false if the copy operation fails
@@ -281,7 +279,7 @@ bool UFile::moveTo(const char* destinationPath, bool overwrite){
         return false;
     }
 
-    open(newPath.c_str(), fileMode); // sure about that ?
+    //open(newPath.c_str(), fileMode); // sure about that ?
     path = newPath;
 
     return true;
diff --git a/src/USBStorage.cpp b/src/USBStorage.cpp
@@ -17,12 +17,12 @@ USBStorage::USBStorage(){
 #endif
 }
 
-int USBStorage::begin(FileSystems fs){
+bool USBStorage::begin(FileSystems fs){
   this -> fileSystem = fs;
-  this -> begin();
+  return this -> begin();
 }
 
-int USBStorage::begin(){
+bool USBStorage::begin(){
     int attempts = 0;
     int err = mount(DEV_USB, this->fileSystem, MNT_DEFAULT);
 
@@ -38,18 +38,18 @@ int USBStorage::begin(){
         this -> connected = false;
     }
 
-    return err == 0;
+    return err == 0 ? true : false;
 }
 
-int USBStorage::unmount(){
+bool USBStorage::unmount(){
   auto unmountResult = umount(DEV_USB);
     
 
   if(unmountResult == 0){
       this -> connected = false;
   }
 
-  return unmountResult == 0;
+    return unmountResult == 0 ? true : false;
 }
 
 Folder USBStorage::getRootFolder(){
@@ -85,17 +85,17 @@ void USBStorage::checkConnection(){
     #endif
 }
 
-int USBStorage::format(FileSystems fs){
+bool  USBStorage::format(FileSystems fs){
     if(fs == FS_FAT){
         this -> begin();
         this -> unmount();
         this -> fileSystem = FS_FAT;
-        return mkfs(DEV_USB, FS_FAT);
+        return mkfs(DEV_USB, FS_FAT) == 0 ? true : false;
     } else if(FS_LITTLEFS) {
         this -> begin();
         this -> unmount();
         this -> fileSystem = FS_LITTLEFS;
-        return mkfs(DEV_USB, FS_LITTLEFS);
+        return mkfs(DEV_USB, FS_LITTLEFS) == 0 ? true : false;
     }
 
 }
diff --git a/src/USBStorage.h b/src/USBStorage.h
@@ -19,22 +19,22 @@ class USBStorage : public Arduino_UnifiedStorage {
      * 
      * @return 1 if successful, 0 if failed.
      */
-    int begin() override;
+    bool begin() override;
 
     /**
      * Initializes the USB storage with the specified file system.
      * 
      * @param fs The desired file system (FS_FAT or FS_LITTLEFS).
      * @return 1 if successful, 0 if failed.
      */
-    int begin(FileSystems fs) override;
+    bool begin(FileSystems fs) override;
 
     /**
      * Unmounts the USB storage.
      * 
      * @return 1 if successful, 0 if failed.
      */
-    int unmount() override;
+    bool unmount() override;
 
     /**
      * Retrieves the root folder of the USB storage.
@@ -48,7 +48,7 @@ class USBStorage : public Arduino_UnifiedStorage {
      * 
      * @return 1 if successful, 0 if failed.
      */
-    int format(FileSystems fs) override;
+    bool format(FileSystems fs) override;
 
     /**
      * Checks if the USB storage is connected.

Original file line number	Diff line number	Diff line change
`@@ -8,36 +8,38 @@ SDStorage::SDStorage(){`
`8`	`8`
`9`	`9`	`}`
`10`	`10`
`11`		`-int SDStorage::begin(){`
`12`		`- return mount(DEV_SDCARD, this->fileSystem, MNT_DEFAULT) == 0;`
	`11`	`+bool SDStorage::begin(){`
	`12`	`+ return mount(DEV_SDCARD, this->fileSystem, MNT_DEFAULT)== 0 ? true : false;`
`13`	`13`	`}`
`14`	`14`
`15`		`-int SDStorage::begin(FileSystems fs){`
	`15`	`+bool SDStorage::begin(FileSystems fs){`
`16`	`16`	`this -> fileSystem = fs;`
`17`		`- this -> begin();`
	`17`	`+ return this -> begin();`
`18`	`18`	`}`
`19`	`19`
`20`		`-int SDStorage::unmount(){`
`21`		`- return umount(DEV_SDCARD) == 0;`
	`20`	`+bool SDStorage::unmount(){`
	`21`	`+ return umount(DEV_SDCARD) == 0 ? true : false;`
`22`	`22`	`}`
`23`	`23`
`24`	`24`	`Folder SDStorage::getRootFolder(){`
`25`	`25`	`return Folder("/sdcard");`
`26`	`26`	`}`
`27`	`27`
`28`		`-int SDStorage::format(FileSystems fs){`
	`28`	`+bool SDStorage::format(FileSystems fs){`
	`29`	`+ int err = 0;`
`29`	`30`	`if(fs == FS_FAT){`
`30`	`31`	`this -> begin();`
`31`	`32`	`this -> unmount();`
`32`	`33`	`this -> fileSystem = FS_FAT;`
`33`		`- return mkfs(DEV_SDCARD, FS_FAT);`
	`34`	`+ err = mkfs(DEV_SDCARD, FS_FAT);`
`34`	`35`	`} else if (fs == FS_LITTLEFS) {`
`35`	`36`	`this -> begin();`
`36`	`37`	`this -> unmount();`
`37`	`38`	`this -> fileSystem = FS_LITTLEFS;`
`38`		`- return mkfs(DEV_SDCARD, FS_LITTLEFS);`
	`39`	`+ err = mkfs(DEV_SDCARD, FS_LITTLEFS);`
`39`	`40`	`}`
`40`	`41`
	`42`	`+ return err == 0 ? true : false;`
`41`	`43`	`}`
`42`	`44`
`43`	`45`
Original file line number	Diff line number	Diff line change
`@@ -17,12 +17,12 @@ USBStorage::USBStorage(){`
`17`	`17`	`#endif`
`18`	`18`	`}`
`19`	`19`
`20`		`-int USBStorage::begin(FileSystems fs){`
	`20`	`+bool USBStorage::begin(FileSystems fs){`
`21`	`21`	`this -> fileSystem = fs;`
`22`		`- this -> begin();`
	`22`	`+ return this -> begin();`
`23`	`23`	`}`
`24`	`24`
`25`		`-int USBStorage::begin(){`
	`25`	`+bool USBStorage::begin(){`
`26`	`26`	`int attempts = 0;`
`27`	`27`	`int err = mount(DEV_USB, this->fileSystem, MNT_DEFAULT);`
`28`	`28`
`@@ -38,18 +38,18 @@ int USBStorage::begin(){`
`38`	`38`	`this -> connected = false;`
`39`	`39`	`}`
`40`	`40`
`41`		`- return err == 0;`
	`41`	`+ return err == 0 ? true : false;`
`42`	`42`	`}`
`43`	`43`
`44`		`-int USBStorage::unmount(){`
	`44`	`+bool USBStorage::unmount(){`
`45`	`45`	`auto unmountResult = umount(DEV_USB);`
`46`	`46`
`47`	`47`
`48`	`48`	`if(unmountResult == 0){`
`49`	`49`	`this -> connected = false;`
`50`	`50`	`}`
`51`	`51`
`52`		`- return unmountResult == 0;`
	`52`	`+ return unmountResult == 0 ? true : false;`
`53`	`53`	`}`
`54`	`54`
`55`	`55`	`Folder USBStorage::getRootFolder(){`
`@@ -85,17 +85,17 @@ void USBStorage::checkConnection(){`
`85`	`85`	`#endif`
`86`	`86`	`}`
`87`	`87`
`88`		`-int USBStorage::format(FileSystems fs){`
	`88`	`+bool USBStorage::format(FileSystems fs){`
`89`	`89`	`if(fs == FS_FAT){`
`90`	`90`	`this -> begin();`
`91`	`91`	`this -> unmount();`
`92`	`92`	`this -> fileSystem = FS_FAT;`
`93`		`- return mkfs(DEV_USB, FS_FAT);`
	`93`	`+ return mkfs(DEV_USB, FS_FAT) == 0 ? true : false;`
`94`	`94`	`} else if(FS_LITTLEFS) {`
`95`	`95`	`this -> begin();`
`96`	`96`	`this -> unmount();`
`97`	`97`	`this -> fileSystem = FS_LITTLEFS;`
`98`		`- return mkfs(DEV_USB, FS_LITTLEFS);`
	`98`	`+ return mkfs(DEV_USB, FS_LITTLEFS) == 0 ? true : false;`
`99`	`99`	`}`
`100`	`100`
`101`	`101`	`}`