mem_stream.h

Go to the documentation of this file.

/* Copyright, 2000 Nevrax Ltd.
 *
 * This file is part of NEVRAX NEL.
 * NEVRAX NEL is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2, or (at your option)
 * any later version.

 * NEVRAX NEL is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 * General Public License for more details.

 * You should have received a copy of the GNU General Public License
 * along with NEVRAX NEL; see the file COPYING. If not, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
 * MA 02111-1307, USA.
 */

#ifndef NL_MEM_STREAM_H
#define NL_MEM_STREAM_H

#include "types_nl.h"
#include "stream.h"
#include "object_vector.h"
#include "fast_mem.h"
#include "smart_ptr.h"

#include <algorithm>

namespace NLMISC
{

struct EMemStream : public NLMISC::EStream
{
    EMemStream( const std::string& str ) : EStream( str ) {}
};


class CMemStreamBuffer
{
public:
    typedef CObjectVector<uint8, false> TBuffer;
private:
    struct TMemStreamBuffer : public CRefCount
    {
        // the buffer himself
        TBuffer _Buffer;
    };

    typedef CSmartPtr<TMemStreamBuffer> TMemStreamBufferPtr;

    TMemStreamBufferPtr     _SharedBuffer;

public:

    mutable uint32  Pos;

    CMemStreamBuffer()
    {
        _SharedBuffer = new TMemStreamBuffer;
        Pos = 0;
    }


    const TBuffer &getBuffer() const
    {
        return _SharedBuffer->_Buffer;
    }

    TBuffer &getBufferWrite()
    {
        if (_SharedBuffer->getRefCount() > 1)
        {
            // we need to duplicate the buffer
            _SharedBuffer = new TMemStreamBuffer(*_SharedBuffer);
        }
        return _SharedBuffer->_Buffer;
    }

    void swap(CMemStreamBuffer &other)
    {
        std::swap(_SharedBuffer, other._SharedBuffer);
        std::swap(Pos, other.Pos);
    }

};


class CMemStream : public NLMISC::IStream
{
public:

    CMemStream( bool inputStream=false, bool stringmode=false, uint32 defaultcapacity=0 ) :
        NLMISC::IStream( inputStream ), _StringMode( stringmode )
    {
        _DefaultCapacity = std::max( (uint32)defaultcapacity, (uint32)16 ); // prevent from no allocation
        _Buffer.getBufferWrite().resize (_DefaultCapacity);
        _Buffer.Pos = 0;
    }

    CMemStream( const CMemStream& other ) :
        IStream (other)
    {
        operator=( other );
    }

    CMemStream&     operator=( const CMemStream& other )
    {
        IStream::operator= (other);
        _Buffer = other._Buffer;
        _StringMode = other._StringMode;
        _DefaultCapacity = other._DefaultCapacity;
        return *this;
    }

    void swap(CMemStream &other);

    void            setStringMode( bool stringmode ) { _StringMode = stringmode; }

    bool            stringMode() const { return _StringMode; }

    std::string     toString( bool hexFormat=false ) const;

    virtual void    serialBuffer(uint8 *buf, uint len);

    virtual void    serialBit(bool &bit);

    virtual bool    seek (sint32 offset, TSeekOrigin origin) const throw(EStream);

    virtual sint32  getPos () const throw(EStream)
    {
        return sint32(_Buffer.Pos);
    }

    sint32          reserve( uint len )
    {
        sint32 pos = sint32(_Buffer.Pos);
        if ( ! isReading() )
        {
            increaseBufferIfNecessary( len );
            _Buffer.Pos += len;
        }
        return pos;
    }

    template <class T>
    void            poke( T value, sint32 pos )
    {
        if ( ! isReading() )
        {
            uint8 *pokeBufPos = _Buffer.getBufferWrite().getPtr() + pos;
            nlassert( pokeBufPos + sizeof(T) <= pokeBufPos+_Buffer.Pos );
            *(T*)pokeBufPos = value;
        }
    }

