XArchive.h

// ExArchive.h: interface for the CXArchive class.
//
//////////////////////////////////////////////////////////////////////
 
#if !defined(CARCHIVE_INCLUDE_H)
#define CARCHIVE_INCLUDE_H
 
#ifdef _MSC_VER
#pragma once
#endif // _MSC_VER
 
#include "HashMap.h"
 
BEGIN_MOOTOOLS_NAMESPACE
 
    class DLL_TOOLSFUNCTION CXArchive : public CXObject
    {
    public:
 
        // Flag values
        typedef enum
        {
            store = 0,
            load = 1,
            bNoFlushOnDelete = 2
        } XArchiveFlags;
 
        CXArchive(CXFile* pFile, unsigned int nMode, unsigned int nBufSize = 4096, void *bufferPtr = NULL);
        ~CXArchive();
 
        // Attributes
        void *GetData() const;
        void SetData(void *data);
        bool IsLoading() const;
        bool IsStoring() const;
 
        CXFile *GetFile() const;
 
        // Operations
        SIZET Read(void *bufferPtr, SIZET maxToRead);
        void EnsureRead(void *bufferPtr, SIZET checkReadCount);
        void Write(const void *bufferPtr, SIZET maxToWrite);
        void Flush();
        void Close();
        void Abort();
 
    public:
        CXArchive& operator<<(const CXObject* pOb);
 
        CXArchive& operator>>(CXObject*& pOb);
        CXArchive& operator>>(const CXObject*& pOb);
 
        // save operations
        CXArchive& operator<<(bool b);
        CXArchive& operator<<(char by);
        CXArchive& operator<<(wchar_t ch);
        CXArchive& operator<<(unsigned char by);
        CXArchive& operator<<(short w);
        CXArchive& operator<<(unsigned short w);
        CXArchive& operator<<(int i);
        CXArchive& operator<<(unsigned int i);
        //CXArchive& operator<<(long l);
        //CXArchive& operator<<(unsigned long l);
        CXArchive& operator<<(float f);
        CXArchive& operator<<(double d);
        CXArchive& operator<<(longint dwdw);
        CXArchive& operator<<(longuint dwdw);
        CXArchive& operator<<(const CXStringA&);
        CXArchive& operator<<(const CXStringW&);
 
        // load operations
        CXArchive& operator>>(bool& b);
        CXArchive& operator>>(char& by);
        CXArchive& operator>>(wchar_t& ch);
        CXArchive& operator>>(unsigned char& by);
        CXArchive& operator>>(short& w);
        CXArchive& operator>>(unsigned short& w);
        CXArchive& operator>>(int& i);
        CXArchive& operator>>(unsigned int& i);
        //CXArchive& operator>>(long& l);
        //CXArchive& operator>>(unsigned long& l);
        CXArchive& operator>>(float& f);
        CXArchive& operator>>(double& d);
        CXArchive& operator>>(longint& dwdw);
        CXArchive& operator>>(longuint& dwdw);
        CXArchive& operator>>(CXStringA&);
        CXArchive& operator>>(CXStringW&);
 
        // XObject read/write
        CXObject* ReadObject(const CXRuntimeClassPtr pClass);
        void WriteObject(const CXObject* pOb);
 
        void WriteStringLength(longuint nLength, xStringEncoding encoding);
        longuint ReadStringLength(xStringEncoding& encoding);
        void WriteCount(longuint count);
        longuint ReadCount();
 
        // advanced versioning support
        void WriteClass(const CXRuntimeClassPtr refruntimeClass);
        const CXRuntimeClassPtr  ReadClass(const CXRuntimeClassPtr runtimeClass = NULL, unsigned int *storedClassVersion = NULL, unsigned int *objectIndex = NULL);
        void SerializeClass(const CXRuntimeClassPtr  refruntimeClass);
 
        unsigned int GetObjectSchema() const; // only valid when reading a CXObject*
 
        // Implementation
    protected:
        // archive objects cannot be copied or assigned
        CXArchive(const CXArchive& arSrc) { XASSERT(0); };
        void operator=(const CXArchive& arSrc) { XASSERT(0); };
 
        CXString filename;
        CXFile *file;
 
        unsigned int flags;
        bool userBuffer, directBuffer;
 
        SIZET bufferSize;
        unsigned char *buffer; // Allocated buffer
        unsigned char *curBufferPos; // Current position in the buffer
        unsigned char *maxBufferPos; // max (potentially filled) buffer and max position
 
        void FillBuffer(SIZET nAdditionalBytesNeeded);
 
        // reading and writing strings
        void WriteString(LPCSTR lpsz, xStringEncoding encoding);
        void WriteString(LPCWSTR lpsz, xStringEncoding encoding);
 
    private:
        typedef const void *storedPtr;
        typedef struct loadedPtr
        {
            storedPtr ptr;
            enum
            {
                XUndefined = 0,
                XRuntimePtr,
                XObjectPtr,
            } type;
 
            unsigned int storedVersion;
 
            loadedPtr()  : ptr(NULL), type(XUndefined), storedVersion((unsigned int)-1)
            {};
            loadedPtr(const CXRuntimeClassPtr runtime, unsigned int version) : ptr(runtime), type(XRuntimePtr), storedVersion(version)
            {};
            loadedPtr(const CXObject *object) : ptr(object), type(XObjectPtr), storedVersion((unsigned int)-1)
            {};
        } loadedRuntime;
 
        unsigned int lastObjectVersion;
        unsigned int curStoredCount;
        CHashMap<storedPtr, const storedPtr, unsigned int> storedMap; // runtime / object map
        CXArray<loadedPtr, const loadedPtr&> loadedArray; 
 
        void *customData;
 
#ifdef MOOTOOLS_PRIVATE_DEBUG
        fileuint curFilePos;
#endif
    };
 
    /////////////////////////////////////////////////////
    // CXArchive inlines
    inline bool CXArchive::IsLoading() const
    { 
        return (flags & CXArchive::load) != 0; 
    }
 
    inline bool CXArchive::IsStoring() const
    { 
        return (flags & CXArchive::load) == 0; 
    }
 
    inline CXFile* CXArchive::GetFile() const
    { 
        return file; 
    }
 
    ///////////////////////// << ////////////////////////////////////////////////////////////////
    #define EXARCHIVE_STORE(TYPE, val) \
        if (!IsStoring()) \
            XThrowExceptionWithArgs(CXArchiveException, CXArchiveException::readOnly, filename); \
        if (curBufferPos + sizeof(TYPE) > maxBufferPos) \
            Flush(); \
        *((TYPE *)curBufferPos) = val; \
        curBufferPos += sizeof(TYPE); \
        return *this;
 
    inline CXArchive& CXArchive::operator<<(char by)
    { 
        EXARCHIVE_STORE(char, by);
    }
 
    inline CXArchive& CXArchive::operator<<(unsigned char by)
    { 
        return CXArchive::operator << (static_cast<char>(by));
    }
 
    inline CXArchive& CXArchive::operator<<(bool b)
    {
        return CXArchive::operator << ((char)(b ? 1 : 0));
    }
 
    inline CXArchive& CXArchive::operator<<(wchar_t tch)
    {
        EXARCHIVE_STORE(wchar_t, tch);
    }
 
    inline CXArchive& CXArchive::operator<<(longint mylongint)
    { 
        EXARCHIVE_STORE(longint, mylongint);
    }
 
    inline CXArchive& CXArchive::operator<<(longuint mylonguint)
    { 
        return CXArchive::operator << (static_cast<longint>(mylonguint));
    }
 
    inline CXArchive& CXArchive::operator<<(short w)
    { 
        EXARCHIVE_STORE(short, w);
    }
 
    inline CXArchive& CXArchive::operator<<(unsigned short w)
    { 
        return CXArchive::operator << (static_cast<short>(w));
    }
 
    inline CXArchive& CXArchive::operator<<(int i)
    { 
        EXARCHIVE_STORE(int, i);
    }
 
    inline CXArchive& CXArchive::operator<<(unsigned int i)
    { 
        return CXArchive::operator << (static_cast<int>(i));
    }
 
    //inline CXArchive& CXArchive::operator<<(long l)
    //{ 
    //  EXARCHIVE_STORE(long, l);
    //}
 
    //inline CXArchive& CXArchive::operator<<(unsigned long l)
    //{ 
    //  return CXArchive::operator << (static_cast<long>(l));
    //}
 
    inline CXArchive& CXArchive::operator<<(float f)
    { 
        EXARCHIVE_STORE(float, f);
    }
 
    inline CXArchive& CXArchive::operator<<(double d)
    {
        EXARCHIVE_STORE(double, d);
    }
 
    #undef EXARCHIVE_STORE
 
    ///////////////////////// >> ////////////////////////////////////////////////////////////////
    #define EXARCHIVE_LOAD(TYPE, val) \
        if(!IsLoading()) \
            XThrowExceptionWithArgs(CXArchiveException, CXArchiveException::writeOnly, filename); \
        if (curBufferPos + sizeof(TYPE) > maxBufferPos) \
            FillBuffer(sizeof(TYPE) - (SIZET)(maxBufferPos - curBufferPos));  \
        val = *((TYPE *)curBufferPos); \
        curBufferPos += sizeof(TYPE); \
        return *this;
 
    inline CXArchive& CXArchive::operator>>(char& by)
    { 
        EXARCHIVE_LOAD(char, by);
    }
 
    inline CXArchive& CXArchive::operator>>(unsigned char& by)
    { 
        EXARCHIVE_LOAD(unsigned char, by);
    }
 
    inline CXArchive& CXArchive::operator>>(bool& b)
    { 
        char tmp;
        EXARCHIVE_LOAD(char, tmp);
        b = !!tmp;
    }
 
    inline CXArchive& CXArchive::operator>>(wchar_t& tch)
    { 
        EXARCHIVE_LOAD(wchar_t, tch);
    }
 
    inline CXArchive& CXArchive::operator>>(longint& mylongint)
    { 
        EXARCHIVE_LOAD(longint, mylongint);
    }
 
    inline CXArchive& CXArchive::operator>>(longuint& mylonguint)
    { 
        EXARCHIVE_LOAD(longuint, mylonguint);
    }
 
    inline CXArchive& CXArchive::operator>>(short& s)
    { 
        EXARCHIVE_LOAD(short, s);
    }
 
    inline CXArchive& CXArchive::operator>>(unsigned short& s)
    { 
        EXARCHIVE_LOAD(unsigned short, s);
    }
 
    inline CXArchive& CXArchive::operator>>(int& i)
    { 
        EXARCHIVE_LOAD(int, i);
    }
 
    inline CXArchive& CXArchive::operator>>(unsigned int& i)
    { 
        EXARCHIVE_LOAD(unsigned int, i);
    }
 
    //inline CXArchive& CXArchive::operator>>(long& l)
    //{ 
    //  EXARCHIVE_LOAD(long, l);
    //}
 
    //inline CXArchive& CXArchive::operator>>(unsigned long& l)
    //{ 
    //  EXARCHIVE_LOAD(unsigned long, l);
    //}
 
    inline CXArchive& CXArchive::operator>>(float& f)
    { 
        EXARCHIVE_LOAD(float, f);
    }
 
    inline CXArchive& CXArchive::operator>>(double& d)
    { 
        EXARCHIVE_LOAD(double, d);
    }
 
    inline CXArchive& CXArchive::operator<<(const CXObject* pOb)
    {
        WriteObject(pOb);
        return *this;
    }
 
    inline CXArchive& CXArchive::operator>>(CXObject*& pOb)
    {
        pOb = ReadObject(NULL);
        return *this;
    }
 
    inline CXArchive& CXArchive::operator>>(const CXObject*& pOb)
    {
        pOb = ReadObject(NULL);
        return *this;
    }
 
    #undef EXARCHIVE_LOAD
    #undef SIZET
 
END_MOOTOOLS_NAMESPACE
 
#endif // !defined(CARCHIVE_INCLUDE_H)