object.h

/* Copyright (c) 2005-2016, Stefan Eilemann <eile@equalizergraphics.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_OBJECT_H
#define CO_OBJECT_H

#include <co/dispatcher.h>    // base class
#include <co/localNode.h>     // used in RefPtr
#include <co/types.h>         // for Nodes
#include <co/version.h>       // used as default parameter
#include <lunchbox/bitOperation.h> // byteswap inline impl

namespace co
{
namespace detail { class Object; }
class ObjectCM;
typedef lunchbox::RefPtr< ObjectCM > ObjectCMPtr;

#  define CO_COMMIT_NEXT LB_UNDEFINED_UINT32 


class Object : public Dispatcher
{
public:
    enum ChangeType
    {
        NONE,              
        STATIC,            
        INSTANCE,          
        DELTA,             
        UNBUFFERED         
    };

    CO_API virtual ~Object();

    CO_API bool isAttached() const;

    CO_API LocalNodePtr getLocalNode();

    CO_API void setID( const uint128_t& identifier );

    CO_API const uint128_t& getID() const;

    CO_API uint32_t getInstanceID() const;

    CO_API bool isBuffered() const;

    CO_API bool isMaster() const;

    virtual ChangeType getChangeType() const { return STATIC; }

    virtual uint64_t getMaxVersions() const
        { return std::numeric_limits< uint64_t >::max(); }

    CO_API virtual CompressorInfo chooseCompressor() const;

    virtual bool isDirty() const { return true; }

    CO_API void push( const uint128_t& groupID, const uint128_t& objectType,
                      const Nodes& nodes );

    CO_API virtual uint128_t commit( const uint32_t incarnation =
                                     CO_COMMIT_NEXT );

    CO_API void setAutoObsolete( const uint32_t count );

    CO_API uint32_t getAutoObsolete() const;

    CO_API virtual uint128_t sync( const uint128_t& version = VERSION_HEAD );

    CO_API uint128_t getHeadVersion() const;

    CO_API uint128_t getVersion() const;

    CO_API virtual void notifyNewHeadVersion( const uint128_t& version );

    virtual void notifyNewVersion() {}

    virtual void getInstanceData( DataOStream& os LB_UNUSED ) {}

    virtual void applyInstanceData( DataIStream& is LB_UNUSED ) {}

    virtual void pack( DataOStream& os ) { getInstanceData( os ); }

    virtual void unpack( DataIStream& is ) { applyInstanceData( is ); }

    CO_API ObjectOCommand send( NodePtr node, const uint32_t cmd,
                                const uint32_t instanceID = CO_INSTANCE_ALL );

    virtual void notifyAttach() {}

    virtual void notifyAttached() {}

    CO_API virtual void notifyDetach();

    virtual void notifyDetached() {}

    uint32_t getMasterInstanceID() const;

    CO_API NodePtr getMasterNode();

    CO_API void removeSlave( NodePtr node, const uint32_t instanceID );
    CO_API void removeSlaves( NodePtr node ); 
    void setMasterNode( NodePtr node ); 

    void addInstanceDatas( const ObjectDataIStreamDeque&, const uint128_t&);

    void setupChangeManager( const Object::ChangeType type,
                             const bool master, LocalNodePtr localNode,
                             const uint32_t masterInstanceID );

    CO_API virtual void attach( const uint128_t& id,
                                const uint32_t instanceID );
    CO_API virtual void detach();

    void transfer( Object* from );

    void applyMapData( const uint128_t& version ); 
    void sendInstanceData( const Nodes& nodes ); 


protected:
    CO_API Object();

    Object& operator = ( const Object& ) { return *this; }

    CO_API explicit Object( const Object& );

private:
    detail::Object* const impl_;
    void _setChangeManager( ObjectCMPtr cm );

    ObjectCMPtr _getChangeManager();
    friend class ObjectStore;

    LB_TS_VAR( _thread );
};

CO_API std::ostream& operator << ( std::ostream&, const Object& );

CO_API std::ostream& operator << ( std::ostream&, const Object::ChangeType& );
}

namespace lunchbox
{
template<> inline void byteswap( co::Object::ChangeType& value )
{ byteswap( reinterpret_cast< uint32_t& >( value )); }
}
#endif // CO_OBJECT_H