Packet Container Class

I've been wanting to start a little side project which would be a small networking wrapper around enet. To get started I worked on creating this Packet class which would wrap all the data sent and received providing easy methods to add and retrieve the data. I did get the class working with char, c-strings, and std::strings but after trying to add support for integer types it hasn't worked so well. The class is based on code code from irrNetLite but I was trying to do it without the dependencies on the irrlicht types such as irr::array.

Here is the header file for the class:

LPacket.h

Code:

---

// BEGIN Includes
#include "LTypes.h"

#include <string>
#include <vector>
// END Includes

#ifndef LPACKET_H
#define LPACKET_H

class LPacket {

        public:
       
                LPacket();
                LPacket(const char* buff, const unsigned int buffSize);
               
                // Methods to append data to the packet
               
                LPacket& operator << (c8 data);
               
                LPacket& operator << (u8 data);
                LPacket& operator << (u16 data);
                LPacket& operator << (u32 data);
               
                LPacket& operator << (s8 data);
                LPacket& operator << (s16 data);
                LPacket& operator << (s32 data);
               
                LPacket& operator << (f32 data);
                LPacket& operator << (f64 data);
               
                LPacket& operator << (c8* data);
                LPacket& operator << (std::string& data);
               
                LPacket& operator << (LPacket& data);
               
                // Methods to retrieve data from the packet
               
                void operator >> (c8& data);
               
                void operator >> (u8& data);
                void operator >> (u16& data);
                void operator >> (u32& data);
               
                void operator >> (s8& data);
                void operator >> (s16& data);
                void operator >> (s32& data);
               
                void operator >> (f32& data);
                void operator >> (f64& data);
               
                void operator >> (c8* data);
                void operator >> (std::string& data);
               
                /**
                * Retrieve that packet's data.
                *
                * @return char*
                */
                c8* getData();
               
                /**
                * Retrieve that packet's data.
                *
                * @return const char*
                */
                const c8* getConstData();
               
                /**
                * Reset the internal read position.
                */
                void resetPos();
               
               
                /**
                * Clear the packet contents.
                */
                void clearData();
               
                /**
                * Retrieve the size in bytes of the packet.
                *
                * @return unsigned int
                */
                u32 getSize();
               
        private:
                       
                /**
                * Position in packet.
                *
                * @var unsigned
                */
                u32 pos;
               
                /**
                * Packet contents.
                *
                * @var std::vector<char>
                */
                std::vector<u8> buffer;       

};

#endif /* LPACKET_H */

---

Here is the CPP file for the class:

Code:

---

// BEGIN Includes
#include "LPacket.h"

#include <memory.h>
#include <stdio.h>
#include <iostream>
// END Includes

#ifndef LPACKET_CPP
#define LPACKET_CPP

/**
 * Default constructor.
 */
LPacket::LPacket() {

        this->pos = 0;
       
}

/**
 * Contructor.
 *
 * @param const char* buff Intial buffer contents.
 * @param const unsigned int buffSize Inital buffer size.
 */
LPacket::LPacket(const char* buff, const unsigned int buffSize) {

        // @TODO: Implement
       
        this->pos = 0;

}

/**
 * Operator method to append data.
 */
LPacket& LPacket::operator << (c8 data) {

        // Append data
        std::copy(&data, &data + 1, std::back_inserter(this->buffer));

        return *this;

}

/**
 * Operator method to append data.
 */
LPacket& LPacket::operator << (u8 data) {

        // Append data
        std::copy(&data, &data + 1, std::back_inserter(this->buffer));

        return *this;

}

/**
 * Operator method to append data.
 */
LPacket& LPacket::operator << (u16 data) {
       
        // Append data
        std::copy(&data, &data + 2, std::back_inserter(this->buffer));

        return *this;

}

/**
 * Operator method to append data.
 */
LPacket& LPacket::operator << (u32 data) {

        // Append data
        std::copy(&data, &data + 4, std::back_inserter(this->buffer));

        return *this;

}

/**
 * Operator method to append data.
 */
LPacket& LPacket::operator << (s8 data) {

        // Append data
        std::copy(&data, &data + 1, std::back_inserter(this->buffer));

        return *this;

}

/**
 * Operator method to append data.
 */
LPacket& LPacket::operator << (s16 data) {

        // Append data
        std::copy(&data, &data + 2, std::back_inserter(this->buffer));
       
        return *this;

}

/**
 * Operator method to append data.
 */
LPacket& LPacket::operator << (s32 data) {

        // Append data
        std::copy(&data, &data + 4, std::back_inserter(this->buffer));
       
        return *this;

}

/**
 * Operator method to append data.
 */
LPacket& LPacket::operator << (f32 data) {

        // Append data
        std::copy(&data, &data + 4, std::back_inserter(this->buffer));
       
        return *this;

}

