xrb_serializer.hpp

// ///////////////////////////////////////////////////////////////////////////
// xrb_serializer.hpp by Victor Dods, created 2005/02/10
// ///////////////////////////////////////////////////////////////////////////
// Unless a different license was explicitly granted in writing by the
// copyright holder (Victor Dods), this software is freely distributable under
// the terms of the GNU General Public License, version 2.  Any works deriving
// from this work must also be released under the GNU GPL.  See the included
// file LICENSE for details.
// ///////////////////////////////////////////////////////////////////////////

#if !defined(_XRB_SERIALIZER_HPP_)
#define _XRB_SERIALIZER_HPP_

#include "xrb.hpp"

#include <stdio.h>
#include <string>

#include "xrb_bitarray.hpp"
#include "xrb_bitcache.hpp"
#include "xrb_color.hpp"
#include "xrb_enums.hpp"
#include "xrb_matrix2.hpp"
#include "xrb_screencoord.hpp"
#include "xrb_simpletransform2.hpp"
#include "xrb_transform2.hpp"
#include "xrb_vector.hpp"

namespace Xrb
{

// metanote: i use the terms serializer and stream interchangeably

class Serializer
{
protected:

    enum
    {
        // with null-terminating character
        MAX_SUPPORTED_STRING_BUFFER_SIZE = 65536,
    };

public:

    enum
    {
        // no null-terminating character
        MAX_SUPPORTED_STRING_LENGTH = MAX_SUPPORTED_STRING_BUFFER_SIZE - 1
    };

    Serializer ();
    virtual ~Serializer ();

    // ///////////////////////////////////////////////////////////////////////
    // state accessors
    // ///////////////////////////////////////////////////////////////////////

    inline bool IsOpen () const
    {
        return m_is_open;
    }
    inline IODirection GetIODirection () const
    {
        return m_io_direction;
    }
    virtual bool IsAtEnd () const = 0;
    virtual bool HasFewerThan8BitsLeft () const = 0;
    inline IOError Error () const
    {
        return m_error;
    }
    inline char const *ErrorString () const
    {
        return Util::IOErrorString(Error());
    }

    // ///////////////////////////////////////////////////////////////////////
    // reading/writing functions
    // ///////////////////////////////////////////////////////////////////////

    virtual Sint32 ReadSignedBits (Uint32 bit_count) = 0;
    virtual void WriteSignedBits (Sint32 value, Uint32 bit_count) = 0;

    virtual Uint32 ReadUnsignedBits (Uint32 bit_count) = 0;
    virtual void WriteUnsignedBits (Uint32 value, Uint32 bit_count) = 0;

    virtual bool ReadBool () = 0;
    virtual void WriteBool (bool value) = 0;

    template <Uint32 bit_count>
    BitArray<bit_count> ReadBitArray ();
    template <Uint32 bit_count>
    void WriteBitArray (BitArray<bit_count> const &value);

    template <Uint32 bit_count>
    BitArray<bit_count> ReadBitArray (Uint32 bits_to_read);
    template <Uint32 bit_count>
    void WriteBitArray (BitArray<bit_count> const &value, Uint32 bits_to_write);

    virtual Sint8 ReadSint8 () = 0;
    virtual void WriteSint8 (Sint8 value) = 0;

    virtual Uint8 ReadUint8 () = 0;
    virtual void WriteUint8 (Uint8 value) = 0;

    virtual Sint16 ReadSint16 () = 0;
    virtual void WriteSint16 (Sint16 value) = 0;

    virtual Uint16 ReadUint16 () = 0;
    virtual void WriteUint16 (Uint16 value) = 0;

    virtual Sint32 ReadSint32 () = 0;
    virtual void WriteSint32 (Sint32 value) = 0;

    virtual Uint32 ReadUint32 () = 0;
    virtual void WriteUint32 (Uint32 value) = 0;

//     ScreenCoord ReadScreenCoord () { return ReadSint16(); }
    ScreenCoord ReadScreenCoord () { return ReadSint32(); }
//     void WriteScreenCoord (ScreenCoord value) { WriteSint16(value); }
    void WriteScreenCoord (ScreenCoord value) { WriteSint32(value); }

    virtual void ReadFloat (float *destination) = 0;
    virtual void WriteFloat (float value) = 0;

