1 

     2 #include <cassert>

     3 #include <cstring>

     4 

     5 #include "NetworkPacket.hh"

     6 

     7 

     8 NetworkPacket::NetworkPacket (void) :

     9     buf_size(NETWORK_PACKET_SIZE), data_size(0), offset(0) {

    10     

    11     // nothing

    12 }

    13 

    14 void NetworkPacket::check_write_size (size_t item_size) {

    15      if (offset + item_size > buf_size)

    16         throw NetworkPacketError("not enough space to write");

    17 

    18 }

    19         

    20 void NetworkPacket::check_read_size (size_t item_size) {

    21     if (offset + item_size > data_size)

    22         throw NetworkPacketError("not enough data to read");

    23 }

    24 

    25 void NetworkPacket::write (const void *ptr, size_t len) {

    26     // check buffer overflow

    27     check_write_size(len);

    28 

    29     // set value

    30     memcpy(buf + offset, ptr, len);

    31 

    32     // update offset and size

    33     offset += len;

    34     data_size += len;

    35 }

    36 

    37 void NetworkPacket::read (void *ptr, size_t len) {

    38     // check buffer underflow

    39     check_read_size(len);

    40 

    41     // set value

    42     memcpy(ptr, buf + offset, len);

    43 

    44     // update offset

    45     offset += len;

    46 }

    47 

    48 template <typename T> T NetworkPacket::read_val (void) {

    49     T val;

    50 

    51     // read

    52     read(&val, sizeof(T));

    53 

    54     // return

    55     return val;

    56 }

    57 

    58 template <typename T> void NetworkPacket::write_val (const T &val) {

    59     // write

    60     write(&val, sizeof(T));

    61 }

    62 

    63 uint32_t NetworkPacket::read_uint32 (void) {

    64     return ntohl(read_val<uint32_t>());

    65 }

    66 

    67 uint16_t NetworkPacket::read_uint16 (void) {

    68     return ntohs(read_val<uint16_t>());

    69 }

    70 

    71 uint8_t NetworkPacket::read_uint8 (void) {

    72     return read_val<uint8_t>();

    73 }

    74 

    75 int32_t NetworkPacket::read_int32 (void) {

    76     return ntohl(read_val<int32_t>());

    77 }

    78 

    79 int16_t NetworkPacket::read_int16 (void) {

    80     return ntohs(read_val<int16_t>());

    81 }

    82 

    83 int8_t NetworkPacket::read_int8 (void) {

    84     return read_val<int8_t>();

    85 }

    86         

    87 float NetworkPacket::read_float32 (void) {

    88     int32_t ival = read_int32();

    89 

    90     return *((float *) &ival);

    91 }

    92 

    93 Vector NetworkPacket::read_vector (void) {

    94     float fx = read_float32();

    95     float fy = read_float32();

    96 

    97     return Vector(fx, fy);

    98 }

    99 

   100 void NetworkPacket::write_uint32 (uint32_t val) {

   101     write_val<uint32_t>(htonl(val));

   102 }

   103 

   104 void NetworkPacket::write_uint16 (uint16_t val) {

   105     write_val<uint16_t>(htons(val));

   106 }

   107 

   108 void NetworkPacket::write_uint8 (uint8_t val) {

   109     write_val<uint8_t>(val);

   110 }

   111 

   112 void NetworkPacket::write_int32 (int32_t val) {

   113     write_val<int32_t>(htonl(val));

   114 }

   115 

   116 void NetworkPacket::write_int16 (int16_t val) {

   117     write_val<int16_t>(htons(val));

   118 }

   119 

   120 void NetworkPacket::write_int8 (int8_t val) {

   121     write_val<int8_t>(val);

   122 }

   123         

   124 void NetworkPacket::write_float32 (float val) {

   125     write_int32(*((int32_t *) &val));

   126 }

   127 

   128 void NetworkPacket::write_vector (const Vector &vec) {

   129     write_float32(vec.x);

   130     write_float32(vec.y);

   131 }

   132 

   133 void NetworkPacket::write_packet (const NetworkPacket &pkt) {

   134     // check buffer size

   135     check_write_size(pkt.get_data_size());

   136 

   137     // copy

   138     memcpy(buf + offset, pkt.get_buf(), pkt.get_data_size());

   139 

   140     // update offset/data_size

   141     offset += pkt.get_data_size();

   142     data_size += pkt.get_data_size();

   143 }

   144