dataIStream.h

/* Copyright (c) 2007-2009, Stefan Eilemann <eile@equalizergraphics.com> 
 *
 * This library is free software; you can redistribute it and/or modify it under
 * the terms of the GNU Lesser General Public License version 2.1 as published
 * by the Free Software Foundation.
 *  
 * This library 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 Lesser General Public License for more
 * details.
 * 
 * You should have received a copy of the GNU Lesser General Public License
 * along with this library; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */

#ifndef EQNET_DATAISTREAM_H
#define EQNET_DATAISTREAM_H

#include <eq/net/object.h>  // nested VERSION_NONE enum
#include <eq/net/types.h>
#include <eq/base/buffer.h> // member

#include <iostream>
#include <vector>

namespace eq
{
namespace net
{
    class DataIStream
    {
    public:
        DataIStream();
        virtual ~DataIStream();

        virtual size_t nRemainingBuffers() const = 0;

        virtual uint32_t getVersion() const { return Object::VERSION_NONE; }

        virtual void reset();

        template< typename T >
        DataIStream& operator >> ( T& value )
            { read( &value, sizeof( value )); return *this; }

        template< typename T >
        DataIStream& operator >> ( std::vector< T >& value )
        {
            uint64_t nElems = 0;
            read( &nElems, sizeof( nElems ));
            value.resize( nElems );
            for( uint64_t i = 0; i < nElems; i++ )
                (*this) >> value[i];

            return *this; 
        }

        EQ_EXPORT void read( void* data, uint64_t size );

        EQ_EXPORT const void*    getRemainingBuffer();

        EQ_EXPORT uint64_t       getRemainingBufferSize();

        EQ_EXPORT void           advanceBuffer( const uint64_t offset ); 
 
    protected:
        virtual bool getNextBuffer( const uint8_t** buffer, uint64_t* size ) =0;

    private:
        const uint8_t* _input;
        uint64_t _inputSize;
        uint64_t  _position;

        bool _checkBuffer();

        template< typename T >
        DataIStream& _readFlatVector ( std::vector< T >& value )
        {
            uint64_t nElems = 0;
            read( &nElems, sizeof( nElems ));
            value.resize( nElems );
            if( nElems > 0 )
                read( &value.front(), nElems * sizeof( T ));            
            return *this; 
        }
    };
}
}

namespace eq
{
namespace net
{
    template<>
    inline DataIStream& DataIStream::operator >> ( std::string& str )
    { 
        uint64_t nElems = 0;
        read( &nElems, sizeof( nElems ));
        EQASSERT( nElems <= getRemainingBufferSize( ));
        if( nElems == 0 )
            str.clear();
        else
        {
            str.assign( static_cast< const char* >( getRemainingBuffer( )), 
                        nElems );
            advanceBuffer( nElems );
        }
        return *this; 
    }

    template<>
    inline DataIStream& DataIStream::operator >> ( base::UUID& id )
    { 
        read( &id, sizeof( id ));
        id.convertToHost();
        return *this;
    }

    template<>
    inline DataIStream& DataIStream::operator >> (std::vector< uint8_t >& value)
    {
        return _readFlatVector( value );
    }

    template<>
    inline DataIStream& DataIStream::operator >> (std::vector< uint32_t>& value)
    {
        return _readFlatVector( value );
    }

    template<>
    inline DataIStream& DataIStream::operator >> (std::vector< int32_t >& value)
    {
        return _readFlatVector( value );
    }

    template<>
    inline DataIStream& DataIStream::operator >> (std::vector< uint64_t>& value)
    {
        return _readFlatVector( value );
    }

    template<>
    inline DataIStream& DataIStream::operator >> (std::vector< int64_t >& value)
    {
        return _readFlatVector( value );
    }

    template<>
    inline DataIStream& DataIStream::operator >> ( std::vector< float >& value )
    {
        return _readFlatVector( value );
    }

    template<>
    inline DataIStream& DataIStream::operator >> ( std::vector< double >& value)
    {
        return _readFlatVector( value );
    }
}
}

#endif //EQNET_DATAISTREAM_H