protocols/MsgPayload.cc

   1 #include "MsgPayload.h"
   2 #include "macros.h"
   3 namespace remote { namespace protocols {
   4
   5 MsgPayload::MsgPayload(uint8_t*& buffer, uint32_t& buflen)
   6 {
   7         data = NULL;
   8         buffer = this->read(buffer,buflen);
   9 }
  10
  11 MsgPayload::MsgPayload()
  12 {
  13         data = NULL;
  14         length = 0;
  15 }
  16
  17 MsgPayload::MsgPayload(const MsgPayload& o)
  18 {
  19         data = NULL;
  20         setPayload(o.length,o.data);
  21 }
  22
  23 MsgPayload::MsgPayload(const std::string& str)
  24 {
  25         data = NULL;
  26         setPayload(str.length(),(uint8_t*)(str.c_str()));
  27 }
  28
  29 MsgPayload::MsgPayload(BaseMsg& baseMsg)
  30 {
  31         length = baseMsg.getLength();
  32         data = new uint8_t[length];
  33         uint32_t len = length;
  34         baseMsg.write(data,len);
  35 }
  36
  37 MsgPayload::~MsgPayload()
  38 {
  39         if (data)
  40         {
  41                 delete data;
  42                 data = 0;
  43         }
  44 }
  45
  46 const MsgPayload& MsgPayload::operator = (const MsgPayload& o)
  47 {
  48         setPayload(o.length,o.data);
  49         return *this;
  50 }
  51
  52 const MsgPayload& MsgPayload::operator = (const std::string& s)
  53 {
  54         setPayload(s.length(),(uint8_t*)(s.c_str()));
  55         return *this;
  56 }
  57
  58 uint32_t MsgPayload::getLength()
  59 {
  60         return sizeof(length)+length;
  61 }
  62
  63 uint8_t* MsgPayload::read(uint8_t* buffer, uint32_t& buflen)
  64 {
  65         buffer = readvalue(length,buffer,buflen);
  66         if (length > buflen)
  67         {
  68                 log("Payload length %u greater than buffer length %u!\n",length,buflen);
  69                 __THROW__ ("Payload length greater than buffer length!");
  70         }
  71
  72         if (data)
  73         {
  74                 delete data;
  75                 data = 0;
  76         }
  77
  78         if ( length > 0 )
  79         {
  80                 data = new uint8_t[length];
  81
  82                 memcpy(data,buffer,length);
  83                 buffer+=length;
  84                 buflen-=length;
  85         }
  86
  87         return buffer;
  88 }
  89
  90 uint8_t* MsgPayload::write(uint8_t* buffer, uint32_t& buflen)
  91 {
  92         buffer = writevalue(length,buffer,buflen);
  93
  94         if (length > buflen)
  95         {
  96                 __THROW__ ("Payload length longer than buffer!");
  97         }
  98
  99         if ( length > 0 )
 100         {
 101                 memcpy(buffer,data,length);
 102                 buffer+=length;
 103                 buflen-=length;
 104         }
 105         return buffer;
 106 }
 107
 108 void MsgPayload::print(_IO_FILE* s)
 109 {
 110         fprintf(s,"MESSAGE MsgPayload\n");
 111         fprintf(s,"length: %u\n",length);
 112 }
 113
 114 void MsgPayload::setPayload(uint32_t p_length, const uint8_t* p_data)
 115 {
 116         if (data)
 117         {
 118                 delete data;
 119         }
 120         length = p_length;
 121         data = new uint8_t[length];
 122         memcpy(data,p_data,length);
 123 }
 124
 125 std::string MsgPayload::getString()
 126 {
 127         if (data)
 128         {
 129                 return std::string((char*)data,length);
 130         }
 131         else
 132         {
 133                 return std::string("");
 134         }
 135 }
 136
 137 uint32_t MsgPayload::getDataLength()
 138 {
 139         return length;
 140 }
 141
 142 const uint8_t* MsgPayload::getData()
 143 {
 144         return data;
 145 }
 146
 147 }}