dataIStream.h

/* Copyright (c) 2007-2016, Stefan Eilemann <eile@equalizergraphics.com>
 *                          Cedric Stalder <cedric.stalder@gmail.com>
 *                          Daniel Nachbaur <danielnachbaur@gmail.com>
 *
 * This file is part of Collage <https://github.com/Eyescale/Collage>
 *
 * 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 CO_DATAISTREAM_H
#define CO_DATAISTREAM_H

#include <co/api.h>
#include <co/types.h>
#include <lunchbox/array.h> // used inline
#include <lunchbox/bitOperation.h>
#include <lunchbox/stdExt.h>

#include <boost/type_traits.hpp>
#include <map>
#include <set>
#include <vector>

namespace co
{
namespace detail { class DataIStream; }

class DataIStream
{
public:
    virtual size_t nRemainingBuffers() const = 0;

    virtual uint128_t getVersion() const = 0; 
    virtual void reset() { _reset(); } 
    void setSwapping( const bool onOff ); 
    CO_API bool isSwapping() const; 
    DataIStream& operator = ( const DataIStream& rhs ); 


    template< typename T > T read()
        { T value; *this >> value; return value; }

    template< class T > DataIStream& operator >> ( T& value )
        { _read( value, boost::has_trivial_copy< T >( )); return *this; }

    template< class T > DataIStream& operator >> ( Array< T > array )
        { _readArray( array, boost::has_trivial_copy< T >( )); return *this; }

    template< class T > DataIStream& operator >> ( lunchbox::RefPtr< T >& );

    template< class T > DataIStream& operator >> ( lunchbox::Buffer< T >& );

    template< class T > DataIStream& operator >> ( std::vector< T >& );

    template< class K, class V >
    DataIStream& operator >> ( std::map< K, V >& );

    template< class T > DataIStream& operator >> ( std::set< T >& );

    template< class K, class V >
    DataIStream& operator >> ( stde::hash_map< K, V >& );

    template< class T > DataIStream& operator >> ( stde::hash_set< T >& );

#  ifdef CO_IGNORE_BYTESWAP

    template< class T > static void swap( T& ) { /* nop */ }
#  else

    template< class T > static void swap( T& v ) { lunchbox::byteswap(v); }
#  endif

    template< typename O, typename C >
    void deserializeChildren( O* object, const std::vector< C* >& old,
                              std::vector< C* >& result );

    CO_API const void* getRemainingBuffer( const uint64_t size );

    CO_API uint64_t getRemainingBufferSize();

    bool wasUsed() const;

    bool hasData() { return _checkBuffer(); }

    CO_API virtual NodePtr getRemoteNode() const = 0;

    CO_API virtual LocalNodePtr getLocalNode() const = 0;

protected:
    CO_API explicit DataIStream( const bool swap );
    explicit DataIStream( const DataIStream& );
    CO_API virtual ~DataIStream();

    virtual bool getNextBuffer( CompressorInfo& info, uint32_t& nChunks,
                                const void*& chunkData, uint64_t& size ) = 0;

private:
    detail::DataIStream* const _impl;

    CO_API void _read( void* data, uint64_t size );

    CO_API bool _checkBuffer();
    CO_API void _reset();

    const uint8_t* _decompress( const void* data, const CompressorInfo& info,
                                uint32_t nChunks, uint64_t dataSize );

    template< class T >
    DataIStream& _readFlatVector ( std::vector< T >& value )
    {
        uint64_t nElems = 0;
        *this >> nElems;
        LBASSERTINFO( nElems < LB_BIT48,
                      "Out-of-sync DataIStream: " << nElems << " elements?" );
        value.resize( size_t( nElems ));
        if( nElems > 0 )
            *this >> Array< T >( &value.front(), nElems );
        return *this;
    }

    template< class T > void _swap( T& value ) const
        { if( isSwapping( )) swap( value ); }

    template< class T > void _read( T& value, const boost::true_type& )
        { _read( &value, sizeof( value )); _swap( value ); }

    template< class T > void _read( T& value, const boost::false_type& )
    { _readSerializable( value, boost::is_base_of< servus::Serializable, T >( ));}

    template< class T > void _readSerializable(T& value, const boost::true_type&);

    template< class T > void _readArray( Array< T >, const boost::true_type& );

    template< class T > void _readArray( Array< T >, const boost::false_type& );

    template< class T > void _swap( Array< T > array ) const
    {
        if( !isSwapping( ))
            return;
#pragma omp parallel for
        for( ssize_t i = 0; i < ssize_t( array.num ); ++i )
            swap( array.data[i] );
    }
};
}

#include "dataIStream.ipp" // template implementation

#endif //CO_DATAISTREAM_H