protocols/motecontrol/MoteMsg.cc

   1 #include "MoteMsg.h"
   2 #include "macros.h"
   3 namespace remote { namespace protocols { namespace motecontrol {
   4
   5 MoteMsg::MoteMsg(uint8_t*& buffer, uint32_t& buflen)
   6 {
   7         buffer = this->read(buffer,buflen);
   8         deleteMsg = true;
   9 }
  10
  11 MoteMsg::MoteMsg(MsgRequest& message)
  12         : type(MOTEMSGTYPE_REQUEST),
  13           message(&message),
  14           deleteMsg(false)
  15 {}
  16
  17 MoteMsg::MoteMsg(MsgConfirm& message)
  18         : type(MOTEMSGTYPE_CONFIRM),
  19           message(&message),
  20           deleteMsg(false)
  21 {}
  22
  23 MoteMsg::MoteMsg(MsgPayload& message)
  24         : type(MOTEMSGTYPE_DATA),
  25           message(&message),
  26           deleteMsg(false)
  27 {}
  28
  29 MoteMsg::~MoteMsg()
  30 {
  31         if (deleteMsg) {delete this->message;}
  32 }
  33
  34
  35 uint32_t MoteMsg::getLength()
  36 {
  37         return sizeof(protocolVersion) + sizeof(type) + message->getLength();
  38 }
  39
  40 uint8_t* MoteMsg::write(uint8_t* buffer, uint32_t& buflen)
  41 {
  42         buffer = writevalue(protocolVersion,buffer,buflen);
  43         buffer = writevalue(type,buffer,buflen);
  44         buffer = message->write(buffer,buflen);
  45         return buffer;
  46 }
  47
  48 uint8_t* MoteMsg::read(uint8_t* buffer, uint32_t& buflen)
  49 {
  50         buffer = readvalue(protocolVersion,buffer,buflen);
  51         // TODO: check protocolVersion
  52         buffer = readvalue(type,buffer,buflen);
  53         switch (type)
  54         {
  55                 case MOTEMSGTYPE_REQUEST:
  56                         message = new MsgRequest(buffer,buflen);
  57                         break;
  58                 case MOTEMSGTYPE_CONFIRM:
  59                         message = new MsgConfirm(buffer,buflen);
  60                         break;
  61                 case MOTEMSGTYPE_DATA:
  62                         message = new MsgPayload(buffer,buflen);
  63                         break;
  64         }
  65         return buffer;
  66 }
  67
  68 void MoteMsg::print(FILE* s)
  69 {
  70         fprintf(s,"MESSAGE MoteMsg\n");
  71         fprintf(s,"protocolVersion: %u\n",protocolVersion);
  72         fprintf(s,"type: ");
  73         switch (type)
  74         {
  75                 case MOTEMSGTYPE_REQUEST:
  76                         fprintf(s,"MOTEMSGTYPE_REQUEST\n");
  77                         break;
  78                 case MOTEMSGTYPE_CONFIRM:
  79                         fprintf(s,"MOTEMSGTYPE_CONFIRM\n");
  80                         break;
  81                 case MOTEMSGTYPE_DATA:
  82                         fprintf(s,"MOTEMSGTYPE_DATA\n");
  83                         break;
  84                 default:
  85                         fprintf(s,"Invalid type!\n");
  86         }
  87         message->print(s);
  88 }
  89
  90 uint32_t MoteMsg::getProtocolVersion()
  91 {
  92         return protocolVersion;
  93 }
  94
  95 uint8_t MoteMsg::getType()
  96 {
  97         return type;
  98 }
  99
 100 MsgRequest& MoteMsg::getRequest()
 101 {
 102         if (type != MOTEMSGTYPE_REQUEST)
 103                 __THROW__ ("Cannot getRequest when type is not MOTEMSGTYPE_REQUEST!");
 104         return *((MsgRequest*)message);
 105 }
 106
 107 MsgConfirm& MoteMsg::getConfirm()
 108 {
 109         if (type != MOTEMSGTYPE_CONFIRM)
 110                 __THROW__ ("Cannot getConfirm when type is not MOTEMSGTYPE_CONFIRM!");
 111         return *((MsgConfirm*)message);
 112 }
 113
 114 MsgPayload& MoteMsg::getData()
 115 {
 116         if (type != MOTEMSGTYPE_DATA)
 117                 __THROW__ ("Cannot getData when type is not MOTEMSGTYPE_DATA!");
 118         return *((MsgPayload*)message);
 119 }
 120 }}}