    virtual void    clear()
    {
        resetPtrTable();
        _Buffer.getBufferWrite().clear();
        if (!isReading())
        {
            _Buffer.getBufferWrite().resize (_DefaultCapacity);
        }
        _Buffer.Pos = 0;
    }

    virtual uint32  length() const
    {
        if ( isReading() )
        {
            return lengthR();
        }
        else
        {
            return lengthS();
        }
    }

    uint32          size() const
    {
        return _Buffer.getBuffer().size();
    }

    virtual const uint8     *buffer() const
    {
        return _Buffer.getBuffer().getPtr();
    }


    void            resetBufPos() { _Buffer.Pos = 0; }

    void            fill( const uint8 *srcbuf, uint32 len )
    {
        if (len == 0) return;

        _Buffer.getBufferWrite().resize( len );
        CFastMem::memcpy( _Buffer.getBufferWrite().getPtr(), srcbuf, len );
        if (isReading())
        {
            _Buffer.Pos = 0;
        }
        else
        {
            _Buffer.Pos = _Buffer.getBuffer().size();
        }
    }

    void            resize (uint32 size);

    uint8           *bufferToFill( uint32 msgsize )
    {
#ifdef NL_DEBUG
        nlassert( isReading() );
#endif
        if ( msgsize == 0 )
            return NULL;

        _Buffer.getBufferWrite().resize( msgsize );
        _Buffer.Pos = 0;
        return _Buffer.getBufferWrite().getPtr();
    }

    virtual void    invert()
    {
        if ( isReading() )
        {
            // In->Out: We want to write (serialize out) what we have read (serialized in)
            uint32 sizeOfReadStream = lengthR();
            resetPtrTable();
            setInOut( false );
            _Buffer.Pos = sizeOfReadStream;
        }
        else
        {
            // Out->In: We want to read (serialize in) what we have written (serialized out)
            resetPtrTable();
            setInOut( true );
            // TODO : is it necessary ?
            _Buffer.getBufferWrite().resize (_Buffer.Pos);
            _Buffer.Pos = 0;
        }
    }

    void            resetPtrTable() { IStream::resetPtrTable() ; }

#ifdef NL_OS_WINDOWS
    __forceinline
#endif
    void            increaseBufferIfNecessary(uint32 len)
    {
        uint32 oldBufferSize = _Buffer.getBuffer().size();
        if (_Buffer.Pos + len > oldBufferSize)
        {
            // need to increase the buffer size
            _Buffer.getBufferWrite().resize(oldBufferSize*2 + len);
        }
    }


    template <class T> void fastSerial (T &val)
    {
#ifdef NL_LITTLE_ENDIAN
        if(isReading())
        {
            // Check that we don't read more than there is to read
            if ( lengthS()+sizeof(T) > length() ) // calls virtual length (cf. sub messages)
                throw EStreamOverflow();
            // Serialize in
            val = *(T*)(_Buffer.getBuffer().getPtr() + _Buffer.Pos);
        }
        else
        {
            increaseBufferIfNecessary (sizeof(T));
            *(T*)(_Buffer.getBufferWrite().getPtr() + _Buffer.Pos) = val;
        }
        _Buffer.Pos += sizeof (T);
#else // NL_LITTLE_ENDIAN
        IStream::serial( val );
#endif // NL_LITTLE_ENDIAN
    }

    template <class T>
    void            fastWrite( const T& value )
    {
        //nldebug( "MEMSTREAM: Writing %u-byte value in %p at pos %u", sizeof(value), this, _BufPos - _Buffer.getPtr() );
        increaseBufferIfNecessary (sizeof(T));
        *(T*)(_Buffer.getBufferWrite().getPtr() + _Buffer.Pos) = value;

        _Buffer.Pos += sizeof (T);
    }

