#include <cassert>
#include <cstring>
#include "Packet.hh"
// XXX: assumes that sizeof(float32) == sizeof(int32);
/*
* NetworkPacketInput
*/
template <typename T> T NetworkPacketInput::read_val (void) {
T val;
// read
read(&val, sizeof(T));
// return
return val;
}
uint32_t NetworkPacketInput::read_uint32 (void) {
return ntohl(read_val<uint32_t>());
}
uint16_t NetworkPacketInput::read_uint16 (void) {
return ntohs(read_val<uint16_t>());
}
uint8_t NetworkPacketInput::read_uint8 (void) {
return read_val<uint8_t>();
}
int32_t NetworkPacketInput::read_int32 (void) {
return ntohl(read_val<int32_t>());
}
int16_t NetworkPacketInput::read_int16 (void) {
return ntohs(read_val<int16_t>());
}
int8_t NetworkPacketInput::read_int8 (void) {
return read_val<int8_t>();
}
float NetworkPacketInput::read_float32 (void) {
int32_t ival = read_int32();
float fval;
assert(sizeof(ival) == sizeof(fval));
memcpy(&fval, &ival, sizeof(float));
return fval;
}
Vector NetworkPacketInput::read_vector (void) {
float fx = read_float32();
float fy = read_float32();
return Vector(fx, fy);
}
/*
* NetworkPacketOutput
*/
template <typename T> void NetworkPacketOutput::write_val (const T &val) {
// write
write(&val, sizeof(T));
}
void NetworkPacketOutput::write_uint32 (uint32_t val) {
write_val<uint32_t>(htonl(val));
}
void NetworkPacketOutput::write_uint16 (uint16_t val) {
write_val<uint16_t>(htons(val));
}
void NetworkPacketOutput::write_uint8 (uint8_t val) {
write_val<uint8_t>(val);
}
void NetworkPacketOutput::write_int32 (int32_t val) {
write_val<int32_t>(htonl(val));
}
void NetworkPacketOutput::write_int16 (int16_t val) {
write_val<int16_t>(htons(val));
}
void NetworkPacketOutput::write_int8 (int8_t val) {
write_val<int8_t>(val);
}
void NetworkPacketOutput::write_float32 (float fval) {
int32_t ival;
assert(sizeof(ival) == sizeof(fval));
memcpy(&ival, &fval, sizeof(int32_t));
write_int32(ival);
}
void NetworkPacketOutput::write_vector (const Vector &vec) {
write_float32(vec.x);
write_float32(vec.y);
}
void NetworkPacketOutput::write_packet (const NetworkPacketBuffer &pkt) {
// just write() it
write(pkt.get_buf(), pkt.get_data_size());
}
/*
* NetworkPacketBuffer
*/
NetworkPacketBuffer::NetworkPacketBuffer (char *buf_ptr, size_t buf_size, size_t data_size) :
buf_ptr(buf_ptr), buf_size(buf_size), data_size(data_size), offset(0) {
// nothing
if (buf_ptr == NULL)
throw NetworkPacketError("buf_ptr may not be NULL");
}
void NetworkPacketBuffer::check_write_size (size_t item_size) {
if (offset + item_size > buf_size)
throw NetworkPacketError("not enough space to write");
}
void NetworkPacketBuffer::check_read_size (size_t item_size) {
if (offset + item_size > data_size)
throw NetworkPacketError("not enough data to read");
}
void NetworkPacketBuffer::write (const void *ptr, size_t len) {
// check buffer overflow
check_write_size(len);
// set value
memcpy(buf_ptr + offset, ptr, len);
// update offset and size
offset += len;
data_size += len;
}
void NetworkPacketBuffer::read (void *ptr, size_t len) {
// check buffer underflow
check_read_size(len);
// set value
memcpy(ptr, buf_ptr + offset, len);
// update offset
offset += len;
}
/*
* NetworkPacket
*/
NetworkPacket::NetworkPacket (void) :
NetworkPacketBuffer(_buf, NETWORK_PACKET_SIZE, 0)
{
}
/*
* BigNetworkPacket
*/
BigNetworkPacket::BigNetworkPacket (size_t size) :
NetworkPacketBuffer((char *) malloc(size), size, 0)
{
}
BigNetworkPacket::~BigNetworkPacket (void) {
free(buf_ptr);
}