/**
 * Operator method to append data.
 */
LPacket& LPacket::operator << (f64 data) {

        // Append data
        std::copy(&data, &data + 8, std::back_inserter(this->buffer));
       
        return *this;

}

/**
 * Operator method to append data.
 */
LPacket& LPacket::operator << (c8* data) {

        unsigned short dataSize = (unsigned short)strlen(data) + 1;

        // Append data size
        std::copy(&dataSize, &dataSize + 2, std::back_inserter(this->buffer));
       
        // Append data
        std::copy(&data[0], &data[0] + dataSize, std::back_inserter(this->buffer));
       
        return *this;

}

/**
 * Operator method to append data.
 */
LPacket& LPacket::operator << (std::string& data) {

        unsigned short dataSize = (unsigned short)data.size();

        // Append data size
        std::copy(&dataSize, &dataSize + 2, std::back_inserter(this->buffer));
       
        // Append data
        std::copy(&data[0], &data[0] + dataSize, std::back_inserter(this->buffer));
       
        return *this;

}

/**
 * Operator method to append data.
 */
LPacket& LPacket::operator << (LPacket& data) {

        // Append packet
        std::copy(data.getData(), data.getData() + data.getSize(), std::back_inserter(this->buffer));
       
        return *this;

}

/**
 * Operator method to retrieve data.
 */
void LPacket::operator >> (c8& data) {

        // Retrieve data
        std::copy(&this->buffer[0] + pos, &this->buffer[0] + pos + 1, &data);
        pos++;
       
}

/**
 * Operator method to retrieve data.
 */
void LPacket::operator >> (u8& data) {

        // Retrieve data
        std::copy(&this->buffer[0] + pos, &this->buffer[0] + pos + 1, &data);
        pos++;

}

/**
 * Operator method to retrieve data.
 */
void LPacket::operator >> (u16& data) {

        // Retrieve data
        std::copy(&this->buffer[0] + pos, &this->buffer[0] + pos + 2, &data);
        pos += 2;
       
}

/**
 * Operator method to retrieve data.
 */
void LPacket::operator >> (u32& data) {

        // Retrieve data
        std::copy(&this->buffer[0] + pos, &this->buffer[0] + pos + 4, &data);
        pos += 4;
       
}

/**
 * Operator method to retrieve data.
 */
void LPacket::operator >> (s8& data) {

        // Retrieve data
        std::copy(&this->buffer[0] + pos, &this->buffer[0] + pos + 1, &data);
        pos++;
       
}

/**
 * Operator method to retrieve data.
 */
void LPacket::operator >> (s16& data) {

        // Retrieve data
        std::copy(&this->buffer[0] + pos, &this->buffer[0] + pos + 2, &data);
        pos += 2;

}

/**
 * Operator method to retrieve data.
 */
void LPacket::operator >> (s32& data) {

        // Retrieve data
        std::copy(&this->buffer[0] + pos, &this->buffer[0] + pos + 4, &data);
        pos += 4;

}

/**
 * Operator method to retrieve data.
 */
void LPacket::operator >> (f32& data) {

        // Retrieve data
        std::copy(&this->buffer[0] + pos, &this->buffer[0] + pos + 4, &data);
        pos += 4;

}

/**
 * Operator method to retrieve data.
 */
void LPacket::operator >> (f64& data) {

        // Retrieve data
        std::copy(&this->buffer[0] + pos, &this->buffer[0] + pos + 8, &data);
        pos += 8;

}

/**
 * Operator method to retrieve data.
 */
void LPacket::operator >> (c8* data) {

        // Retrieve data size
        unsigned short size;
        std::copy(&this->buffer[0] + pos, &this->buffer[0] + pos + 2, &size);
        pos += 2;
       
        // Retrieve data
        std::copy(&this->buffer[0] + pos, &this->buffer[0] + pos + size, data);
        pos += size;
       
        data[size] = '\0';

}

/**
 * Operator method to retrieve data.
 */
void LPacket::operator >> (std::string &data) {

        // Retrieve data size
        unsigned short size;
        std::copy(&this->buffer[0] + pos, &this->buffer[0] + pos + 2, &size);
        pos += 2;
       
        // Retrieve data
        std::copy(&this->buffer[0] + pos, &this->buffer[0] + pos + size, std::back_inserter(data));
        pos += size;
       
        data.append("\0");
       
}

/**
 * Retrieve that packet's data.
 *
 * @return char*
 */
c8* LPacket::getData() {

        return (c8*)&this->buffer[0];

}

/**
 * Retrieve that packet's data.
 *
 * @return const char*
 */
const c8* LPacket::getConstData() {

        return (const c8*)&this->buffer[0];

}

/**
 * Reset the internal read position.
 */
void LPacket::resetPos() {

        pos = 0;

}

/**
 * Clear the packet contents.
 */