    template <class T>
    void            fastRead( T& value )
    {
        //nldebug( "MEMSTREAM: Reading %u-byte value in %p at pos %u", sizeof(value), this, _BufPos - _Buffer.getPtr() );
        // Check that we don't read more than there is to read
        if ( lengthS()+sizeof(value) > length() ) // calls virtual length (cf. sub messages)
        {
            throw EStreamOverflow();
        }
        // Serialize in
        value = *(T*)(_Buffer.getBuffer().getPtr() + _Buffer.Pos);
        _Buffer.Pos += sizeof(value);
    }


    template<class T>
    void            serial(T &obj)              { obj.serial(*this); }


    template<class T>
    void            serialCont(std::vector<T> &cont)        {IStream::serialCont(cont);}
    template<class T>
    void            serialCont(std::list<T> &cont)          {IStream::serialCont(cont);}
    template<class T>
    void            serialCont(std::deque<T> &cont)         {IStream::serialCont(cont);}
    template<class T>
    void            serialCont(std::set<T> &cont)           {IStream::serialCont(cont);}
    template<class T>
    void            serialCont(std::multiset<T> &cont)      {IStream::serialCont(cont);}
    template<class K, class T>
    void            serialCont(std::map<K, T> &cont)        {IStream::serialCont(cont);}
    template<class K, class T>
    void            serialCont(std::multimap<K, T> &cont)   {IStream::serialCont(cont);}
    virtual void            serialCont(std::vector<uint8> &cont) {IStream::serialCont(cont);}
    virtual void            serialCont(std::vector<sint8> &cont) {IStream::serialCont(cont);}
    virtual void            serialCont(std::vector<bool> &cont) {IStream::serialCont(cont);}



    template<class T0,class T1>
    void            serial(T0 &a, T1 &b)
    { serial(a); serial(b);}
    template<class T0,class T1,class T2>
    void            serial(T0 &a, T1 &b, T2 &c)
    { serial(a); serial(b); serial(c);}
    template<class T0,class T1,class T2,class T3>
    void            serial(T0 &a, T1 &b, T2 &c, T3 &d)
    { serial(a); serial(b); serial(c); serial(d);}
    template<class T0,class T1,class T2,class T3,class T4>
    void            serial(T0 &a, T1 &b, T2 &c, T3 &d, T4 &e)
    { serial(a); serial(b); serial(c); serial(d); serial(e);}
    template<class T0,class T1,class T2,class T3,class T4,class T5>
    void            serial(T0 &a, T1 &b, T2 &c, T3 &d, T4 &e, T5 &f)
    { serial(a); serial(b); serial(c); serial(d); serial(e); serial(f);}

    virtual void    serial(uint8 &b) ;
    virtual void    serial(sint8 &b) ;
    virtual void    serial(uint16 &b) ;
    virtual void    serial(sint16 &b) ;
    virtual void    serial(uint32 &b) ;
    virtual void    serial(sint32 &b) ;
    virtual void    serial(uint64 &b) ;
    virtual void    serial(sint64 &b) ;
    virtual void    serial(float &b) ;
    virtual void    serial(double &b) ;
    virtual void    serial(bool &b) ;
#ifndef NL_OS_CYGWIN
    virtual void    serial(char &b) ;
#endif
    virtual void    serial(std::string &b) ;
    virtual void    serial(ucstring &b) ;




    uint            serialSeparatedBufferIn( uint8 *buf, uint len );

    void            serialSeparatedBufferOut( uint8 *buf, uint len );

    virtual void    serialHex(uint32 &b);


protected:

    virtual uint32          lengthS() const
    {
        return _Buffer.Pos; // not calling getPos() because virtual and not const!
    }

    uint32          lengthR() const
    {
        return size();
    }

    virtual uint            getDbgStreamSize() const;

    CMemStreamBuffer            _Buffer;

    mutable bool                _StringMode;

