dataIStream.h

/* Copyright (c) 2007, Stefan Eilemann <[email protected]> 
   All rights reserved. */

#ifndef EQNET_DATAISTREAM_H
#define EQNET_DATAISTREAM_H

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

#include <iostream>
#include <vector>

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

        //*{ 
        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 );
            if( nElems > 0 )
                read( &value[0], nElems * sizeof( T ) ); 
            return *this; 
        }

        void read( void* data, uint64_t size );

        const void*    getRemainingBuffer();

        uint64_t       getRemainingBufferSize();

        void           advanceBuffer( const uint64_t offset ); 

        virtual size_t nRemainingBuffers() const = 0;

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

        virtual void reset();
 
    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();
    };
}
}

#include <eq/net/nodeID.h>
namespace eq
{
namespace net
{
    // Some template specializations
    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 >> ( NodeID& nodeID )
    { 
        read( &nodeID, sizeof( nodeID ));
        nodeID.convertToHost();
        return *this;
    }
}
}

#endif //EQNET_DATAISTREAM_H