Expose raw message header and payload pointers

Author: ReeceHumphreys

src/architecture/messaging/messaging.h

@@ -17,13 +17,57 @@ ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 */
 #ifndef MESSAGING_H
 #define MESSAGING_H
+#include <memory>
 #include "architecture/_GeneralModuleFiles/sys_model.h"
 #include <vector>
 #include "architecture/messaging/msgHeader.h"
 #include "architecture/utilities/bskLogging.h"
 #include <typeinfo>
 #include <stdlib.h>
 
+
+struct messagePointerData{
+  void *header;
+  void *payload;
+};
+
+typedef struct messagePointerData messagePointerData;
+
+class MessageBase{
+    public:
+        messagePointerData pointers;
+        messagePointerData *reference;
+
+        messagePointerData *GetPointers(void)
+        {
+            this->reference =  (messagePointerData*)malloc(sizeof(messagePointerData));
+            this->reference->payload = pointers.payload;
+            this->reference->header = pointers.header;
+
+            return this->reference;
+        }
+};
+
+class ReadFunctorBase{
+    public :
+        void *headerVoidPtr; //! TODO: kludge to fix PITL, do we want to keep this member?
+        void *payloadVoidPtr;
+        messagePointerData *reference;
+
+        //! constructor
+        ReadFunctorBase() : headerVoidPtr(NULL), payloadVoidPtr(NULL), reference(NULL) {};
+
+        messagePointerData *GetPointers(void)
+        {
+            this->reference =  (messagePointerData*)malloc(sizeof(messagePointerData));
+            this->reference->header = this->headerVoidPtr;
+            this->reference->payload = this->payloadVoidPtr;
+            return this->reference;
+        }
+
+};
+
+
 /*! forward-declare sim message for use by read functor */
 template<typename messageType>
 class Message;
@@ -33,7 +77,7 @@ class Recorder;
 
 /*! Read functors have read-only access to messages*/
 template<typename messageType>
-class ReadFunctor{
+class ReadFunctor : public ReadFunctorBase{
 private:
     messageType* payloadPointer;    //!< -- pointer to the incoming msg data
     MsgHeader *headerPointer;      //!< -- pointer to the incoming msg header
@@ -49,7 +93,12 @@ class ReadFunctor{
     ReadFunctor() : initialized(false) {};
 
     //! constructor
-    ReadFunctor(messageType* payloadPtr, MsgHeader *headerPtr) : payloadPointer(payloadPtr), headerPointer(headerPtr), initialized(true){};
+    ReadFunctor(messageType* payloadPtr, MsgHeader *headerPtr) :
+                  payloadPointer(payloadPtr), headerPointer(headerPtr), initialized(true)
+    {
+        this->headerVoidPtr = headerPtr;
+        this->payloadVoidPtr = payloadPtr;
+    };
 
     //! constructor
     const messageType& operator()(){
@@ -110,10 +159,12 @@ class ReadFunctor{
         MsgHeader* pt = this->headerPointer;
         this->payloadPointer = (messageType *) (++pt);
 
-
         // set flag that this input message is connected to another message
         this->initialized = true;           // set input message as linked
         this->headerPointer->isLinked = 1;  // set source output message as linked
+
+        this->payloadVoidPtr = this->payloadPointer;
+        this->headerVoidPtr = this->headerPointer;
     };
     //! Subscribe to the message located at the sourceAddr in memory
     void subscribeToAddr(uint64_t sourceAddr)
@@ -187,7 +238,7 @@ template<typename messageType>
 class WriteFunctor{
 private:
     messageType* payloadPointer;    //!< pointer to the message payload
-    MsgHeader* headerPointer;       //!< pointer to the message header
+    MsgHeader* headerPointer;      //!< pointer to the message header
 public:
     //! write functor constructor
     WriteFunctor(){};
@@ -210,12 +261,13 @@ class Recorder;
  * base class template for bsk messages
  */
 template<typename messageType>
-class Message{
+class Message : public MessageBase{
 private:
     messageType payload = {};   //!< struct defining message payload, zero'd on creation
     MsgHeader header = {};      //!< struct defining the message header, zero'd on creation
     ReadFunctor<messageType> read = ReadFunctor<messageType>(&payload, &header);  //!< read functor instance
 public:
+    Message();
     //! write functor to this message
     WriteFunctor<messageType> write = WriteFunctor<messageType>(&payload, &header);
     //! -- request read rights. returns reference to class ``read`` variable
@@ -240,6 +292,12 @@ class Message{
     uint64_t getPayloadSize() {return sizeof(messageType);};
 };
 
+template<typename messageType>
+Message<messageType>::Message()
+{
+    this->pointers.payload = &payload;
+    this->pointers.header = &header;
+}
 
 template<typename messageType>
 ReadFunctor<messageType> Message<messageType>::addSubscriber(){
@@ -280,12 +338,11 @@ class Recorder : public SysModel{
     Recorder(void* message, uint64_t timeDiff = 0){
         this->timeInterval = timeDiff;
 
-        MsgHeader* msgPt = (MsgHeader *) message;
-        MsgHeader *pt = msgPt;
-        messageType* payloadPointer;
-        payloadPointer = (messageType *) (++pt);
+        auto* headerPtr  = static_cast<MsgHeader*>(message);
+        auto* payloadPtr = reinterpret_cast<messageType*>(headerPtr + 1);
+
+        this->readMessage = ReadFunctor<messageType>(payloadPtr, headerPtr);
 
-        this->readMessage = ReadFunctor<messageType>(payloadPointer, msgPt);
         this->ModelTag = "Rec:";
         Message<messageType> tempMsg;
         std::string msgName = typeid(tempMsg).name();