    virtual void ReadFloat (double *destination) = 0;
    virtual void WriteFloat (double value) = 0;

    virtual Uint32 ReadBufferString (char *destination, Uint32 destination_size) = 0;
    virtual Uint32 WriteBufferString (char const *source, Uint32 source_size) = 0;

    virtual Uint32 ReadString (char **destination);
    virtual Uint32 WriteString (char const *source);

    inline std::string ReadStdString (Uint32 *string_length = NULL)
    {
        std::string retval;
        ReadStdString(&retval, string_length);
        return retval;
    }
    void ReadStdString (std::string *destination, Uint32 *string_length = NULL);
    void WriteStdString (std::string const &source, Uint32 *string_length = NULL);

    inline Color ReadColor ()
    {
        Color retval;
        ReadColor(&retval);
        return retval;
    }
    virtual void ReadColor (Color *destination) = 0;
    virtual void WriteColor (Color const &value) = 0;

    inline ScreenCoordVector2 ReadScreenCoordVector2 ()
    {
        ScreenCoordVector2 retval;
        ReadScreenCoordVector2(&retval);
        return retval;
    }
    virtual void ReadScreenCoordVector2 (ScreenCoordVector2 *destination) = 0;
    virtual void WriteScreenCoordVector2 (ScreenCoordVector2 const &value) = 0;

    inline FloatVector2 ReadFloatVector2 ()
    {
        FloatVector2 retval;
        ReadFloatVector2(&retval);
        return retval;
    }
    virtual void ReadFloatVector2 (FloatVector2 *destination) = 0;
    virtual void WriteFloatVector2 (FloatVector2 const &value) = 0;

    inline FloatSimpleTransform2 ReadFloatSimpleTransform2 ()
    {
        FloatSimpleTransform2 retval;
        ReadFloatSimpleTransform2(&retval);
        return retval;
    }
    virtual void ReadFloatSimpleTransform2 (FloatSimpleTransform2 *destination) = 0;
    virtual void WriteFloatSimpleTransform2 (FloatSimpleTransform2 const &value) = 0;

    inline FloatMatrix2 ReadFloatMatrix2 ()
    {
        FloatMatrix2 retval;
        ReadFloatMatrix2(&retval);
        return retval;
    }
    virtual void ReadFloatMatrix2 (FloatMatrix2 *destination) = 0;
    virtual void WriteFloatMatrix2 (FloatMatrix2 const &value) = 0;

    inline FloatTransform2 ReadFloatTransform2 ()
    {
        FloatTransform2 retval(true);
        ReadFloatTransform2(&retval);
        return retval;
    }
    virtual void ReadFloatTransform2 (FloatTransform2 *destination) = 0;
    virtual void WriteFloatTransform2 (FloatTransform2 const &value) = 0;

protected:

    // ///////////////////////////////////////////////////////////////////////
    // protected modifiers
    // ///////////////////////////////////////////////////////////////////////

    inline void SetIsOpen (bool is_open)
    {
        m_is_open = is_open;
    }
    inline void SetIODirection (IODirection io_direction)
    {
        m_io_direction = io_direction;
    }
    inline void SetError (IOError error) const
    {
        m_error = error;
    }

    // ///////////////////////////////////////////////////////////////////////
    // procedures
    // ///////////////////////////////////////////////////////////////////////

    virtual void FlushWriteCache () = 0;

