scIGPMessage.h

Go to the documentation of this file.

/*  @author János Végh (jvegh)
*  @bug No known bugs.
*/
#ifndef scIGPMessage_h
#define scIGPMessage_h
 
//#include "scGridPoint.h"
#include <cstring>
#include "GridPoint.h"
class scGridPoint;
using namespace sc_core; using namespace std;
 
typedef enum {msg_Reg,  
              msg_Qt,   
              msg_Mem,  
              msg_Coop,  
              msg_Neur  
             } IGPMessageType;
 
 
typedef struct {
        uint32_t Time : (32-4-4-4-4); 
        uint32_t SubKey: 4;         
        uint32_t ReplyLength : 4;   
        uint32_t Length : 4;        
        uint32_t Type: 4;           
    int &ToInt() { return *reinterpret_cast<int *>(this);} 
} MessageFeatures_t;
 
class scIGPMessage
{
//    friend class scGridPoint;   /*!< The messages are handled directly by scGridPoint */
//    friend class scProcessor;   /*!< and by scProcessor */
//    friend class scClusterBusMemorySlow; /*!< and may go directly to the bus */
 
  public:
    scIGPMessage(void);
   ~scIGPMessage(void);
        void
    BufferContent_Set(int index, int32_t C)
    {   assert(!(index<0 || index >= MAX_IGPCBUFFER_SIZE)); // wrong index
        mBuffer[4+index] = C;
    }
        int32_t
    BufferContent_Get(int index)
    {   assert(!(index<0 || index >= MAX_IGPCBUFFER_SIZE)); // wrong index
        return mBuffer[4+index];
    }
        string
    StringOfBufferContent_Get(int index)
    {
        ostringstream oss;
        oss << "0x" << hex << BufferContent_Get(index) << dec ;
        return oss.str();
    }
        MessageFeatures_t
    FeatureWord_Get(void)
    {
        MessageFeatures_t MsgType;
        static_assert( sizeof(MsgType) <= sizeof(mBuffer[1]), "!");
        memcpy( &MsgType ,&mBuffer[1], sizeof(mBuffer[1]));
        return MsgType;
    }
        void
    FeatureWord_Set(MessageFeatures_t &F)
    {
        static_assert( sizeof(F) <= sizeof(mBuffer[1]), "!");
        memcpy(&mBuffer[1],  &F, sizeof(mBuffer[1]));
    }
        IGPMessageType
    Type_Get(void)
    {
        MessageFeatures_t MsgType;
        static_assert( sizeof(MsgType) <= sizeof(mBuffer[1]), "!");
        memcpy( &MsgType ,&mBuffer[1], sizeof(mBuffer[1]));
        return (IGPMessageType)MsgType.Type;
    }
        void
    Type_Set(IGPMessageType &T)
    {
        MessageFeatures_t MsgType;
        static_assert( sizeof(T) <= sizeof(mBuffer[1]), "!");
        memcpy( &MsgType ,&mBuffer[1], sizeof(mBuffer[1]));
        MsgType.Type = T;
        memcpy(&mBuffer[1],  &MsgType, sizeof(mBuffer[1]));
    }
        int
    Length_Get(void)
    {
            MessageFeatures_t MsgType;
            static_assert( sizeof(MsgType) <= sizeof(mBuffer[1]), "!");
            memcpy( &MsgType ,&mBuffer[1], sizeof(mBuffer[1]));
            return MsgType.Length;
    }
        int
    ReplyLength_Get(void)
    {
        MessageFeatures_t MsgType;
        static_assert( sizeof(MsgType) <= sizeof(mBuffer[1]), "!");
        memcpy( &MsgType ,&mBuffer[1], sizeof(mBuffer[1]));
        return MsgType.ReplyLength;
    }
        ClusterAddress_t
    DestinationAddress_Get(void)
    {
        ClusterAddress_t CA;
        memcpy(&CA, &mBuffer[0], sizeof(CA));
        return CA;
    }
        void
    DestinationAddress_Set(ClusterAddress_t CA)
    {
        memcpy(&mBuffer[0], &CA, sizeof(CA));
        return;
    }
        void
    ReplyToAddress_Set(ClusterAddress_t CA)
    {
        memcpy(&mBuffer[2], &CA, sizeof(CA));
        return;
    }
        ClusterAddress_t
    ReplyToAddress_Get(void)
    {
        ClusterAddress_t CA;
        memcpy(&CA, &mBuffer[2], sizeof(CA));
        return CA;
    }
 
        uint32_t
    Header3Address_Get(void)
    {
        uint32_t A;
        memcpy(&A, &mBuffer[3], sizeof(A));
        return A;
    }
        void
    Header3Address_Set(uint32_t A)
    {
        memcpy(&mBuffer[3], &A, sizeof(A));
        return;
    }
        void
    DelayTime_Set(int16_t T)
    {
        MessageFeatures_t MsgType;
        static_assert( sizeof(T) <= sizeof(mBuffer[1]), "!");
        memcpy( &MsgType ,&mBuffer[1], sizeof(mBuffer[1]));
        MsgType.Time = T;
        memcpy(&mBuffer[1],  &MsgType, sizeof(mBuffer[1]));
    }
        int16_t
    DelayTime_Get(void)
    {
            MessageFeatures_t MsgType;
            static_assert( sizeof(MsgType) <= sizeof(mBuffer[1]), "!");
            memcpy( &MsgType ,&mBuffer[1], sizeof(mBuffer[1]));
            return MsgType.Time;
    }
private:
    int32_t mBuffer[4+MAX_IGPCBUFFER_SIZE];   
 
}; // of scIGPMessage
 
#endif // scIGPMessage_h