cArchive.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cArchive_H
#define _INC_cArchive_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "cStream.h"
#include "cUnitTestDecl.h"
 
namespace Gray
{
        UNITTEST2_PREDEF(cArchive);
 
        class GRAYCORE_LINK cArchive
        {
        private:
                const bool m_bStoring;          
                cStreamBase* const m_pStream;   
 
        public:
                cArchive(cStreamOutput& so) noexcept
                        : m_bStoring(true)
                        , m_pStream(&so)
                {
                }
                cArchive(cStreamInput& si) noexcept
                        : m_bStoring(false)
                        , m_pStream(&si)
                {
                }
                cArchive(cStream& s, bool bStoring) noexcept
                        : m_bStoring(bStoring)
                        , m_pStream(bStoring ? static_cast<cStreamBase*>(static_cast<cStreamOutput*>(&s)) : static_cast<cStreamBase*>(static_cast<cStreamInput*>(&s)))
                {
                }
 
                bool IsStoring() const noexcept
                {
                        return m_bStoring;
                }
                bool IsLoading() const noexcept
                {
                        return !m_bStoring;
                }
 
                cStreamOutput& ref_Out()
                {
                        ASSERT(IsStoring());
                        return *static_cast<cStreamOutput*>(m_pStream);
                }
                cStreamInput& ref_Inp()
                {
                        ASSERT(IsLoading());
                        return *static_cast<cStreamInput*>(m_pStream);
                }
 
                HRESULT Serialize(void* pData, size_t nSize);
                HRESULT SerializeSize(size_t& nSize);
 
                HRESULT Write(const void* pData, size_t nSize)
                {
                        // Emulate MFC. Insert into the archive.
                        ASSERT(IsStoring());
                        return Serialize(const_cast<void*>(pData), nSize);
                }
                HRESULT Read(void* pData, size_t nSize)
                {
                        // Emulate MFC. Extract from the archive.
                        ASSERT(IsLoading());
                        return Serialize(pData, nSize);
                }
 
                COUNT_t ReadCount()
                {
                        // Emulate MFC. return size_t
                        ASSERT(IsLoading());
                        size_t n;
                        SerializeSize(n);
                        return n;
                }
                void WriteCount(size_t n)
                {
                        // Emulate MFC
                        ASSERT(IsStoring());
                        SerializeSize(n);
                }
 
#define CTYPE_DEF(a,_TYPE,c,d,e,f,g,h) HRESULT Serialize( _TYPE& Val ) { return Serialize(&Val,sizeof(Val)); } \
                cArchive& operator << (const _TYPE& Val) { Write(&Val,sizeof(Val)); return *this; } \
                cArchive& operator >> (_TYPE& Val) { Read(&Val,sizeof(Val)); return *this; } 
 
#include "cTypes.tbl"
#undef CTYPE_DEF
 
                UNITTEST_FRIEND(cArchive);
        };
}
 
#ifndef _MFC_VER        // emulate MFC.
typedef Gray::cArchive CArchive;
// #define cArchive Gray::cArchive 
#define DECLARE_SERIAL(class_name) friend CArchive& GRAYCALL operator>>(CArchive& ar, class_name* &pOb);        //   _DECLARE_DYNCREATE(class_name)  
#define IMPLEMENT_SERIAL(class_name,base_name,quant)    // external to class.
#endif
 
#endif