    bool m_is_open;
    IODirection m_io_direction;
    mutable IOError m_error;
}; // end of class Serializer

template <Uint32 bit_count>
BitArray<bit_count> Serializer::ReadBitArray ()
{
    ASSERT1(bit_count <= MAX_SUPPORTED_STRING_BUFFER_SIZE * 8);

    BitArray<bit_count> retval;

    for (Uint32 current_word = BitArray<bit_count>::HIGHEST_WORD_INDEX;
         current_word <= BitArray<bit_count>::HIGHEST_WORD_INDEX;
         --current_word)
    {
        Uint32 bits_to_read_for_current_word =
            current_word == BitArray<bit_count>::HIGHEST_WORD_INDEX ?
            bit_count % BitArray<bit_count>::WORD_SIZE_IN_BITS :
            BitArray<bit_count>::WORD_SIZE_IN_BITS;
        if (bits_to_read_for_current_word == 0)
            bits_to_read_for_current_word = BitArray<bit_count>::WORD_SIZE_IN_BITS;

        retval.SetWord(
            current_word,
            ReadUnsignedBits(bits_to_read_for_current_word));
        if (Error() != IOE_NONE)
            return retval;
    }

    return retval;
}

template <Uint32 bit_count>
void Serializer::WriteBitArray (BitArray<bit_count> const &value)
{
    ASSERT1(bit_count <= MAX_SUPPORTED_STRING_BUFFER_SIZE * 8);

    for (Uint32 current_word = BitArray<bit_count>::HIGHEST_WORD_INDEX;
         current_word <= BitArray<bit_count>::HIGHEST_WORD_INDEX;
         --current_word)
    {
        Uint32 bits_to_write_for_current_word =
            current_word == BitArray<bit_count>::HIGHEST_WORD_INDEX ?
            bit_count % BitArray<bit_count>::WORD_SIZE_IN_BITS :
            BitArray<bit_count>::WORD_SIZE_IN_BITS;
        if (bits_to_write_for_current_word == 0)
            bits_to_write_for_current_word = BitArray<bit_count>::WORD_SIZE_IN_BITS;

        WriteUnsignedBits(
            value.Word(current_word),
            bits_to_write_for_current_word);
        if (Error() != IOE_NONE)
            return;
    }
}

template <Uint32 bit_count>
BitArray<bit_count> Serializer::ReadBitArray (Uint32 const bits_to_read)
{
    ASSERT1(bit_count <= MAX_SUPPORTED_STRING_BUFFER_SIZE * 8);
    ASSERT1(bits_to_read > 0);
    ASSERT1(bits_to_read <= bit_count);

    BitArray<bit_count> retval;
    Uint32 highest_word_to_read = bits_to_read / BitArray<bit_count>::WORD_SIZE_IN_BITS;

    for (Uint32 current_word = highest_word_to_read;
         current_word <= highest_word_to_read; // trick to do > 0 for unsigned
         --current_word)
    {
        Uint32 bits_to_read_for_current_word =
            current_word == highest_word_to_read ?
            bits_to_read % BitArray<bit_count>::WORD_SIZE_IN_BITS :
            BitArray<bit_count>::WORD_SIZE_IN_BITS;
        if (bits_to_read_for_current_word == 0)
            bits_to_read_for_current_word = BitArray<bit_count>::WORD_SIZE_IN_BITS;

        retval.SetWord(
            current_word,
            ReadUnsignedBits(bits_to_read_for_current_word));
        if (Error() != IOE_NONE)
            return retval;
    }

    // there may be uninitialized words above highest_word_to_read
    for (Uint32 current_word = highest_word_to_read + 1;
         current_word <= BitArray<bit_count>::HIGHEST_WORD_INDEX;
         ++current_word)
    {
        retval.SetWord(current_word, 0);
    }

    return retval;
}

template <Uint32 bit_count>
void Serializer::WriteBitArray (
    BitArray<bit_count> const &value,
    Uint32 const bits_to_write)
{
    ASSERT1(bit_count <= MAX_SUPPORTED_STRING_BUFFER_SIZE * 8);
    ASSERT1(bits_to_write > 0);
    ASSERT1(bits_to_write <= bit_count);

    Uint32 highest_word_to_write = bits_to_write / BitArray<bit_count>::WORD_SIZE_IN_BITS;

    for (Uint32 current_word = highest_word_to_write;
         current_word <= highest_word_to_write; // trick to do > 0 for unsigned
         --current_word)
    {
        Uint32 bits_to_write_for_current_word =
            current_word == highest_word_to_write ?
            bits_to_write % BitArray<bit_count>::WORD_SIZE_IN_BITS :
            BitArray<bit_count>::WORD_SIZE_IN_BITS;
        if (bits_to_write_for_current_word == 0)
            bits_to_write_for_current_word = BitArray<bit_count>::WORD_SIZE_IN_BITS;

        WriteUnsignedBits(
            value.Word(current_word),
            bits_to_write_for_current_word);
        if (Error() != IOE_NONE)
            return;
    }
}

} // end of namespace Xrb

#endif // !defined(_XRB_SERIALIZER_HPP_)

---