BinarySerializer.h

#ifndef _MSL_H_
#define _MSL_H_

#include <cassert>
#include <fstream>
#include <vector>

class ISerializable;

class BinarySerializer
{
public:
    BinarySerializer(const std::string& filename) : mode(0), filename(filename) { }
    ~BinarySerializer();

    void closeFiles();
    void serialize();
    void deserialize();

    unsigned getMode() { return mode; }
    void addData(const char* ptr, unsigned size);
    void addData(const ISerializable& ptr);
    void readData(void* ptr, unsigned size);

    // operators
    // <<
    template <class T>
    BinarySerializer& operator<<(const std::vector<T*>& vec)
    {
        std::vector<ISerializable*> cvec;
        cvec.assign(vec.begin(), vec.end());

        *this << vec.size();

        for (std::vector<ISerializable*>::const_iterator itr = cvec.begin(); itr != cvec.end(); itr++)
            (*itr)->Serialize(this);

        return *this;
    }

    BinarySerializer& operator<<(const std::vector<ISerializable*>& vec);
    BinarySerializer& operator<<(const ISerializable& ptr);
    BinarySerializer& operator<<(const std::string& str);
    BinarySerializer& operator<<(const int& i);
    BinarySerializer& operator<<(const unsigned int& ui);
    BinarySerializer& operator<<(const short int& si);
    BinarySerializer& operator<<(const unsigned short& us);
    BinarySerializer& operator<<(const long long& ll);
    BinarySerializer& operator<<(const float& f);
    BinarySerializer& operator<<(const double& d);

    // >>
    template <class T>
    BinarySerializer& operator>>(std::vector<T*>& vec)
    {
        unsigned size;
        T* obj;

        *this >> size;

        for (unsigned i = 0; i < size; i++)
        {
            obj = new T();
            *this >> *obj;

            vec.push_back(obj);
        }

        return *this;
    }

    template <class T>
    BinarySerializer& operator>>(T** ptr)
    {
        T* obj = new T();
        *this >> *obj;

        *ptr = obj;

        return *this;
    }

    BinarySerializer& operator>>(const ISerializable& ptr);
    BinarySerializer& operator>>(std::string& str);
    BinarySerializer& operator>>(int& i);
    BinarySerializer& operator>>(unsigned int& ui);
    BinarySerializer& operator>>(short int& si);
    BinarySerializer& operator>>(unsigned short& us);
    BinarySerializer& operator>>(long long& ll);
    BinarySerializer& operator>>(float& f);
    BinarySerializer& operator>>(double& d);

protected:
    // 0 = inactive
    // 1 = serialize
    // 2 = deserialize
    unsigned mode;

    std::string filename;
    std::ofstream ofs;
    std::ifstream ifs;
};

class ISerializable
{
protected:
    friend class BinarySerializer;

    virtual ~ISerializable() {}
    virtual void Serialize(BinarySerializer* sds)=0;
    virtual void Deserialize(BinarySerializer* sds)=0;

protected:
    ISerializable() { }
};

#endif