1

     2

#include <cassert>

     3

     4

#include "NetworkPacket.hh"

     5

     6

     7

NetworkPacket::NetworkPacket (void) :

     8

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

     9

    10

    // nothing

    11

}

    12

    13

void NetworkPacket::check_write_size (size_t item_size) {

    14

     if (offset + item_size > buf_size)

    15

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

    16

    17

}

    18

    19

void NetworkPacket::check_read_size (size_t item_size) {

    20

    if (offset + item_size > data_size)

    21

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

    22

}

    23

    24

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

    25

    // check buffer overflow

    26

    check_write_size(len);

    27

    28

    // set value

    29

    memcpy(buf + offset, ptr, len);

    30

    31

    // update offset and size

    32

    offset += len;

    33

    data_size += len;

    34

}

    35

    36

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

    37

    // check buffer underflow

    38

    check_read_size(len);

    39

    40

    // set value

    41

    memcpy(ptr, buf + offset, len);

    42

    43

    // update offset

    44

    offset += len;

    45

}

    46

    47

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

    48

    T val;

    49

    50

    // read

    51

    read(&val, sizeof(T));

    52

    53

    // return

    54

    return val;

    55

}

    56

    57

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

    58

    // write

    59

    write(&val, sizeof(T));

    60

}

    61

    62

uint32_t NetworkPacket::read_uint32 (void) {

    63

    return ntohl(read_val<uint32_t>());

    64

}

    65

    66

uint16_t NetworkPacket::read_uint16 (void) {

    67

    return ntohs(read_val<uint16_t>());

    68

}

    69

    70

uint8_t NetworkPacket::read_uint8 (void) {

    71

    return read_val<uint8_t>();

    72

}

    73

    74

int32_t NetworkPacket::read_int32 (void) {

    75

    return ntohl(read_val<int32_t>());

    76

}

    77

    78

int16_t NetworkPacket::read_int16 (void) {

    79

    return ntohs(read_val<int16_t>());

    80

}

    81

    82

int8_t NetworkPacket::read_int8 (void) {

    83

    return read_val<int8_t>();

    84

}

    85

    86

float NetworkPacket::read_float32 (void) {

    87

    int32_t ival = read_int32();

    88

    89

    return *((float *) &ival);

    90

}

    91

    92

Vector NetworkPacket::read_vector (void) {

    93

    float fx = read_float32();

    94

    float fy = read_float32();

    95

    96

    return Vector(fx, fy);

    97

}

    98

    99

void NetworkPacket::write_uint32 (uint32_t val) {

   100

    write_val<uint32_t>(htonl(val));

   101

}

   102

   103

void NetworkPacket::write_uint16 (uint16_t val) {

   104

    write_val<uint16_t>(htons(val));

   105

}

   106

   107

void NetworkPacket::write_uint8 (uint8_t val) {

   108

    write_val<uint8_t>(val);

   109

}

   110

   111

void NetworkPacket::write_int32 (int32_t val) {

   112

    write_val<int32_t>(htonl(val));

   113

}

   114

   115

void NetworkPacket::write_int16 (int16_t val) {

   116

    write_val<int16_t>(htons(val));

   117

}

   118

   119

void NetworkPacket::write_int8 (int8_t val) {

   120

    write_val<int8_t>(val);

   121

}

   122

   123

void NetworkPacket::write_float32 (float val) {

   124

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

   125

}

   126

   127

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

   128

    write_float32(vec.x);

   129

    write_float32(vec.y);

   130

}

   131

   132

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

   133

    // check buffer size

   134

    check_write_size(pkt.get_data_size());

   135

   136

    // copy

   137

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

   138

   139

    // update offset/data_size

   140

    offset += pkt.get_data_size();

   141

    data_size += pkt.get_data_size();

   142

}

   143