co/object.h

/* Copyright (c) 2005-2012, Stefan Eilemann <eile@equalizergraphics.com> 
 *
 * 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

namespace co
{
    class ObjectCM;

#  define CO_COMMIT_NEXT LB_UNDEFINED_UINT32 //!< the next commit incarnation

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

        CO_API Object();

        CO_API virtual ~Object();

        bool isAttached() const { return _instanceID != EQ_INSTANCE_INVALID; }

        LocalNodePtr getLocalNode() { return _localNode; }

        CO_API void setID( const UUID& identifier );

        const UUID& getID() const { return _id; }

        uint32_t getInstanceID() const { return _instanceID; }

        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 uint32_t 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 ) = 0;

        virtual void applyInstanceData( DataIStream& is ) = 0;

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

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

        CO_API bool send( NodePtr node, ObjectPacket& packet );

        CO_API bool send( NodePtr node, ObjectPacket& packet,
                          const std::string& string );

        CO_API bool send( NodePtr node, ObjectPacket& packet, 
                          const void* data, const uint64_t size );

        template< class T > bool
        send( NodePtr node, ObjectPacket& packet, const std::vector<T>& v );

        virtual void notifyAttach() {}

        virtual void notifyAttached() {}

        CO_API virtual void notifyDetach();

        virtual void notifyDetached() {}

        uint32_t getMasterInstanceID() const;

        NodePtr getMasterNode();

        void addSlave( Command& command );
        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 UUID& id, 
                                    const uint32_t instanceID );
        CO_API virtual void detach();

        void transfer( Object* from );

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


    protected:
        CO_API Object( const Object& );

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

    private:
        friend class DeltaMasterCM;
        friend class FullMasterCM;
        friend class VersionedMasterCM;
        friend class ObjectCM;
        friend class StaticMasterCM;
        friend class StaticSlaveCM;
        friend class UnbufferedMasterCM;
        friend class VersionedSlaveCM;

        UUID _id;

        LocalNodePtr _localNode;

        uint32_t _instanceID;

        ObjectCM* _cm;

        void _setChangeManager( ObjectCM* cm );

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

    template< class T > inline bool
    Object::send( NodePtr node, ObjectPacket& packet, const std::vector<T>& v )
    {
        LBASSERT( isAttached() );
        packet.objectID  = _id;
        return node->send( packet, v );
    }
}

#endif // CO_OBJECT_H