Refactor Os::FileSystem and Os::Directory

.github/actions/spelling/line_forbidden.patterns

@@ -11,9 +11,6 @@
 # s.b. anymore
 \bany more[,.]
 
-# s.b. cannot
-\b[Cc]an not\b
-
 # s.b. GitHub
 (?<![&*.]|// |\btype )\bGithub\b(?![{)])
 
@@ -70,16 +67,9 @@
 # s.b. or (more|less)
 \bore (?:more|less)\b
 
-# s.b. nonexistent
-\bnon existing\b
-\b[Nn]o[nt][- ]existent\b
-
 # s.b. brief / details/ param / return / retval
 (?:^\s*|(?:\*|//|/*)\s+`)[\\@](?:breif|(?:detail|detials)|(?:params(?!\.)|prama?)|ret(?:uns?)|retvl)\b
 
-# s.b. preexisting
-[Pp]re[- ]existing
-
 # s.b. preempt
 [Pp]re[- ]empt\b
 

Fw/Types/StringBase.hpp

@@ -28,7 +28,7 @@ class StringBase : public Serializable {
     virtual SizeType getCapacity() const = 0;  //!< return size of buffer
     SizeType length() const;                   //!< Get length of string
 
-    //! Get the maximum length of a string that the buffer can hold
+    //! Get the maximum length of a string that the buffer can hold (which is capacity - 1)
     SizeType maxLength() const;
     //! Get the static serialized size of a string
     //! This is the max length of the string plus the size of the stored size

Os/CMakeLists.txt

@@ -35,9 +35,12 @@ set(SOURCE_FILES
     "${CMAKE_CURRENT_LIST_DIR}/ValidatedFile.cpp"
 
     # Refactored common files
+    "${CMAKE_CURRENT_LIST_DIR}/Os.cpp"
     "${CMAKE_CURRENT_LIST_DIR}/File.cpp"
     "${CMAKE_CURRENT_LIST_DIR}/Task.cpp"
     "${CMAKE_CURRENT_LIST_DIR}/Mutex.cpp"
+    "${CMAKE_CURRENT_LIST_DIR}/FileSystem.cpp"
+    "${CMAKE_CURRENT_LIST_DIR}/Directory.cpp"
 )
 # Check for default logger
 if (NOT FPRIME_DISABLE_DEFAULT_LOGGER)
@@ -56,8 +59,6 @@ if (FPRIME_USE_POSIX)
         "${CMAKE_CURRENT_LIST_DIR}/Linux/InterruptLock.cpp"
         "${CMAKE_CURRENT_LIST_DIR}/Linux/WatchdogTimer.cpp"
         "${CMAKE_CURRENT_LIST_DIR}/Posix/IntervalTimer.cpp"
-        "${CMAKE_CURRENT_LIST_DIR}/Linux/FileSystem.cpp"
-        "${CMAKE_CURRENT_LIST_DIR}/Linux/Directory.cpp"
     )
 endif()
 # Darwin IPC queue implementation
@@ -97,26 +98,33 @@ endif()
 register_fprime_module()
 
 require_fprime_implementation(Os/File)
+require_fprime_implementation(Os/FileSystem)
+require_fprime_implementation(Os/Directory)
+require_fprime_implementation(Os/Mutex)
 # require_fprime_implementation(Os/Task) # should be added in
-require_fprime_implementation(Os/Mutex) 
+# require_fprime_implementation(Os/Console) # should be added in
 
 
 ### UTS ### Note: 3 separate UTs registered here.
 set(UT_SOURCE_FILES
   "${CMAKE_CURRENT_LIST_DIR}/test/ut/OsQueueTest.cpp"
   "${CMAKE_CURRENT_LIST_DIR}/test/ut/OsTestMain.cpp"
   "${CMAKE_CURRENT_LIST_DIR}/test/ut/IntervalTimerTest.cpp"
-  "${CMAKE_CURRENT_LIST_DIR}/test/ut/OsFileSystemTest.cpp"
   "${CMAKE_CURRENT_LIST_DIR}/test/ut/OsValidateFileTest.cpp"
   "${CMAKE_CURRENT_LIST_DIR}/test/ut/OsSystemResourcesTest.cpp"
   "${CMAKE_CURRENT_LIST_DIR}/test/ut/OsMutexBasicLockableTest.cpp"
 )
 register_fprime_ut()
 if (BUILD_TESTING)
-    foreach (TEST IN ITEMS StubFileTest PosixFileTest StubMutexTest PosixMutexTest) # add? : StubTaskTest PosixTaskTest
-       if (TARGET "${TEST}")
-           add_dependencies("Os_ut_exe" "${TEST}")
-       endif()
+    foreach (TEST IN ITEMS 
+                StubFileTest PosixFileTest
+                StubMutexTest PosixMutexTest
+                StubDirectoryTest PosixDirectory
+                StubFileSystemTest PosixFileSystemTest
+            ) # add? : StubTaskTest PosixTaskTest
+        if (TARGET "${TEST}")
+            add_dependencies("Os_ut_exe" "${TEST}")
+        endif()
     endforeach()
 endif()
 # Second UT Pthreads

Os/Directory.cpp

@@ -0,0 +1,148 @@
+// ======================================================================
+// \title Os/Directory.cpp
+// \brief common function implementation for Os::Directory
+// ======================================================================
+#include <Fw/Types/Assert.hpp>
+#include <Os/Directory.hpp>
+
+namespace Os {
+
+Directory::Directory() : m_is_open(false), m_handle_storage(), m_delegate(*DirectoryInterface::getDelegate(m_handle_storage)) {
+    FW_ASSERT(&this->m_delegate == reinterpret_cast<DirectoryInterface*>(&this->m_handle_storage[0]));
+}
+
+Directory::~Directory() {
+    FW_ASSERT(&this->m_delegate == reinterpret_cast<DirectoryInterface*>(&this->m_handle_storage[0]));
+    if (this->m_is_open) {
+        this->close();
+    }
+    this->m_delegate.~DirectoryInterface();
+}
+
+// ------------------------------------------------------------
+// Directory operations delegating to implementation
+// ------------------------------------------------------------
+DirectoryHandle* Directory::getHandle() {
+    FW_ASSERT(&this->m_delegate == reinterpret_cast<DirectoryInterface*>(&this->m_handle_storage[0]));
+    return this->m_delegate.getHandle();
+}
+
+Directory::Status Directory::open(const char* path, OpenMode mode) {
+    FW_ASSERT(&this->m_delegate == reinterpret_cast<DirectoryInterface*>(&this->m_handle_storage[0]));
+    FW_ASSERT(path != nullptr);
+    FW_ASSERT(mode >= 0 and mode < OpenMode::MAX_OPEN_MODE);
+    Status status = this->m_delegate.open(path, mode);
+    if (status == Status::OP_OK) {
+        this->m_is_open = true;
+    }
+    return status;
+}
+
+bool Directory::isOpen() {
+    FW_ASSERT(&this->m_delegate == reinterpret_cast<DirectoryInterface*>(&this->m_handle_storage[0]));
+    return this->m_is_open;
+}
+Directory::Status Directory::rewind() {
+    FW_ASSERT(&this->m_delegate == reinterpret_cast<DirectoryInterface*>(&this->m_handle_storage[0]));
+    if (not this->m_is_open) {
+        return Status::NOT_OPENED;
+    }
+    return this->m_delegate.rewind();
+}
+
+Directory::Status Directory::read(char * fileNameBuffer, FwSizeType bufSize) {
+    FW_ASSERT(&this->m_delegate == reinterpret_cast<DirectoryInterface*>(&this->m_handle_storage[0]));
+    if (not this->m_is_open) {
+        return Status::NOT_OPENED;
+    }
+    FW_ASSERT(fileNameBuffer != nullptr);
+    Status status = this->m_delegate.read(fileNameBuffer, bufSize);
+    fileNameBuffer[bufSize - 1] = '\0'; // Guarantee null-termination
+    return status;
+}
+
+Directory::Status Directory::read(Fw::StringBase& filename) {
+    FW_ASSERT(&this->m_delegate == reinterpret_cast<DirectoryInterface*>(&this->m_handle_storage[0]));
+    if (not this->m_is_open) {
+        return Status::NOT_OPENED;
+    }
+    return this->m_delegate.read(const_cast<char*>(filename.toChar()), filename.getCapacity());
+}
+
+void Directory::close() {
+    FW_ASSERT(&this->m_delegate == reinterpret_cast<DirectoryInterface*>(&this->m_handle_storage[0]));
+    this->m_is_open = false;
+    return this->m_delegate.close();
+}
+
+// ------------------------------------------------------------
+// Common functions built on top of OS-specific functions
+// ------------------------------------------------------------
+
+Directory::Status Directory::getFileCount(FwSizeType& fileCount) {
+    if (not this->m_is_open) {
+        return Status::NOT_OPENED;
+    }
+    // Rewind to ensure we start from the beginning of the stream
+    if (this->rewind() != Status::OP_OK) {
+        return Status::OTHER_ERROR;
+    }
+    const FwSizeType loopLimit = std::numeric_limits<FwSizeType>::max();
+    FwSizeType count = 0;
+    char unusedBuffer[1]; // buffer must have size but is unused
+    Status readStatus = Status::OP_OK;
+    fileCount = 0;
+    // Count files by reading each file entry until there is NO_MORE_FILES
+    for (FwSizeType iter = 0; iter < loopLimit; ++iter) {
+        readStatus = this->read(unusedBuffer, sizeof(unusedBuffer));
+        if (readStatus == Status::NO_MORE_FILES) {
+            break;
+        } else if (readStatus != Status::OP_OK) {
+            return Status::OTHER_ERROR;
+        }
+        count++;
+    }
+    fileCount = count;
+    if (this->rewind() != Status::OP_OK) {
+        return Status::OTHER_ERROR;
+    }
+    return Status::OP_OK;
+}
+
+
+Directory::Status Directory::readDirectory(Fw::String filenameArray[], const FwSizeType filenameArraySize, FwSizeType& filenameCount) {
+    FW_ASSERT(filenameArray != nullptr);
+    FW_ASSERT(filenameArraySize > 0);
+    if (not this->m_is_open) {
+        return Status::NOT_OPENED;
+    }
+    // Rewind to ensure we start reading from the beginning of the stream
+    if (this->rewind() != Status::OP_OK) {
+        return Status::OTHER_ERROR;
+    }
+
+    Status readStatus = Status::OP_OK;
+    Status returnStatus = Status::OP_OK;
+    FwSizeType index;
+    filenameCount = 0;
+    // Iterate through the directory and read the filenames into the array
+    for (index = 0; index < filenameArraySize; index++) {
+        readStatus = this->read(filenameArray[index]);
+        if (readStatus == Status::NO_MORE_FILES) {
+            break;
+        } else if (readStatus != Status::OP_OK) {
+            return Status::OTHER_ERROR;
+        }
+    }
+    filenameCount = index;
+
+    if (this->rewind() != Status::OP_OK) {
+        return Status::OTHER_ERROR;
+    }
+
+    return returnStatus;
+
+}
+
+
+}  // namespace Os