Removing TaskId and reworking handle storage

Os/CMakeLists.txt

@@ -60,7 +60,6 @@ if (FPRIME_USE_POSIX)
         "${CMAKE_CURRENT_LIST_DIR}/Posix/IntervalTimer.cpp"
         "${CMAKE_CURRENT_LIST_DIR}/Posix/Mutex.cpp"
         "${CMAKE_CURRENT_LIST_DIR}/Linux/FileSystem.cpp"
-        "${CMAKE_CURRENT_LIST_DIR}/Posix/TaskId.cpp"
         "${CMAKE_CURRENT_LIST_DIR}/Linux/Directory.cpp"
     )
 endif()

Os/Delegate.hpp

@@ -5,6 +5,7 @@
 #include <new>
 #include <type_traits>
 #include "Fw/Types/Assert.hpp"
+#include "Os/Os.hpp"
 #ifndef OS_DELEGATE_HPP_
 #define OS_DELEGATE_HPP_
 namespace Os {
@@ -42,7 +43,7 @@ namespace Delegate {
 //! \param aligned_new_memory: memory to be filled via placement new call
 //! \return pointer to implementation result of placement new
 template<class Interface, class Implementation>
-inline Interface *makeDelegate(U8 *aligned_new_memory) {
+inline Interface *makeDelegate(HandleStorage& aligned_new_memory) {
     FW_ASSERT(aligned_new_memory != nullptr);
     // Ensure prerequisites before performing placement new
     static_assert(std::is_base_of<Interface, Implementation>::value, "Implementation must derive from Interface");
@@ -86,12 +87,12 @@ inline Interface *makeDelegate(U8 *aligned_new_memory) {
 //! \param to_copy: pointer to Interface to be copied by copy constructor
 //! \return pointer to implementation result of placement new
 template<class Interface, class Implementation>
-inline Interface *makeDelegate(U8 *aligned_new_memory, const Interface *to_copy) {
+inline Interface *makeDelegate(HandleStorage& aligned_new_memory, const Interface *to_copy) {
     FW_ASSERT(aligned_new_memory != nullptr);
     const Implementation *copy_me = reinterpret_cast<const Implementation *>(to_copy);
     // Ensure prerequisites before performing placement new
     static_assert(std::is_base_of<Interface, Implementation>::value, "Implementation must derive from Interface");
-    static_assert(sizeof(Implementation) <= FW_HANDLE_MAX_SIZE, "Handle size not large enough");
+    static_assert(sizeof(Implementation) <= sizeof(aligned_new_memory), "Handle size not large enough");
     static_assert((FW_HANDLE_ALIGNMENT % alignof(Implementation)) == 0, "Handle alignment invalid");
     // Placement new the object and ensure non-null result
     Implementation *interface = nullptr;

Os/File.cpp

@@ -10,7 +10,7 @@ extern "C" {
 }
 namespace Os {
 
-File::File() : m_crc_buffer(), m_handle_storage(), m_delegate(*FileInterface::getDelegate(&m_handle_storage[0])) {
+File::File() : m_crc_buffer(), m_handle_storage(), m_delegate(*FileInterface::getDelegate(m_handle_storage)) {
     FW_ASSERT(&this->m_delegate == reinterpret_cast<FileInterface*>(&this->m_handle_storage[0]));
 }
 
@@ -28,7 +28,7 @@ File::File(const File& other) :
     m_crc(other.m_crc),
     m_crc_buffer(),
     m_handle_storage(),
-    m_delegate(*FileInterface::getDelegate(&m_handle_storage[0], &other.m_delegate)) {
+    m_delegate(*FileInterface::getDelegate(m_handle_storage, &other.m_delegate)) {
     FW_ASSERT(&this->m_delegate == reinterpret_cast<FileInterface*>(&this->m_handle_storage[0]));
 }
 
@@ -37,7 +37,7 @@ File& File::operator=(const File& other) {
         this->m_mode = other.m_mode;
         this->m_path = other.m_path;
         this->m_crc = other.m_crc;
-        this->m_delegate = *FileInterface::getDelegate(&m_handle_storage[0], &other.m_delegate);
+        this->m_delegate = *FileInterface::getDelegate(m_handle_storage, &other.m_delegate);
     }
     return *this;
 }

Os/File.hpp

@@ -6,6 +6,7 @@
 #define Os_File_hpp_
 
 #include <FpConfig.hpp>
+#include <Os/Os.hpp>
 
 namespace Os {
     //! \brief base implementation of FileHandle
@@ -206,14 +207,12 @@ namespace Os {
             //!
             //! \return result of placement new, must be equivalent to `aligned_placement_new_memory`
             //!
-            static FileInterface* getDelegate(U8* aligned_placement_new_memory, const FileInterface* to_copy=nullptr);
+            static FileInterface* getDelegate(HandleStorage& aligned_placement_new_memory, const FileInterface* to_copy=nullptr);
     };
 
 
     class File final : public FileInterface {
       public:
-        // Required for access to m_handle_storage for static assertions against actual storage
-        friend FileInterface* FileInterface::getDelegate(U8*, const FileInterface*);
         //! \brief constructor
         //!
         File();
@@ -485,7 +484,7 @@ namespace Os {
         // opaque and thus normal allocation cannot be done. Instead, we allow the implementor to store then handle in
         // the byte-array here and set `handle` to that address for storage.
         //
-        alignas(FW_HANDLE_ALIGNMENT) U8 m_handle_storage[FW_HANDLE_MAX_SIZE]; //!< Storage for aligned FileHandle data
+        alignas(FW_HANDLE_ALIGNMENT) HandleStorage m_handle_storage; //!< Storage for aligned FileHandle data
         FileInterface& m_delegate; //!< Delegate for the real implementation
     };
 }

Os/Os.hpp

@@ -0,0 +1,11 @@
+// ======================================================================
+// \title Os/Os.hpp
+// \brief common definitions for the OSAL layer
+// ======================================================================
+#ifndef OS_OS_HPP_
+#define OS_OS_HPP_
+#include "FpConfig.h"
+
+//! Storage type for OSAL handles
+typedef U8 HandleStorage[FW_HANDLE_MAX_SIZE];
+#endif

Os/Posix/DefaultFile.cpp

@@ -7,7 +7,7 @@
 #include "Os/Delegate.hpp"
 
 namespace Os {
-FileInterface* FileInterface::getDelegate(U8* aligned_new_memory, const FileInterface* to_copy) {
+FileInterface* FileInterface::getDelegate(HandleStorage& aligned_new_memory, const FileInterface* to_copy) {
     return Os::Delegate::makeDelegate<FileInterface, Os::Posix::File::PosixFile>(aligned_new_memory, to_copy);
 }
 }

Os/Posix/DefaultTask.cpp

@@ -38,7 +38,7 @@ namespace Os {
         return task_status;
     }
 
-    TaskInterface* TaskInterface::getDelegate(U8* aligned_new_memory) {
+    TaskInterface* TaskInterface::getDelegate(HandleStorage& aligned_new_memory) {
         return Os::Delegate::makeDelegate<TaskInterface, Os::Posix::Task::PosixTask>(aligned_new_memory);
     }
 

Os/Posix/Task.hpp

@@ -5,14 +5,13 @@
 #ifndef Os_Posix_Task_hpp_
 #define Os_Posix_Task_hpp_
 
+#include <pthread.h>
 #include <Os/Task.hpp>
 
 #include <FpConfig.hpp>
 #include <Fw/Types/Serializable.hpp>
 #include <Os/TaskString.hpp>
 #include <Os/Mutex.hpp>
-
-#include <Os/TaskId.hpp>
 #include <Fw/Deprecate.hpp>
 
 namespace Os {

Os/Stub/DefaultFile.cpp

@@ -10,7 +10,7 @@ namespace Os {
 //! \param aligned_new_memory: aligned memory to fill
 //! \param to_copy: pointer to copy-constructor input
 //! \return: pointer to delegate
-FileInterface *FileInterface::getDelegate(U8 *aligned_placement_new_memory, const FileInterface* to_copy) {
+FileInterface *FileInterface::getDelegate(HandleStorage& aligned_placement_new_memory, const FileInterface* to_copy) {
     return Os::Delegate::makeDelegate<FileInterface, Os::Stub::File::StubFile>(
             aligned_placement_new_memory, to_copy
     );

Os/Stub/test/DefaultFile.cpp

@@ -11,7 +11,7 @@ namespace Os {
 //! \param aligned_new_memory: aligned memory to fill
 //! \param to_copy: pointer to copy-constructor input
 //! \return: pointer to delegate
-FileInterface *FileInterface::getDelegate(U8 *aligned_placement_new_memory, const FileInterface* to_copy) {
+FileInterface *FileInterface::getDelegate(HandleStorage& aligned_placement_new_memory, const FileInterface* to_copy) {
     return Os::Delegate::makeDelegate<FileInterface, Os::Stub::File::Test::TestFile>(
             aligned_placement_new_memory, to_copy
     );

Os/Task.hpp

@@ -8,10 +8,10 @@
 #include <FpConfig.hpp>
 #include <Fw/Time/Time.hpp>
 #include <Fw/Types/Serializable.hpp>
+#include <Os/Os.hpp>
 #include <Os/TaskString.hpp>
 #include <Os/Mutex.hpp>
 
-#include <Os/TaskId.hpp>
 #include <Fw/Deprecate.hpp>
 #include <limits>
 
@@ -143,7 +143,7 @@ namespace Os {
             //!
             //! \return result of placement new, must be equivalent to `aligned_placement_new_memory`
             //!
-            static TaskInterface* getDelegate(U8* aligned_placement_new_memory);
+            static TaskInterface* getDelegate(HandleStorage& aligned_placement_new_memory);
 
             // =================
             // Implementation functions (instance) to be supplied by the Os::TaskInterface children
@@ -202,8 +202,6 @@ namespace Os {
     //! parent class. Instead it wraps a delegate provided by `TaskInterface::getDelegate()` to provide system specific
     //! behaviour.
     class Task final : public TaskInterface {
-        // Required for access to m_handle_storage for static assertions against actual storage
-        friend TaskInterface* TaskInterface::getDelegate(U8*);
       public:
         static constexpr FwSizeType TASK_DEFAULT = std::numeric_limits<FwSizeType>::max();
         //! Wrapper for task routine that ensures `onStart()` is called once the task actually begins
@@ -343,7 +341,7 @@ namespace Os {
         // opaque and thus normal allocation cannot be done. Instead, we allow the implementor to store then handle in
         // the byte-array here and set `handle` to that address for storage.
         //
-        alignas(FW_HANDLE_ALIGNMENT) U8 m_handle_storage[FW_HANDLE_MAX_SIZE]; //!< Storage for aligned FileHandle data
+        alignas(FW_HANDLE_ALIGNMENT) HandleStorage m_handle_storage; //!< Storage for aligned FileHandle data
         TaskInterface& m_delegate; //!< Delegate for the real implementation
     };