source: dev/trunk/jenga/include/common/Binaly.h@ 387

#pragma once

#include <string>
#include <vector>

#include <memory.h>
#include <windows.h>

#define JENGA_SERIALIZER(param) ( isRead?(binaly.Read(param)):(binaly << param) );

class MemoryBlock
{
    int base;
    int size;
public:
    MemoryBlock( int base, int size )
        : base( base )
        , size( size )
    {
    }
    int GetBase() const
    {
        return base;
    }
    int GetSize() const
    {
        return size;
    }
};
class Binaly
{
    static const int alignment = 1024 * 1024;

    unsigned char *pBuffer;
    int size;
    int maxSize;

    std::vector<MemoryBlock> memoryBlocks;
    int indexOfMemoryBlocks;

    // 初期化
    void Initialize()
    {
        maxSize = alignment;
        pBuffer = (unsigned char *)calloc( maxSize, 1 );
        size = 0;

        memoryBlocks.clear();
        indexOfMemoryBlocks = 0;
    }

    // メモリ領域の再確保
    void Allocator( int newSize )
    {
        size = newSize;

        if( maxSize > newSize )
        {
            // 確保済みメモリのサイズがあまっているとき
            return;
        }

        while( maxSize <= newSize )
        {
            maxSize += alignment;
        }
        pBuffer = (unsigned char *)realloc( pBuffer, maxSize );
    }
    void AddMemorySize( int plusSize )
    {
        Allocator( size + plusSize );
    }
    void ReadMemoryCheck( int readSize )
    {
        if( (int)memoryBlocks.size() < indexOfMemoryBlocks )
        {
            throw "bad memory access";
        }

        if( memoryBlocks[indexOfMemoryBlocks].GetSize() != readSize )
        {
            throw "bad memory access";
        }
    }

public:
    Binaly( const Binaly &binaly )
    {
        Initialize();
    }
    Binaly( const unsigned char *pNewBuffer, int size )
    {
        Initialize();
    }
    Binaly()
    {
        Initialize();
    }
    ~Binaly()
    {
        free( pBuffer );
    }

    void Clear()
    {
        free( pBuffer );
        Initialize();
    }

    void Add( const unsigned char *pBufferOfBlock, int sizeOfBlock )
    {
        int base = this->size;
        AddMemorySize( sizeOfBlock );
        memcpy( pBuffer + base, pBufferOfBlock, sizeOfBlock );

        memoryBlocks.push_back( MemoryBlock( base, sizeOfBlock ) );
    }
    void operator<< ( int i )
    {
        Add( (const unsigned char *)&i, sizeof(int) );
    }
    void operator<< ( double dbl )
    {
        Add( (const unsigned char *)&dbl, sizeof(double) );
    }
    void operator<< ( bool b )
    {
        Add( (const unsigned char *)&b, sizeof(bool) );
    }
    void operator<< ( const std::string &str )
    {
        Add( (const unsigned char *)str.c_str(), (int)str.size() );
    }
    void operator<< ( const char *lpszStr )
    {
        Add( (const unsigned char *)lpszStr, lstrlen(lpszStr) );
    }

    int GetNextSizeToReading()
    {
        return memoryBlocks[indexOfMemoryBlocks].GetSize();
    }
    void Read( unsigned char *pBuffer, int readSize )
    {
        ReadMemoryCheck( readSize );

        memcpy(
            pBuffer,
            this->pBuffer + memoryBlocks[indexOfMemoryBlocks].GetBase(),
            memoryBlocks[indexOfMemoryBlocks].GetSize()
        );

        indexOfMemoryBlocks++;
    }
    void Read( int &i )
    {
        Read( (unsigned char *)&i, sizeof(int) );
    }
    void Read( bool &b )
    {
        Read( (unsigned char *)&b, sizeof(bool) );
    }
    void Read( std::string &str )
    {
        str = std::string(
            (const char *)pBuffer + memoryBlocks[indexOfMemoryBlocks].GetBase(),
            memoryBlocks[indexOfMemoryBlocks].GetSize()
        );
    }
};