class CMetaDataOutputFileStream & CMetaDataInputMemoryStream

以前写的程序，都弄丢了，从今天开始，放到博客上，积累起来！

类CMetaDataOutputFileStream用来序列化数据到文件；类CMetaDataInputMemoryStream先将文件中的数据加载到内存中，然后用于反序列化。

#include <cstdio>
#include <cstring>
#include <string>

#define DAF_RUN_ERROR printf

//////////////////////////////////////////////////////////////////////////
// CMetaDataOutputFileStream

class CMetaDataOutputFileStream
{
    typedef CMetaDataOutputFileStream MyType;

public:
    CMetaDataOutputFileStream()
        : m_pFile(NULL)
        , m_good(true)
    {

    }

    ~CMetaDataOutputFileStream()
    {
        Close();
    }

    bool IsOpen() const { return NULL != m_pFile; }
    bool Good() const { return m_good; }

    void Open()
    {
        SetBad();
        m_pFile = fopen("C:\\metadata.dat", "wb");
        if (NULL != m_pFile)
            SetGood();
    }

    void Close()
    {
        if (IsOpen())
        {
            if (fclose(m_pFile))
                SetBad();
            m_pFile = NULL;
        }
    }

    template<typename T>
    MyType& operator<<(const T& t)
    {
        if (Good())
        {
            if (!Write(t))
                SetBad();
        }
        return *this;
    }

    MyType& operator<<(bool b)
    {
        return *this << (char)b;
    }

    MyType& operator<<(const char* p)
    {
        return WriteStringWithNull(p, strlen(p));
    }

    MyType& operator<<(const std::string& s)
    {
        return WriteStringWithNull(s.c_str(), s.size());
    }

    MyType& WriteBinary(const void* p, size_t n)
    {
        if (Good())
        {
            if (!Write(n) || !Write(p, n))
                SetBad();
        }
        return *this;
    }

    MyType& WriteString(const char* p, size_t n)
    {
        if (Good())
        {
            if (!Write(n) || !Write(p, n) || !Write("", 1))
                SetBad();
        }
        return *this;
    }

    MyType& WriteStringWithNull(const char* p, size_t n)
    {
        if (Good())
        {
            if (!Write(n) || !Write(p, n + 1))
                SetBad();
        }
        return *this;
    }

private:
    bool Write(const void* p, size_t n)
    {
        return n == fwrite(p, 1, n, m_pFile);
    }

    template<typename T>
    bool Write(const T& t)
    {
        return Write(&t, sizeof(t));
    }

    void SetGood() { m_good = true; }
    void SetBad() { m_good = false; }

private:
    FILE* m_pFile;
    bool m_good;
};

//////////////////////////////////////////////////////////////////////////
// CMetaDataInputMemoryStream

class CMetaDataInputMemoryStream
{
    typedef CMetaDataInputMemoryStream MyType;

    class CBin
    {
    public:
        const void* p;
        size_t n;
    };

    class CStr
    {
    public:
        const char* p;
        size_t n;
    };

public:
    CMetaDataInputMemoryStream()
        : m_pBegin(NULL)
        , m_pEnd(NULL)
        , m_pCur(NULL)
        , m_good(true)
    {

    }

    ~CMetaDataInputMemoryStream()
    {
        Close();
    }

    bool IsOpen() const { return NULL != m_pBegin; }
    bool Good() const { return m_good; }

    void Open()
    {
        Close();
        SetBad();

        FILE* pFile = fopen("C:\\metadata.dat", "rb");
        if (NULL == pFile)
            return;

        char* buf = NULL;
        do 
        {
            if (fseek(pFile, 0L, SEEK_END))
                break;

            size_t len = (size_t)ftell(pFile);
            if (0 == len)
                break;

            if (fseek(pFile, 0L, SEEK_SET))
                break;

            buf = new char[len];

            if (len != fread(buf, 1, len, pFile))
                break;

            m_pBegin = buf;
            m_pCur = buf;
            m_pEnd = buf + len;
            SetGood();
            return;

        } while (0);

        (void)fclose(pFile);
        delete[] buf;
    }

    void Close()
    {
        if (IsOpen())
        {
            delete[] m_pBegin;
            m_pBegin = NULL;
            m_pCur = NULL;
            m_pEnd = NULL;
        }
    }

    template<typename T>
    MyType& operator>>(T& t)
    {
        if (Good())
        {
            if (!Read(t))
                SetBad();
        }
        return *this;
    }

    MyType& operator>>(bool& b)
    {
        if (Good())
        {
            char c;
            if (!Read(c))
                SetBad();
            else
                b = (c != 0);
        }
        return *this;
    }

    MyType& operator>>(const char*& p)
    {
        size_t n;
        return ReadString(p, n);
    }

    MyType& operator>>(std::string& s)
    {
        if (Good())
        {
            const char* p;
            size_t n;
            if (!Read(n) || !Read(p, n + 1) || p[n])
                SetBad();
            else
                (void)s.assign(p, n);
        }
        return *this;
    }

    MyType& operator>>(CBin& b)
    {
        return ReadBinary(b.p, b.n);
    }

    MyType& operator>>(CStr& s)
    {
        return ReadString(s.p, s.n);
    }

    MyType& ReadBinary(const void*& p, size_t& n)
    {
        if (Good())
        {
            if (!Read(n) || !Read(p, n))
                SetBad();
        }
        return *this;
    }

    MyType& ReadString(const char*& p, size_t& n)
    {
        if (Good())
        {
            if (!Read(n) || !Read(p, n + 1) || p[n])
                SetBad();
        }
        return *this;
    }

private:
    size_t RemainingLength() const { return m_pEnd - m_pCur; }

    template<typename T>
    bool Read(const T*& p, size_t n)
    {
        if (RemainingLength() >= n)
        {
            p = (const T*)m_pCur;
            m_pCur += n;
            return true;
        }
        return false;
    }

    template<typename T>
    bool Read(T& t)
    {
        if (RemainingLength() >= sizeof(t))
        {
            t = *(const T*)m_pCur;
            m_pCur += sizeof(t);
            return true;
        }
        return false;
    }

    void SetGood() { m_good = true; }
    void SetBad() { m_good = false; }

private:
    const char* m_pBegin;
    const char* m_pEnd;
    const char* m_pCur;
    bool m_good;
};

//////////////////////////////////////////////////////////////////////////

int _tmain(int argc, _TCHAR* argv[])
{
    int a = 'aaaa';
    long long b = (((long long)'bbbb') << 32) + 'bbbb';
    const char* c = "ccccc";
    std::string d("ddddd");
    const char e[] = "eeeee";
    CMetaDataOutputFileStream ofs;
    ofs.Open();
    ofs << a;
    ofs << b;
    ofs << c;
    ofs << d;
    ofs.WriteBinary(e, sizeof(e));
    ofs.Close();

    int aa = 0;
    long long bb = 0;
    const char* cc = 0;
    std::string dd;
    const void* ee = 0;
    size_t een = 0;
    CMetaDataInputMemoryStream ims;
    ims.Open();
    ims >> aa;
    ims >> bb;
    ims >> cc;
    ims >> dd;
    ims.ReadBinary(ee, een);
    ims.Close();

    return 0;
}