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,38 +159,20 @@ 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)
-    {
-        //!Cast a pointer at the sourceAddr and call the regular subscribe
-        Message<messageType> *source =
-            reinterpret_cast<Message<messageType> *> (sourceAddr);
-	    subscribeTo(source);
-    }
-    //! Subscribe to the C message located at the sourceAddr in memory
-    void subscribeToCAddr(uint64_t sourceAddr)
-    {
-        //! Cast a void* pointer and call the regular C-subscribe method
-        void *source = reinterpret_cast<void *> (sourceAddr);
-        subscribeToC(source);
-    }
+
     //! Subscribe to a C++ message
     void subscribeTo(Message<messageType> *source){
         *this = source->addSubscriber();
         this->initialized = true;
     };
 
-    //! Unsubscribe to the connected message, noop if no message was connected
-    void unsubscribe(){
-        this->payloadPointer = nullptr;
-        this->headerPointer = nullptr;
-        this->initialized = false;
-    }
 
     //! Check if self has been subscribed to a C message
     uint8_t isSubscribedToC(void *source){
@@ -163,20 +194,6 @@ class ReadFunctor{
         return (this->initialized && firstCheck && secondCheck );
 
     };
-    //! Check if self has been subscribed to the message at sourceAddr
-    uint8_t isSubscribedToAddr(uint64_t sourceAddr)
-    {
-        //!Cast a pointer at the sourceAddr and call the regular is-subscribe
-        Message<messageType> *source = reinterpret_cast<Message<messageType> *> (sourceAddr);
-        return(isSubscribedTo(source));
-    }
-    //! Check if self has been subscribed to the message at sourceAddr
-    uint8_t isSubscribedToCAddr(uint64_t sourceAddr)
-    {
-        //!Cast a void* pointer at the sourceAddr and call the regular is-subscribe
-        void *source = reinterpret_cast<void *> (sourceAddr);
-        return(isSubscribedToC(source));
-    }
 
     //! Recorder method description
     Recorder<messageType> recorder(uint64_t timeDiff = 0){return Recorder<messageType>(this, timeDiff);}
@@ -187,7 +204,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 +227,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
+    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 +258,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(){
@@ -279,13 +303,13 @@ class Recorder : public SysModel{
     //! -- Use this to record C messages
     Recorder(void* message, uint64_t timeDiff = 0){
         this->timeInterval = timeDiff;
+        MsgHeader msgHeader;
 
-        MsgHeader* msgPt = (MsgHeader *) message;
-        MsgHeader *pt = msgPt;
+        MsgHeader* pt = (MsgHeader *) message;
         messageType* payloadPointer;
         payloadPointer = (messageType *) (++pt);
 
-        this->readMessage = ReadFunctor<messageType>(payloadPointer, msgPt);
+        this->readMessage = ReadFunctor<messageType>(payloadPointer, &msgHeader);
         this->ModelTag = "Rec:";
         Message<messageType> tempMsg;
         std::string msgName = typeid(tempMsg).name();
@@ -310,13 +334,6 @@ class Recorder : public SysModel{
     //! -- Read and record the message
     void UpdateState(uint64_t CurrentSimNanos){
         if (CurrentSimNanos >= this->nextUpdateTime) {
-            // Log warning if message is invalid but don't change behavior
-            if (!this->readMessage.isLinked() || !this->readMessage.isWritten()) {
-                messageType var;
-                bskLogger.bskLog(BSK_WARNING, "Recording message of type %s that is not properly initialized or written", typeid(var).name());
-            }
-
-            // Record the message
             this->msgRecordTimes.push_back(CurrentSimNanos);
             this->msgWrittenTimes.push_back(this->readMessage.timeWritten());
             this->msgRecord.push_back(this->readMessage());
@@ -336,8 +353,6 @@ class Recorder : public SysModel{
     std::vector<uint64_t>& timesWritten(){return this->msgWrittenTimes;}
     //! record method
     std::vector<messageType>& record(){return this->msgRecord;};
-    //! size of the record so far
-    size_t size(){return this->record().size();}
 
     //! determine message name
     std::string findMsgName(std::string msgName) {