1

     2

#include "NetworkPacket.hh"

     3

     4

     5

NetworkPacket::NetworkPacket (void) :

     7

     8

    // nothing

     9

}

    10

    11

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

    12

    T val;

    13

    14

    // check size

    15

    if (offset + sizeof(T) > size)

    16

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

    17

    18

    // set value

    19

    val = *((T*) (buf + offset));

    20

    21

    // update offset

    22

    offset += sizeof(T);

    23

    24

    // return

    25

    return val;

    26

}

    27

    28

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

    29

    // check max size

    30

    if (offset + sizeof(T) > NETWORK_PACKET_SIZE)

    31

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

    32

    33

    // set value

    34

    *((T*) (buf + offset)) = val;

    35

    36

    // update offset and size

    37

    offset += sizeof(T);

    38

    size += sizeof(T);

    39

}

    40

    41

uint32_t NetworkPacket::read_uint32 (void) {

    42

    return ntohl(read_val<uint32_t>());

    43

}

    44

    45

uint16_t NetworkPacket::read_uint16 (void) {

    46

    return ntohs(read_val<uint16_t>());

    47

}

    48

    49

uint8_t NetworkPacket::read_uint8 (void) {

    50

    return read_val<uint8_t>();

    51

}

    52

    53

int32_t NetworkPacket::read_int32 (void) {

    54

    return ntohl(read_val<int32_t>());

    55

}

    56

    57

int16_t NetworkPacket::read_int16 (void) {

    58

    return ntohs(read_val<int16_t>());

    59

}

    60

    61

int8_t NetworkPacket::read_int8 (void) {

    62

    return read_val<int8_t>();

    63

}

    64

    65

void NetworkPacket::write_uint32 (uint32_t val) {

    66

    write_val<uint32_t>(htonl(val));

    67

}

    68

    69

void NetworkPacket::write_uint16 (uint16_t val) {

    70

    write_val<uint16_t>(htons(val));

    71

}

    72

    73

void NetworkPacket::write_uint8 (uint8_t val) {

    74

    write_val<uint8_t>(val);

    75

}

    76

    77

void NetworkPacket::write_int32 (int32_t val) {

    78

    write_val<int32_t>(htonl(val));

    79

}

    80

    81

void NetworkPacket::write_int16 (int16_t val) {

    82

    write_val<int16_t>(htons(val));

    83

}

    84

    85

void NetworkPacket::write_int8 (int8_t val) {

    86

    write_val<int8_t>(val);

    87

}

    88