void LPacket::clearData() {

        this->buffer.clear();

}

/**
 * Retrieve the size in bytes of the packet.
 *
 * @return unsigned int
 */
u32 LPacket::getSize() {

        return this->buffer.size();

}

#endif /* LPACKET_CPP */

---

Here is the header file for types:

LTypes.h

Code:

---

// BEGIN Includes
// END Includes

#ifndef LTYPES_H
#define LTYPES_H

/**
 * 8 bit unsigned variable.
 */

typedef unsigned char u8;

/**
 * 8 bit signed variable.
 */

typedef signed char s8;

/**
 * 8 bit character variable.
 */

typedef char c8;


/**
 * 16 bit signed variable.
 */

typedef unsigned short u16;

/**
 * 16 bit signed variable.
 */

typedef signed short s16;


/**
 * 32 bit unsigned variable.
 */

typedef unsigned int u32;



/**
 * 32 bit signed variable.
 */

typedef signed int s32;

/**
 * 32 bit signed variable.
 *
 * Unused and supposedly only supported by Microsoft compilers, thus commented out.
 */

//typedef __int64 s64;



/**
 * 32 bit floating point variable.
 */

typedef float f32;



/**
 * 64 bit floating point variable.
 */

typedef double f64;

#endif /* LTYPES_H */

---

and finally here is the testing code:

Code:

---

#include "LPacket.h"
#include <stdio.h>
#include <iostream>
#include <string>
#include <memory.h>
int main(int argc, char **argv) {

        // Declare our packet object
        LPacket packet;
       
        // Prepare some data to add to the packet
        std::string s1 = "This is a string!";
        std::string s2 = "This had better.";
        char cS[21] = "C-Style strings!";
        c8 c = 'i';
        u32 i1 = 1024;
        u16 i2 = 256;
       
        // Add the data to the packet
        packet << s1 << s2 << 'h';
        packet << cS;
        packet << c;
        packet << i1;
        packet << i2;

///

        std::string rS1, rS2;
        char rC1;
        char rCS[21];
        c8 rC2;
        u32 rI1;
        u16 rI2;
       
        // Get the data from the packet
        packet >> rS1;
        packet >> rS2;
        packet >> rC1;
        packet >> rCS;
        packet >> rC2;
        packet >> rI1;
        packet >> rI2;
       
        // Output the recieved data
        std::cout << "String - " << rS1 << std::endl;
        std::cout << "String - " << rS2 << std::endl;
        std::cout << "char  - " << rC1 << std::endl;
        std::cout << "char*  - " << rCS << std::endl;
        std::cout << "char  - " << rC2 << std::endl;
        std::cout << "u32    - " << rI1 << std::endl;
        std::cout << "u16    - " << rI2 << std::endl;

        return 0;

}

---

Expected output should be like so:

Code:

---

String - This is a string!
String - This had better.
char  - h
char*  - C-Style strings!
char  - i
u32    - 1024
u16    - 256

---

Instead I get:

Code:

---

String - This is a string!
String - This had better.
char  - h
char*  - C-Style strings!
char  -
u32    - 0
u16    - 0

---

An interesting thing I noticed when I tried to use GDB to debug (never really used it before though) was that initially the call to packet >> rC2; would work correctly and set rC2 to 'i', but after the call to packet >> rI1; or packet >> rI2; it would somehow change into some "garbage" value. I'm quite confused as to why that would happen.

I also compiled with: gcc version 4.4.5 (Ubuntu/Linaro 4.4.4-14ubuntu5)

Thus, if anyone could assist me with this I would be utterly grateful,
thanks in advance.

There is quite a substantial amount of code in your post and I haven't read it all yet, but I think I may know what the problem is.

From your main.cpp:

Code:

---

c8 c = 'i';
u32 i1 = 1024;
u16 i2 = 256;

/* A few extra bits and bobs in between */

packet << c;
packet << i1;
packet << i2;

packet >> rC2;
packet >> rI1;
packet >> rI2;

---

From your LPacket.h:

Code:

---

LPacket& operator << (c8 data);
LPacket& operator << (u8 data);
LPacket& operator << (u16 data);
LPacket& operator << (u32 data);

void operator >> (c8& data);
void operator >> (u8& data);
void operator >> (u16& data);
void operator >> (u32& data);

---

Could the problem be that one of your '>>' operator is expecting the address of a variable instance rather than the variable instance itself?

Perhaps I am completely off the mark but without going through the code properly that would be my best guess.

Firstly, thanks for your reply. Unfortunately I am unable yo test out your hypothesis as I'm away from my computer at the moment but I'll be sure to test it as soon as I get back.

Also, I thought that by putting & in the function declaration you're passing by reference already and thus don't need to pass a pointer. Wouldn't the compiler also emit warnings/errors if the function calls and declaration didn't match up?

Thanks.