tested examples, added documentation

Author: cristidragomir97

libraries/ArduinoStorage/CMakeLists.txt

@@ -1,10 +1,3 @@
 # SPDX-License-Identifier: Apache-2.0
+# Header-only library - just expose include directory
 zephyr_include_directories(.)
-
-if(NOT DEFINED ARDUINO_BUILD_PATH)
-	zephyr_sources_ifdef(CONFIG_FILE_SYSTEM
-		StorageError.cpp
-		StorageFile.cpp
-		StorageFolder.cpp
-	)
-endif()

libraries/ArduinoStorage/StorageError.cpp

@@ -8,6 +8,7 @@
 #define ARDUINO_STORAGE_ERROR_H
 
 #include <Arduino.h>
+#include <cstring>
 
 enum class StorageErrorCode {
     NONE = 0,
@@ -49,19 +50,96 @@ enum class StorageErrorCode {
 
 class StorageError {
 public:
-    StorageError();
+    StorageError() : code_(StorageErrorCode::NONE) {
+        message_[0] = '\0';
+    }
 
     // Error state
-    StorageErrorCode getCode() const;
-    const char* getMessage() const;
-    bool hasError() const;
+    StorageErrorCode getCode() const {
+        return code_;
+    }
+
+    const char* getMessage() const {
+        if (message_[0] != '\0') {
+            return message_;
+        }
+
+        // Return default message based on error code
+        switch (code_) {
+            case StorageErrorCode::NONE:
+                return "No error";
+            case StorageErrorCode::FILE_NOT_FOUND:
+                return "File not found";
+            case StorageErrorCode::FOLDER_NOT_FOUND:
+                return "Folder not found";
+            case StorageErrorCode::ALREADY_EXISTS:
+                return "Already exists";
+            case StorageErrorCode::INVALID_PATH:
+                return "Invalid path";
+            case StorageErrorCode::PERMISSION_DENIED:
+                return "Permission denied";
+            case StorageErrorCode::READ_ERROR:
+                return "Read error";
+            case StorageErrorCode::WRITE_ERROR:
+                return "Write error";
+            case StorageErrorCode::SEEK_ERROR:
+                return "Seek error";
+            case StorageErrorCode::OPEN_ERROR:
+                return "Open error";
+            case StorageErrorCode::CLOSE_ERROR:
+                return "Close error";
+            case StorageErrorCode::STORAGE_FULL:
+                return "Storage full";
+            case StorageErrorCode::STORAGE_NOT_MOUNTED:
+                return "Storage not mounted";
+            case StorageErrorCode::STORAGE_CORRUPTED:
+                return "Storage corrupted";
+            case StorageErrorCode::STORAGE_NOT_FORMATTED:
+                return "Storage not formatted";
+            case StorageErrorCode::INVALID_OPERATION:
+                return "Invalid operation";
+            case StorageErrorCode::INVALID_MODE:
+                return "Invalid mode";
+            case StorageErrorCode::BUFFER_OVERFLOW:
+                return "Buffer overflow";
+            case StorageErrorCode::OUT_OF_MEMORY:
+                return "Out of memory";
+            case StorageErrorCode::TIMEOUT:
+                return "Timeout";
+            case StorageErrorCode::HARDWARE_ERROR:
+                return "Hardware error";
+            case StorageErrorCode::NOT_INITIALIZED:
+                return "Not initialized";
+            case StorageErrorCode::UNKNOWN_ERROR:
+            default:
+                return "Unknown error";
+        }
+    }
+
+    bool hasError() const {
+        return code_ != StorageErrorCode::NONE;
+    }
 
     // Error setting (for implementations)
-    void setError(StorageErrorCode code, const char* message = nullptr);
-    void clear();
+    void setError(StorageErrorCode code, const char* message = nullptr) {
+        code_ = code;
+        if (message != nullptr) {
+            strncpy(message_, message, sizeof(message_) - 1);
+            message_[sizeof(message_) - 1] = '\0';
+        } else {
+            message_[0] = '\0';
+        }
+    }
+
+    void clear() {
+        code_ = StorageErrorCode::NONE;
+        message_[0] = '\0';
+    }
 
     // Convenience operators
-    operator bool() const;  // Returns true if error exists
+    operator bool() const {
+        return hasError();
+    }
 
 private:
     StorageErrorCode code_;

libraries/ArduinoStorage/StorageError.h

@@ -8,6 +8,7 @@
 #define ARDUINO_STORAGE_FILE_H
 
 #include <Arduino.h>
+#include <cstring>
 #include "StorageCommon.h"
 #include "StorageError.h"
 
@@ -23,10 +24,25 @@ class Folder;
  */
 class File {
 public:
-    File();
-    File(const char* path);
-    File(const String& path);
-    virtual ~File();
+    File() {
+        path_[0] = '\0';
+    }
+
+    File(const char* path) {
+        if (path != nullptr) {
+            strncpy(path_, path, sizeof(path_) - 1);
+            path_[sizeof(path_) - 1] = '\0';
+        } else {
+            path_[0] = '\0';
+        }
+    }
+
+    File(const String& path) {
+        strncpy(path_, path.c_str(), sizeof(path_) - 1);
+        path_[sizeof(path_) - 1] = '\0';
+    }
+
+    virtual ~File() {}
 
     // Opening and Closing
     virtual bool open(const char* filename, FileMode mode, StorageError* error = nullptr) = 0;
@@ -58,15 +74,31 @@ class File {
     virtual bool rename(const String& newFilename, StorageError* error = nullptr) = 0;
 
     // Path Information
-    virtual const char* getPath() const;
-    virtual String getPathAsString() const;
-    virtual String getFilename() const;
+    virtual const char* getPath() const {
+        return path_;
+    }
+
+    virtual String getPathAsString() const {
+        return String(path_);
+    }
+
+    virtual String getFilename() const {
+        const char* lastSep = strrchr(path_, '/');
+        if (lastSep != nullptr) {
+            return String(lastSep + 1);
+        }
+        return String(path_);
+    }
 
 protected:
     char path_[STORAGE_MAX_PATH_LENGTH];
 
     // Helper to set error if pointer is not null
-    static void setErrorIfNotNull(StorageError* error, StorageErrorCode code, const char* message = nullptr);
+    static void setErrorIfNotNull(StorageError* error, StorageErrorCode code, const char* message = nullptr) {
+        if (error != nullptr) {
+            error->setError(code, message);
+        }
+    }
 };
 
 #endif // ARDUINO_STORAGE_FILE_H