    uint32                      _DefaultCapacity;
};

// Input
#define readnumber(dest,thetype,digits,convfunc) \
    char number_as_cstring [digits+1]; \
    uint realdigits = serialSeparatedBufferIn( (uint8*)number_as_cstring, digits ); \
    number_as_cstring[realdigits] = '\0'; \
    dest = (thetype)convfunc( number_as_cstring );

// Output
#define writenumber(src,format,digits) \
    char number_as_cstring [digits+1]; \
    sprintf( number_as_cstring, format, src ); \
    serialSeparatedBufferOut( (uint8*)number_as_cstring, strlen(number_as_cstring) );

/*
 * atoihex
 */
inline uint32 atoihex( const char* ident )
{
    uint32 number;
    sscanf( ident, "%x", &number );
    return number;
}

inline uint32 atoui( const char *ident)
{
    return (uint32) strtoul (ident, NULL, 10);
}

static const char SEPARATOR = ' ';
static const int SEP_SIZE = 1; // the code is easier to read with that

//
// inline serial functions
//


// ======================================================================================================
inline  void        CMemStream::serial(uint8 &b)
{
    if ( _StringMode )
    {
        if ( isReading() )
        {
            readnumber( b, uint8, 3, atoi ); // 255
        }
        else
        {
            writenumber( (uint16)b,"%hu", 3 );
        }
    }
    else
    {
        fastSerial (b);
    }
}

// ======================================================================================================
inline  void        CMemStream::serial(sint8 &b)
{
    if ( _StringMode )
    {
        if ( isReading() )
        {
            readnumber( b, sint8, 4, atoi ); // -128
        }
        else
        {
            writenumber( (sint16)b, "%hd", 4 );
        }
    }
    else
    {
        fastSerial (b);
    }
}

// ======================================================================================================
inline  void        CMemStream::serial(uint16 &b)
{
    if ( _StringMode )
    {
        // No byte swapping in text mode
        if ( isReading() )
        {
            readnumber( b, uint16, 5, atoi ); // 65535
        }
        else
        {
            writenumber( b, "%hu", 5 );
        }
    }
    else
    {
        fastSerial (b);
    }
}

// ======================================================================================================
inline  void        CMemStream::serial(sint16 &b)
{
    if ( _StringMode )
    {
        if ( isReading() )
        {
            readnumber( b, sint16, 6, atoi ); // -32768
        }
        else
        {
            writenumber( b, "%hd", 6 );
        }
    }
    else
    {
        fastSerial (b);
    }
}

// ======================================================================================================
inline  void        CMemStream::serial(uint32 &b)
{
    if ( _StringMode )
    {
        if ( isReading() )
        {
            readnumber( b, uint32, 10, atoui ); // 4294967295
        }
        else
        {
            writenumber( b, "%u", 10 );
        }
    }
    else
    {
        fastSerial (b);
    }
}


// ======================================================================================================
inline  void        CMemStream::serial(sint32 &b)
{
    if ( _StringMode )
    {
        if ( isReading() )
        {
            readnumber( b, sint32, 11, atoi ); // -2147483648
        }
        else
        {
            writenumber( b, "%d", 11 );
        }
    }
    else
    {
        fastSerial (b);
    }
}

// ======================================================================================================
inline  void        CMemStream::serial(uint64 &b)
{
    if ( _StringMode )
    {
        if ( isReading() )
        {
            readnumber( b, uint64, 20, atoiInt64 ); // 18446744073709551615
        }
        else
        {
            writenumber( b, "%"NL_I64"u", 20 );
        }
    }
    else
    {
        fastSerial (b);
    }
}

// ======================================================================================================
inline  void        CMemStream::serial(sint64 &b)
{
    if ( _StringMode )
    {
        if ( isReading() )
        {
            readnumber( b, sint64, 20, atoiInt64 ); // -9223372036854775808
        }
        else
        {
            writenumber( b, "%"NL_I64"d", 20 );
        }
    }
    else
    {
        fastSerial (b);
    }
}

// ======================================================================================================
inline  void        CMemStream::serial(float &b)
{
    if ( _StringMode )
    {
        if ( isReading() )
        {
            readnumber( b, float, 128, atof ); // ?
        }
        else
        {
            writenumber( (double)b, "%f", 128 );
        }
    }
    else
    {
        fastSerial (b);
    }
}

// ======================================================================================================
inline  void        CMemStream::serial(double &b)
{
    if ( _StringMode )
    {
        if ( isReading() )
        {
            readnumber( b, double, 128, atof ); //
        }
        else
        {
            writenumber( b, "%f", 128 );
        }
    }
    else
    {
        fastSerial (b);
    }
}

// ======================================================================================================
inline  void        CMemStream::serial(bool &b)
{
    if ( _StringMode )
    {
        serialBit(b);
    }
    else
    {
        fastSerial (b);
    }
}


#ifndef NL_OS_CYGWIN
// ======================================================================================================
inline  void        CMemStream::serial(char &b)
{
    if ( _StringMode )
    {
        char buff [2];
        if ( isReading() )
        {
            serialBuffer( (uint8*)buff, 2 );
            b = buff[0];
        }
        else
        {
            buff[0] = b;
            buff[1] = SEPARATOR;
            serialBuffer( (uint8*)buff, 2 );
        }
    }
    else
    {
        fastSerial (b);
    }
}
#endif

// ======================================================================================================
inline  void        CMemStream::serial(std::string &b)
{
    if ( _StringMode )
    {
        uint32  len=0;
        // Read/Write the length.
        if(isReading())
        {
            serial(len);
            checkStreamSize((uint)len);
            /*if (len>1000000)
                throw NLMISC::EInvalidDataStream( "CMemStream/str: Trying to read a string of %u bytes", len );
            */
            b.resize(len);
        }
        else
        {
            len= (uint32)b.size();
            if (len>1000000)
                throw NLMISC::EInvalidDataStream( "CMemStream/str: Trying to write a string of %u bytes", len );
            serial(len);
        }

        // Read/Write the string.
        for(uint i=0;i!=len;++i)
            serialBuffer( (uint8*)&(b[i]), sizeof(b[i]) );

        char sep = SEPARATOR;
        serialBuffer( (uint8*)&sep, 1 );
    }
    else
    {
        if (isReading())
        {
            if (!isXML())
            {
                uint32  len=0;
                fastSerial(len);
                checkStreamSize((uint)len);
                /*
                if (len>1000000)
                    throw NLMISC::EInvalidDataStream( "CMemStream: Trying to read a string of %u bytes", len );
                */
                b.resize(len);
                if (len > 0)
                {
                    // can serial all in a single call to serialBuffer, since sizeof(char) == 1
                    serialBuffer((uint8 *) &b[0], len);
                }
            }
            else
            {
                IStream::serial( b );
            }
        }
        else
        {
            IStream::serial( b );
        }
    }
}


// ======================================================================================================
inline  void        CMemStream::serial(ucstring &b)
{
    if ( _StringMode )
    {
        uint32  len=0;
        // Read/Write the length.
        if(isReading())
        {
            serial(len);
            checkStreamSize((uint)len);
            /*
            if (len>1000000)
                throw NLMISC::EInvalidDataStream( "CMemStream/str: Trying to read an ucstring of %u bytes", len );
            */
            b.resize(len);
        }
        else
        {
            len= (uint32)b.size();
            if (len>1000000)
                throw NLMISC::EInvalidDataStream( "CMemStream/str: Trying to write an ucstring of %u bytes", len );
            serial(len);
        }
        // Read/Write the string.
        for(uint i=0;i!=len;++i)
            serialBuffer( (uint8*)&b[i], sizeof(b[i]) );

        char sep = SEPARATOR;
        serialBuffer( (uint8*)&sep, 1 );
    }
    else
    {
        IStream::serial( b );
    }
}



/*
 * Serialisation in hexadecimal
 */
inline  void    CMemStream::serialHex(uint32 &b)
{
    if ( _StringMode )
    {
        if ( isReading() )
        {
            readnumber( b, uint32, 10, atoihex ); // 4294967295
        }
        else
        {
            writenumber( b, "%x", 10 );
        }
    }
    else
    {
        IStream::serial( b );
    }
}

}

#endif // NL_MEM_STREAM_H

/* End of mem_stream.h */