dataOStream.h

/* Copyright (c) 2007-2008, Stefan Eilemann <eile@equalizergraphics.com> 
   All rights reserved. */

#ifndef EQNET_DATAOSTREAM_H
#define EQNET_DATAOSTREAM_H

#include <eq/base/buffer.h> // member
#include <eq/net/types.h>   // ConnectionVector member

#include <iostream>
#include <vector>

namespace eq
{
namespace net
{
    class Connection;

    class EQ_EXPORT DataOStream
    {
    public:
        DataOStream();
        virtual ~DataOStream();

        void enable( const NodeVector& receivers );
        void enable( const ConnectionVector& receivers );
        void enable( const NodePtr node );
        void enable();

        void resend( const NodePtr node );

        void disable();

        void flush();

        void enableBuffering();
        void disableBuffering();
        
        void enableSave();
        void disableSave();

        //*{
        bool hasSentData() const { return _dataSent; }

        const base::Bufferb& getSaveBuffer() const 
            { EQASSERT( _save ); return _buffer; }
        //*}

        //*{
        template< typename T >
        DataOStream& operator << ( const T& value )
            { write( &value, sizeof( value )); return *this; }

        template< typename T >
        DataOStream& operator << ( const std::vector< T >& value )
            { 
                const uint64_t nElems = value.size();
                write( &nElems, sizeof( nElems ));
                if( nElems > 0 )
                    write( &value[0], nElems * sizeof( T ) );
                return *this;
            }

        void write( const void* data, uint64_t size );
        void writeOnce( const void* data, uint64_t size );
        //*}

 
    protected:
        virtual void sendHeader( const void* buffer, const uint64_t size ) = 0;
        virtual void sendBuffer( const void* buffer, const uint64_t size ) = 0;
        virtual void sendFooter( const void* buffer, const uint64_t size ) = 0;
        virtual void sendSingle( const void* buffer, const uint64_t size )
            { sendHeader( buffer, size ); sendFooter( 0, 0 ); }

        ConnectionVector _connections;

    private:
        base::Bufferb  _buffer;
        uint64_t _bufferStart;
        static uint64_t _highWaterMark;
        
        bool _enabled;
        bool _dataSent;
        bool _buffered;
        bool _save;

        void _sendBuffer( const void* data, const uint64_t size );
        
        void _resetStart();

        void _unlockConnections();
    };

}
}

#include <eq/net/nodeID.h>
namespace eq
{
namespace net
{
    // Some template specializations
    template<>
    inline DataOStream& DataOStream::operator << ( const std::string& str )
    { 
        const uint64_t nElems = str.length();
        write( &nElems, sizeof( nElems ));
        if ( nElems > 0 )
            write( str.c_str(), nElems );

        return *this;
    }
    template<>
    inline DataOStream& DataOStream::operator << ( const NodeID& nodeID )
    { 
        NodeID out( nodeID );
        out.convertToNetwork();
        write( &out, sizeof( out ));
        return *this;
    }
}
}
#endif //EQNET_DATAOSTREAM_H