Zerobuf.h

/* Copyright (c) 2015-2016, Human Brain Project
 *                          Stefan.Eilemann@epfl.ch
 *                          grigori.chevtchenko@epfl.ch
 */

#ifndef ZEROBUF_ZEROBUF_H
#define ZEROBUF_ZEROBUF_H

#include <zerobuf/api.h>
#include <zerobuf/Allocator.h> // MSVC needs it for std::unique_ptr
#include <zerobuf/types.h>
#include <zerobuf/json.h> // friend
#include <servus/serializable.h> // base class
#include <servus/uint128_t.h> // used inline in operator <<

namespace zerobuf
{

class Zerobuf : public servus::Serializable
{
public:
    virtual size_t getZerobufStaticSize() const = 0;

    virtual size_t getZerobufNumDynamics() const = 0;

    virtual void notifyChanging() {}

    ZEROBUF_API virtual void compact( float threshold = 0.1f );

    ZEROBUF_API Zerobuf& operator = ( const Zerobuf& rhs );

    ZEROBUF_API Zerobuf( Zerobuf&& rhs );

    ZEROBUF_API Zerobuf& operator = ( Zerobuf&& rhs );

    ZEROBUF_API bool operator == ( const Zerobuf& rhs ) const;

    ZEROBUF_API bool operator != ( const Zerobuf& rhs ) const;

    ZEROBUF_API void reset( AllocatorPtr allocator );

    ZEROBUF_API void check() const;

protected:
    ZEROBUF_API explicit Zerobuf( AllocatorPtr alloc ); // takes ownership of alloc
    ZEROBUF_API virtual ~Zerobuf();

    // used by generated ZeroBuf objects
    ZEROBUF_API const Allocator& getAllocator() const;
    ZEROBUF_API Allocator& getAllocator();

    ZEROBUF_API void _copyZerobufArray( const void* data, size_t size,
                                        size_t arrayNum );

    ZEROBUF_API virtual void _parseJSON( const Json::Value& json );
    ZEROBUF_API virtual void _createJSON( Json::Value& json ) const;
    ZEROBUF_API friend void fromJSON( const Json::Value&,Zerobuf& );
    ZEROBUF_API friend void toJSON( const Zerobuf&, Json::Value& );

private:
    AllocatorPtr _allocator;

    Zerobuf() = delete;
    Zerobuf( const Zerobuf& zerobuf ) = delete;

    ZEROBUF_API bool _fromBinary( const void* data, const size_t size ) final;
    ZEROBUF_API Data _toBinary() const final;
    ZEROBUF_API bool _fromJSON( const std::string& json ) final;
    ZEROBUF_API std::string _toJSON() const final;
};

inline std::ostream& operator << ( std::ostream& os, const Zerobuf& zerobuf )
{
    return os << "\"" << zerobuf.getTypeName() << "\" : " << zerobuf.toJSON();
}

}

#endif