dataIStream.ipp

/* Copyright (c) 2012-2016, Daniel Nachbaur <danielnachbaur@gmail.com>
 *                          Stefan.Eilemann@epfl.ch
 *
 * 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.
 */

#include <co/object.h>
#include <co/objectVersion.h>
#include <servus/serializable.h> // used inline

namespace co
{
template<> inline DataIStream& DataIStream::operator >> ( std::string& str )
{
    uint64_t nElems = 0;
    *this >> nElems;
    const uint64_t maxElems = getRemainingBufferSize();
    LBASSERTINFO( nElems <= maxElems,
                  nElems << " > " << maxElems );
    if( nElems == 0 )
        str.clear();
    else if( nElems <= maxElems )
        str.assign( static_cast< const char* >( getRemainingBuffer(nElems)),
                    size_t( nElems ));
    else
        str.assign(
            static_cast< const char* >( getRemainingBuffer(maxElems)),
                size_t( maxElems ));
    return *this;
}

template<> inline DataIStream& DataIStream::operator >> ( Object*& object )
{
    ObjectVersion data;
    *this >> data;
    LBASSERT( object->getID() == data.identifier );
    object->sync( data.version );
    return *this;
}

template< class T >
void DataIStream::_readSerializable( T& object, const boost::true_type& )
{
    const size_t size = read< size_t >();
    object.fromBinary( getRemainingBuffer( size ), size );
}

template< class T >
void DataIStream::_readArray( Array< T > array, const boost::true_type& )
{
    _read( array.data, array.getNumBytes( ));
    _swap( array );
}

template< class T >
void DataIStream::_readArray( Array< T > array, const boost::false_type& )
{
    for( size_t i = 0; i < array.num; ++i )
        *this >> array.data[ i ];
}

template<> inline
void DataIStream::_readArray( Array< void > array, const boost::false_type& )
{
    _read( array.data, array.getNumBytes( ));
}

template< class T > inline DataIStream&
DataIStream::operator >> ( lunchbox::RefPtr< T >& ptr )
{
    T* object = 0;
    *this >> object;
    ptr = object;
    return *this;
}

template< class T > inline DataIStream&
DataIStream::operator >> ( lunchbox::Buffer< T >& buffer )
{
    uint64_t nElems = 0;
    *this >> nElems;
    LBASSERTINFO( nElems < LB_BIT48,
                  "Out-of-sync co::DataIStream: " << nElems << " elements?" );
    buffer.resize( nElems );
    return *this >> Array< T >( buffer.getData(), nElems );
}


template< class T > inline DataIStream&
DataIStream::operator >> ( std::vector< T >& value )
{
    uint64_t nElems = 0;
    *this >> nElems;
    value.resize( nElems );
    for( uint64_t i = 0; i < nElems; ++i )
        *this >> value[i];
    return *this;
}

template< class K, class V > inline DataIStream&
DataIStream::operator >> ( std::map< K, V >& map )
{
    map.clear();
    uint64_t nElems = 0;
    *this >> nElems;
    for( uint64_t i = 0; i < nElems; ++i )
    {
        typename std::map< K, V >::key_type key;
        typename std::map< K, V >::mapped_type value;
        *this >> key >> value;
        map.insert( std::make_pair( key, value ));
    }
    return *this;
}

template< class T > inline DataIStream&
DataIStream::operator >> ( std::set< T >& value )
{
    value.clear();
    uint64_t nElems = 0;
    *this >> nElems;
    for( uint64_t i = 0; i < nElems; ++i )
    {
        T item;
        *this >> item;
        value.insert( item );
    }
    return *this;
}

template< class K, class V > inline DataIStream&
DataIStream::operator >> ( stde::hash_map< K, V >& map )
{
    map.clear();
    uint64_t nElems = 0;
    *this >> nElems;
    for( uint64_t i = 0; i < nElems; ++i )
    {
        typename stde::hash_map< K, V >::key_type key;
        typename stde::hash_map< K, V >::mapped_type value;
        *this >> key >> value;
        map.insert( std::make_pair( key, value ));
    }
    return *this;
}

template< class T > inline DataIStream&
DataIStream::operator >> ( stde::hash_set< T >& value )
{
    value.clear();
    uint64_t nElems = 0;
    *this >> nElems;
    for( uint64_t i = 0; i < nElems; ++i )
    {
        T item;
        *this >> item;
        value.insert( item );
    }
    return *this;
}

namespace
{
class ObjectFinder
{
public:
    explicit ObjectFinder( const uint128_t& id ) : _id( id ) {}
    bool operator()( co::Object* candidate )
        { return candidate->getID() == _id; }

private:
    const uint128_t _id;
};
}

template< typename O, typename C > inline void
DataIStream::deserializeChildren( O* object, const std::vector< C* >& old_,
                                  std::vector< C* >& result )
{
    ObjectVersions versions;
    *this >> versions;
    std::vector< C* > old = old_;

    // rebuild vector from serialized list
    result.clear();
    for( ObjectVersions::const_iterator i = versions.begin();
         i != versions.end(); ++i )
    {
        const ObjectVersion& version = *i;

        if( version.identifier == uint128_t( ))
        {
            result.push_back( 0 );
            continue;
        }

        typename std::vector< C* >::iterator j =
            lunchbox::find_if( old, ObjectFinder( version.identifier ));

        if( j == old.end( )) // previously unknown child
        {
            C* child = 0;
            object->create( &child );
            LocalNodePtr localNode = object->getLocalNode();
            LBASSERT( child );
            LBASSERT( !object->isMaster( ));

            LBCHECK( localNode->mapObject( child, version ));
            result.push_back( child );
        }
        else
        {
            C* child = *j;
            old.erase( j );
            if( object->isMaster( ))
                child->sync( VERSION_HEAD );
            else
                child->sync( version.version );

            result.push_back( child );
        }
    }

    while( !old.empty( )) // removed children
    {
        C* child = old.back();
        old.pop_back();
        if( !child )
            continue;

        if( child->isAttached() && !child->isMaster( ))
        {
            LocalNodePtr localNode = object->getLocalNode();
            localNode->unmapObject( child );
        }
        object->release( child );
    }
}
template<> inline DataIStream&
DataIStream::operator >> ( std::vector< uint8_t >& value )
{ return _readFlatVector( value );}

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

template<> inline DataIStream&
DataIStream::operator >> ( std::vector< int16_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 ); }

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