1 #include "mtag-buffer.h"

     2 #include "ns3/assert.h"

     3 

     4 namespace ns3 {

     5 

     6 void 

     7 TagBuffer::WriteU8 (uint8_t v)

     8 {

     9   NS_ASSERT (m_current + 1 <= m_end);

    10   *m_current = v;

    11   m_current++;

    12 }

    13 void 

    14 TagBuffer::WriteU16 (uint16_t data)

    15 {

    16   WriteU8 ((data >> 0) & 0xff);

    17   WriteU8 ((data >> 8) & 0xff);

    18 }

    19 void 

    20 TagBuffer::WriteU32 (uint32_t data)

    21 {

    22   WriteU8 ((data >> 0) & 0xff);

    23   WriteU8 ((data >> 8) & 0xff);

    24   WriteU8 ((data >> 16) & 0xff);

    25   WriteU8 ((data >> 24) & 0xff);

    26 }

    27 void 

    28 TagBuffer::WriteU64 (uint64_t data)

    29 {

    30   WriteU8 ((data >> 0) & 0xff);

    31   WriteU8 ((data >> 8) & 0xff);

    32   WriteU8 ((data >> 16) & 0xff);

    33   WriteU8 ((data >> 24) & 0xff);

    34   WriteU8 ((data >> 32) & 0xff);

    35   WriteU8 ((data >> 40) & 0xff);

    36   WriteU8 ((data >> 48) & 0xff);

    37   WriteU8 ((data >> 54) & 0xff);

    38 }

    39 void

    40 TagBuffer::WriteDouble (double v)

    41 {

    42   uint8_t *buf = (uint8_t *)&v;

    43   for (uint32_t i = 0; i < sizeof (double); ++i, ++buf)

    44     {

    45       WriteU8 (*buf);

    46     }

    47 }

    48 void 

    49 TagBuffer::Write (const uint8_t *buffer, uint32_t size)

    50 {

    51   for (uint32_t i = 0; i < size; ++i, ++buffer)

    52     {

    53       WriteU8 (*buffer);

    54     }

    55 }

    56 uint8_t  

    57 TagBuffer::ReadU8 (void)

    58 {

    59   NS_ASSERT (m_current + 1 <= m_end);

    60   uint8_t v;

    61   v = *m_current;

    62   m_current++;

    63   return v;

    64 }

    65 uint16_t 

    66 TagBuffer::ReadU16 (void)

    67 {

    68   uint8_t byte0 = ReadU8 ();

    69   uint8_t byte1 = ReadU8 ();

    70   uint16_t data = byte1;

    71   data <<= 8;

    72   data |= byte0;

    73   return data;

    74 }

    75 uint32_t 

    76 TagBuffer::ReadU32 (void)

    77 {

    78   uint8_t byte0 = ReadU8 ();

    79   uint8_t byte1 = ReadU8 ();

    80   uint8_t byte2 = ReadU8 ();

    81   uint8_t byte3 = ReadU8 ();

    82   uint32_t data = byte3;

    83   data <<= 8;

    84   data |= byte2;

    85   data <<= 8;

    86   data |= byte1;

    87   data <<= 8;

    88   data |= byte0;

    89   return data;

    90 }

    91 uint64_t 

    92 TagBuffer::ReadU64 (void)

    93 {

    94   uint8_t byte0 = ReadU8 ();

    95   uint8_t byte1 = ReadU8 ();

    96   uint8_t byte2 = ReadU8 ();

    97   uint8_t byte3 = ReadU8 ();

    98   uint8_t byte4 = ReadU8 ();

    99   uint8_t byte5 = ReadU8 ();

   100   uint8_t byte6 = ReadU8 ();

   101   uint8_t byte7 = ReadU8 ();

   102   uint32_t data = byte7;

   103   data <<= 8;

   104   data |= byte6;

   105   data <<= 8;

   106   data |= byte5;

   107   data <<= 8;

   108   data |= byte4;

   109   data <<= 8;

   110   data |= byte3;

   111   data <<= 8;

   112   data |= byte2;

   113   data <<= 8;

   114   data |= byte1;

   115   data <<= 8;

   116   data |= byte0;

   117 

   118   return data;

   119 }

   120 double

   121 TagBuffer::ReadDouble (void)

   122 {

   123   double v;

   124   uint8_t *buf = (uint8_t *)&v;

   125   for (uint32_t i = 0; i < sizeof (double); ++i, ++buf)

   126     {

   127       *buf = ReadU8 ();

   128     }

   129   return v;

   130 }

   131 void 

   132 TagBuffer::Read (uint8_t *buffer, uint32_t size)

   133 {

   134   for (uint32_t i = 0; i < size; ++i, ++buffer)

   135     {

   136       *buffer = ReadU8 ();

   137     }

   138 }

   139 TagBuffer::TagBuffer (uint8_t *start, uint8_t *end)

   140   : m_current (start),

   141     m_end (end)

   142 {}

   143 

   144 void 

   145 TagBuffer::TrimAtEnd (uint32_t trim)

   146 {

   147   NS_ASSERT (m_current <= (m_end - trim));

   148   m_end -= trim;

   149 }

   150 

   151 void 

   152 TagBuffer::CopyFrom (TagBuffer o)

   153 {

   154   uint32_t size = o.m_end - o.m_current;

   155   NS_ASSERT (size <= m_end - m_current);

   156   memcpy (m_current, o.m_current, size);

   157   m_current += size;

   158 }

   159 

   160 } // namespace ns3