eq/fabric/object.h

/* Copyright (c) 2009-2011, 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 EQFABRIC_OBJECT_H
#define EQFABRIC_OBJECT_H

#include <eq/fabric/api.h>
#include <eq/fabric/error.h>        // enum
#include <eq/fabric/serializable.h> // base class
#include <co/objectVersion.h>       // member

namespace eq
{
namespace fabric
{
    class Object : public Serializable
    {
    public:
        EQFABRIC_API void setName( const std::string& name );

        EQFABRIC_API const std::string& getName() const;

        EQFABRIC_API void setUserData( co::Object* userData );

        co::Object* getUserData() { return _userData; }

        const co::Object* getUserData() const { return _userData; }

        EQFABRIC_API void setError( const int32_t error );

        co::base::Error getError() const { return _error; }

        uint32_t getTasks() const { return _tasks; }

        uint32_t getSerial() const { return _serial; } 


        EQFABRIC_API virtual bool isDirty() const;

        EQFABRIC_API virtual uint32_t commitNB( const uint32_t incarnation );

        EQFABRIC_API virtual void backup();

        EQFABRIC_API virtual void restore();

        enum DirtyBits
        {
            DIRTY_NAME       = Serializable::DIRTY_CUSTOM << 0, // 1
            DIRTY_USERDATA   = Serializable::DIRTY_CUSTOM << 1, // 2
            DIRTY_ERROR      = Serializable::DIRTY_CUSTOM << 2, // 4
            DIRTY_TASKS      = Serializable::DIRTY_CUSTOM << 3, // 8
            DIRTY_REMOVED    = Serializable::DIRTY_CUSTOM << 4, // 16
            DIRTY_SERIAL     = Serializable::DIRTY_CUSTOM << 5, // 32
            // Leave room for binary-compatible patches
            DIRTY_CUSTOM     = Serializable::DIRTY_CUSTOM << 6, // 64
            DIRTY_OBJECT_BITS = DIRTY_NAME | DIRTY_USERDATA | DIRTY_ERROR
        };

    protected:
        EQFABRIC_API Object();
        
        EQFABRIC_API virtual ~Object();

        virtual bool hasMasterUserData() { return false; }

        virtual uint32_t getUserDataLatency() const { return 0; }

        EQFABRIC_API void setTasks( const uint32_t tasks );

        EQFABRIC_API virtual void notifyDetach();

        EQFABRIC_API virtual void serialize( co::DataOStream& os,
                                          const uint64_t dirtyBits );
        EQFABRIC_API virtual void deserialize( co::DataIStream& is,
                                            const uint64_t dirtyBits );

        virtual uint64_t getRedistributableBits() const
            { return DIRTY_OBJECT_BITS; }

        EQFABRIC_API void postRemove( const Object* child );

        virtual void removeChild( const co::base::UUID& ) { EQUNIMPLEMENTED; }

        template< class C, class PKG, class S >
        void commitChild( C* child, S* sender, const uint32_t incarnation );

        template< class C > inline 
        void commitChild( C* child, const uint32_t incarnation )
            {
                EQASSERT( child->isAttached( ));
                child->commit( incarnation );
            }

        template< class C, class PKG, class S >
        void commitChildren( const std::vector< C* >& children, S* sender,
                             const uint32_t incarnation );

        template< class C, class PKG >
        void commitChildren( const std::vector< C* >& children,
                             const uint32_t incarnation )
            { commitChildren< C, PKG, Object >( children, this, incarnation ); }

        template< class C >
        void commitChildren( const std::vector< C* >& children,
                             const uint32_t incarnation );

        template< class C >
        void syncChildren( const std::vector< C* >& children );

        template< class P, class C >
        inline void releaseChildren( const std::vector< C* >& children );

        EQFABRIC_API bool _cmdSync( co::Command& command );

    private:
        struct BackupData
        {
            std::string name;

            co::ObjectVersion userData;
        }
            _data, _backup;

        co::Object* _userData;

        uint32_t _tasks;

        co::base::Error _error;

        uint32_t _serial;

        std::vector< co::base::UUID > _removedChildren;

        struct Private;
        Private* _private; // placeholder for binary-compatible changes
    };

    // Template Implementation
    template< class C, class PKG, class S > inline void
    Object::commitChild( C* child, S* sender, const uint32_t incarnation )
    {
        if( !child->isAttached( ))
        {
            EQASSERT( !isMaster( ));
            co::LocalNodePtr localNode = child->getConfig()->getLocalNode();
            PKG packet;
            packet.requestID = localNode->registerRequest();

            co::NodePtr node = child->getServer().get();
            sender->send( node, packet );

            uint128_t identifier;
            localNode->waitRequest( packet.requestID, identifier );
            EQCHECK( localNode->mapObject( child,identifier,co::VERSION_NONE ));
        }
        child->commit( incarnation );
    }

    template< class C, class PKG, class S > inline void
    Object::commitChildren( const std::vector< C* >& children, S* sender,
                            const uint32_t incarnation )
    {
        // TODO Opt: async register and commit
        for( typename std::vector< C* >::const_iterator i = children.begin();
             i != children.end(); ++i )
        {
            C* child = *i;
            commitChild< C, PKG, S >( child, sender, incarnation );
        }
    }

    template< class C >
    inline void Object::commitChildren( const std::vector< C* >& children,
                                        const uint32_t incarnation )
    {
        // TODO Opt: async commit
        for( typename std::vector< C* >::const_iterator i = children.begin();
             i != children.end(); ++i )
        {
            C* child = *i;
            EQASSERT( child->isAttached( ));
            child->commit( incarnation );
        }
    }

    template< class C >
    inline void Object::syncChildren( const std::vector< C* >& children )
    {
        for( typename std::vector< C* >::const_iterator i = children.begin();
             i != children.end(); ++i )
        {
            C* child = *i;
            EQASSERT( child->isMaster( )); // slaves are synced using version
            child->sync();
        }
    }
 
    template< class P, class C >
    inline void Object::releaseChildren( const std::vector< C* >& children )
    {
        while( !children.empty( ))
        {
            C* child = children.back();
            if( !child->isAttached( ))
            {
                EQASSERT( isMaster( ));
                return;
            }

            getLocalNode()->releaseObject( child );
            if( !isMaster( ))
            {
                static_cast< P* >( this )->_removeChild( child );
                static_cast< P* >( this )->release( child );
            }
        }
    }
}
}
#endif // EQFABRIC_OBJECT_H