dataOStream.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 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 Object* const& object )
{
    LBASSERT( !object || object->isAttached( ));
    (*this) << ObjectVersion( object );
    return *this;
}

template< class T >
void DataOStream::_writeSerializable( const T& object, const boost::true_type& )
{
    const auto& data = object.toBinary();
    (*this) << data.size << Array< const void >( data.ptr.get(), data.size );
}

template<> inline void DataOStream::_writeArray( const Array< void > array,
                                                 const boost::false_type& )
{
    _write( array.data, array.getNumBytes( ));
}

template<> inline void DataOStream::_writeArray( const Array< const void > array,
                                                 const boost::false_type& )
{
    _write( array.data, array.getNumBytes( ));
}

template< class T > inline
DataOStream& DataOStream::operator << ( const lunchbox::RefPtr< T >& ptr )
{
    return *this << ptr.get();
}

template< class T > inline
DataOStream& DataOStream::operator << ( const lunchbox::Buffer< T >& buffer )
{
    return (*this) << buffer.getSize()
                   << Array< const T >( buffer.getData(), buffer.getSize());
}

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

template< class K, class V > inline
DataOStream& DataOStream::operator << ( const std::map< K, V >& value )
{
    const uint64_t nElems = value.size();
    *this << nElems;
    for( typename std::map< K, V >::const_iterator it = value.begin();
         it != value.end(); ++it )
    {
        *this << it->first << it->second;
    }
    return *this;
}

template< class T > inline
DataOStream& DataOStream::operator << ( const std::set< T >& value )
{
    const uint64_t nElems = value.size();
    *this << nElems;
    for( typename std::set< T >::const_iterator it = value.begin();
         it != value.end(); ++it )
    {
        *this << *it;
    }
    return *this;
}

template< class K, class V > inline
DataOStream& DataOStream::operator << ( const stde::hash_map< K, V >& value )
{
    const uint64_t nElems = value.size();
    *this << nElems;
    for( typename stde::hash_map< K, V >::const_iterator it = value.begin();
         it != value.end(); ++it )
    {
        *this << it->first << it->second;
    }
    return *this;
}

template< class T > inline
DataOStream& DataOStream::operator << ( const stde::hash_set< T >& value )
{
    const uint64_t nElems = value.size();
    *this << nElems;
    for( typename stde::hash_set< T >::const_iterator it = value.begin();
         it != value.end(); ++it )
    {
        *this << *it;
    }
    return *this;
}

template< typename C > inline
void DataOStream::serializeChildren( const std::vector<C*>& children )
{
    const uint64_t nElems = children.size();
    (*this) << nElems;

    for( typename std::vector< C* >::const_iterator i = children.begin();
         i != children.end(); ++i )
    {
        C* child = *i;
        (*this) << ObjectVersion( child );
        LBASSERTINFO( !child || child->isAttached(),
                      "Found unmapped object during serialization" );
    }
}
template<> inline
DataOStream& DataOStream::operator << ( const std::vector< uint8_t >& value )
{ return _writeFlatVector( value ); }

template<> inline
DataOStream& DataOStream::operator << ( const std::vector< uint16_t >& value )
{ return _writeFlatVector( value ); }

template<> inline
DataOStream& DataOStream::operator << ( const std::vector< int16_t >& value )
{ return _writeFlatVector( value ); }

template<> inline
DataOStream& DataOStream::operator << ( const std::vector< uint32_t >& value )
{ return _writeFlatVector( value ); }

template<> inline
DataOStream& DataOStream::operator << ( const std::vector< int32_t >& value )
{ return _writeFlatVector( value ); }

template<> inline
DataOStream& DataOStream::operator << ( const std::vector< uint64_t >& value )
{ return _writeFlatVector( value ); }

template<> inline
DataOStream& DataOStream::operator << ( const std::vector< int64_t >& value )
{ return _writeFlatVector( value ); }

template<> inline
DataOStream& DataOStream::operator << ( const std::vector< float >& value )
{ return _writeFlatVector( value ); }

template<> inline
DataOStream& DataOStream::operator << ( const std::vector< double >& value )
{ return _writeFlatVector( value ); }

template<> inline DataOStream&
DataOStream::operator << ( const std::vector< ObjectVersion >& value )
{ return _writeFlatVector( value ); }
}