template <long SWAP_ENDIAN>

class BufferStreamOrder

{

    std::vector<char> v;

    size_t offset;

public:

    inline BufferStreamOrder & WriteIn(const void *p, size_t len)

    {

        if (v.size() < offset+len)

            v.resize(offset+len);



        memcpy(&v[offset], p, len);

        offset += len;

        return *this;

    }

protected:

    template <class T>

    inline BufferStreamOrder & WriteTemplate(const T v)

        {

            if (SWAP_ENDIAN)

            {

                T v2 = swapVal(v);

                return WriteIn(&v2, sizeof(v));

            }

            else

                return WriteIn(&v, sizeof(v));

        };



public:

    BufferStreamOrder()    { offset=0; }



    inline long resize(size_t size)

    {

        v.reserve(size);

    }



    inline BufferStreamOrder & empty() { offset = 0; return *this; }



    inline  char *Get() { return &v[0]; }

    inline  size_t WriteLen() { return offset; }





    inline BufferStreamOrder & writeIn(u8  v) { return WriteTemplate(v); }

    inline BufferStreamOrder & writeIn(s8  v) { return WriteTemplate(v); }

    inline BufferStreamOrder & writeIn(u16 v) { return WriteTemplate(v); }

    inline BufferStreamOrder & writeIn(s16 v) { return WriteTemplate(v); }

    inline BufferStreamOrder & writeIn(u32 v) { return WriteTemplate(v); }

    inline BufferStreamOrder & writeIn(s32 v) { return WriteTemplate(v); }

    inline BufferStreamOrder & writeIn(u64 v) { return WriteTemplate(v); }

    inline BufferStreamOrder & writeIn(s64 v) { return WriteTemplate(v); }

    inline BufferStreamOrder & operator << (u8  v) { return WriteTemplate(v); }

    inline BufferStreamOrder & operator << (s8  v) { return WriteTemplate(v); }

    inline BufferStreamOrder & operator << (s16 v) { return WriteTemplate(v); }

    inline BufferStreamOrder & operator << (u16 v) { return WriteTemplate(v); }

    inline BufferStreamOrder & operator << (s32 v) { return WriteTemplate(v); }

    inline BufferStreamOrder & operator << (u32 v) { return WriteTemplate(v); }

    inline BufferStreamOrder & operator << (s64 v) { return WriteTemplate(v); }

    inline BufferStreamOrder & operator << (u64 v) { return WriteTemplate(v); }

    //*/

    inline BufferStreamOrder & operator << (const char *psz) { return WriteIn(psz, strlen(psz)); }

};

typedef size_t (*ReadFunction_t)(void *dst, const void *pUser, size_t len);

template <long SWAP_ENDIAN>

class ReadStreamOrder

{

public:

     //there is no reason to hide these

    void *userData;

    ReadFunction_t readFunction;



    inline ReadStreamOrder & ReadIn(void *dst, const void *pUser, size_t len)

    {

        readFunction(dst, pUser, len);

        return *this;

    }

protected:

    template <class T>

    inline ReadStreamOrder & ReadTemplate(T &v)

        {

            if (SWAP_ENDIAN)

            {

                T v2;

                ReadIn(&v2, userData, sizeof(v));

                v = swapVal(v2);

                return *this;

            }

            else

                return ReadIn(&v, userData, sizeof(v));

        };



public:

    ReadStreamOrder(ReadFunction_t readFunc_, void *userData_)    { readFunction = readFunc_; userData = userData_; }



    #define WRITEIN(T) inline ReadStreamOrder &writeIn(T &v) { return ReadTemplate(v); }

    WRITEIN(u8)

    WRITEIN(s8)

    WRITEIN(u16)

    WRITEIN(s16)

    WRITEIN(u32)

    WRITEIN(s32)

    WRITEIN(u64)

    WRITEIN(s64)

    #undef WRITEIN

    #define WRITEIN(T) inline ReadStreamOrder & operator >> (T &v) { return ReadTemplate(v); }

    WRITEIN(u8)

    WRITEIN(s8)

    WRITEIN(u16)

    WRITEIN(s16)

    WRITEIN(u32)

    WRITEIN(s32)

    WRITEIN(u64)

    WRITEIN(s64)

    #undef WRITEIN

    /*

    inline ReadStreamOrder & writeIn(u8  &v) { return ReadTemplate(v); }

    inline ReadStreamOrder & writeIn(s8  &v) { return ReadTemplate(v); }

    inline ReadStreamOrder & writeIn(u16 &v) { return ReadTemplate(v); }

    inline ReadStreamOrder & writeIn(s16 &v) { return ReadTemplate(v); }

    inline ReadStreamOrder & writeIn(u32 &v) { return ReadTemplate(v); }

    inline ReadStreamOrder & writeIn(s32 &v) { return ReadTemplate(v); }

    inline ReadStreamOrder & writeIn(u64 &v) { return ReadTemplate(v); }

    inline ReadStreamOrder & writeIn(s64 &v) { return ReadTemplate(v); }

    inline ReadStreamOrder & operator >> (u8  &v) { return ReadTemplate(v); }

    inline ReadStreamOrder & operator >> (s8  &v) { return ReadTemplate(v); }

    inline ReadStreamOrder & operator >> (s16 &v) { return ReadTemplate(v); }

    inline ReadStreamOrder & operator >> (u16 &v) { return ReadTemplate(v); }

    inline ReadStreamOrder & operator >> (s32 &v) { return ReadTemplate(v); }

    inline ReadStreamOrder & operator >> (u32 &v) { return ReadTemplate(v); }

    inline ReadStreamOrder & operator >> (s64 &v) { return ReadTemplate(v); }

    inline ReadStreamOrder & operator >> (u64 &v) { return ReadTemplate(v); }

    //*/

    inline ReadStreamOrder & operator >> (const char *psz) { return ReadIn(psz, strlen(psz)); }



    template <class T>    inline T Get() { T v; ReadTemplate(v); return v; }

    template <class T>    inline long Equal(T v) { T v2; ReadTemplate(v2); return v == v2; }

};

#ifdef __BIG_ENDIAN__

    typedef BufferStreamOrder<1>        BufferStreamLE;

    typedef BufferStreamOrder<0>        BufferStreamBE;

    typedef ReadStreamOrder<1>            ReadStreamLE;

    typedef ReadStreamOrder<0>            ReadStreamBE;



#endif

#if defined __LITTLE_ENDIAN__

    typedef BufferStreamOrder<0>        BufferStreamLE;

    typedef BufferStreamOrder<1>        BufferStreamBE;

    typedef ReadStreamOrder<0>            ReadStreamLE;

    typedef ReadStreamOrder<1>            ReadStreamBE;

#endif

typedef BufferStreamOrder<0>            BufferStream;

typedef ReadStreamOrder<0>                ReadStream;