source: dev/trunk/abdev/BasicCompiler_Common/include/Binary.h@ 417

#pragma once


class Binary
{
    int allocateSize;
    char *buffer;
    int size;

    // XMLシリアライズ用
private:
    friend class boost::serialization::access;
    BOOST_SERIALIZATION_SPLIT_MEMBER();
    template<class Archive> void load(Archive& ar, const unsigned int version)
    {
        trace_for_serialize( "serializing(load) - Binary" );

        std::string _buffer;
        ar & BOOST_SERIALIZATION_NVP( _buffer );
        ar & BOOST_SERIALIZATION_NVP( size );

        // 読み込み後の処理
        Realloc( size );
        for( int i=0; i<size; i++ )
        {
            ULONG_PTR l1 = ( ( _buffer[i*3] >= 'a' ) ? ( _buffer[i*3] - 'a' + 0x0a ) : ( _buffer[i*3] - '0' ) ) * 0x10;
            ULONG_PTR l2 = ( _buffer[i*3+1] >= 'a' ) ? ( _buffer[i*3+1] - 'a' + 0x0a ) : ( _buffer[i*3+1] - '0' );
            ULONG_PTR l = l1 + l2;
            buffer[i] = static_cast<char>(l);
        }
    }
    template<class Archive> void save(Archive& ar, const unsigned int version) const
    {
        trace_for_serialize( "serializing(save) - Binary" );

        // 保存準備
        char *tempCode = (char *)calloc( (size+1) * 3, 1 );
        for( int i=0; i<size; i++ )
        {
            char temp[32];
            sprintf( temp, "%02x,", (unsigned char)buffer[i] );
            tempCode[i*3] = temp[0];
            tempCode[i*3+1] = temp[1];
            tempCode[i*3+2] = temp[2];
        }

        std::string _buffer = tempCode;
        free( tempCode );

        ar & BOOST_SERIALIZATION_NVP( _buffer );
        ar & BOOST_SERIALIZATION_NVP( size );
    }

    void Realloc( int newSize )
    {
        if( allocateSize < newSize + 8192 )
        {
            while( allocateSize < newSize + 8192 )
            {
                allocateSize += 8192;
            }
            buffer = (char *)realloc( buffer, allocateSize );

            // 再確保した部分を0で埋める
            memset( buffer + size, 0, allocateSize - size );
        }
    }

public:
    Binary()
        : allocateSize( 8192 )
        , buffer( (char *)malloc( allocateSize ) )
        , size( 0 )
    {
    }
    Binary( const char *buffer, int size )
        : allocateSize( 8192 )
        , buffer( (char *)malloc( allocateSize ) )
        , size( 0 )
    {
        Put( buffer, size );
    }
    ~Binary()
    {
        free( buffer );
    }

    void Clear()
    {
        size = 0;
    }

    const char *GetBuffer() const
    {
        return buffer;
    }
    int GetSize() const
    {
        return size;
    }
    void Resize( int newSize )
    {
        Realloc( newSize );
        size = newSize;
    }

    long GetLong( int pos ) const
    {
        return *(long *)( buffer + pos );
    }

    void Overwrite( int pos, const char *buffer, int size )
    {
        memcpy( this->buffer + pos, buffer, size );
    }
    void Overwrite( int pos, char c )
    {
        buffer[pos] = c;
    }
    void Overwrite( int pos, long newLongValue )
    {
        *(long *)( buffer + pos ) = newLongValue;
    }
    void Overwrite( int pos, _int64 newInt64Value )
    {
        *(_int64 *)( buffer + pos ) = newInt64Value;
    }

    void Put( const char *buffer, int size )
    {
        Realloc( this->size + size );

        memcpy( this->buffer + this->size, buffer, size );
        this->size += size;
    }
    void Put( double dbl )
    {
        Put( (const char *)(&dbl), sizeof(double) );
    }
    void Put( float flt )
    {
        Put( (const char *)(&flt), sizeof(float) );
    }
    void Put( _int64 i64data )
    {
        Put( (const char *)(&i64data), sizeof(_int64) );
    }
    void Put( long l )
    {
        Realloc( size + sizeof(long) );
        *((long *)(buffer+size))=l;
        size += sizeof(long);
    }
    void Put( short s )
    {
        Realloc( size + sizeof(short) );
        *((short *)(buffer+size))=s;
        size += sizeof(short);
    }
    void Put( char c )
    {
        Realloc( size + 1 );
        buffer[size++] = c;
    }
};