object.h

/* Copyright (c) 2009-2016, Stefan Eilemann <eile@equalizergraphics.com>
 *                          Daniel Nachbaur <danielnachbaur@gmail.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/types.h>
#include <co/objectOCommand.h>      // used inline send()
#include <co/objectVersion.h>       // member
#include <co/serializable.h>        // base class

namespace eq
{
namespace fabric
{
namespace detail { class Object; }

class Object : public co::Serializable
{
public:
    EQFABRIC_API virtual void setName( const std::string& name );

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

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

    EQFABRIC_API co::Object* getUserData();

    EQFABRIC_API const co::Object* getUserData() const;

    EQFABRIC_API uint32_t getTasks() const;

    EQFABRIC_API uint32_t getSerial() const; 


    EQFABRIC_API bool isDirty() const override;

    EQFABRIC_API uint128_t commit( const uint32_t incarnation =
                                   CO_COMMIT_NEXT ) override;

    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_TASKS      = Serializable::DIRTY_CUSTOM << 2, // 4
        DIRTY_REMOVED    = Serializable::DIRTY_CUSTOM << 3, // 8
        DIRTY_SERIAL     = Serializable::DIRTY_CUSTOM << 4, // 16
        // Leave room for binary-compatible patches
        DIRTY_CUSTOM     = Serializable::DIRTY_CUSTOM << 6, // 64
        DIRTY_OBJECT_BITS = DIRTY_NAME | DIRTY_USERDATA
    };

protected:
    EQFABRIC_API Object();

    EQFABRIC_API Object( const Object& );

    EQFABRIC_API virtual ~Object();

    EQFABRIC_API Object& operator = ( const Object& from );

    virtual bool hasMasterUserData() { return false; }

    virtual uint32_t getUserDataLatency() const { return 0; }

    EQFABRIC_API void setTasks( const uint32_t tasks );

    EQFABRIC_API void notifyDetach() override;

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

    virtual uint64_t getRedistributableBits() const
        { return DIRTY_OBJECT_BITS; }

    EQFABRIC_API void postRemove( Object* child );

    virtual void removeChild( const uint128_t& ) { LBUNIMPLEMENTED; }

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

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

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

    template< class C >
    void commitChildren( const std::vector< C* >& children, uint32_t cmd,
                         const uint32_t incarnation )
        { commitChildren< C, Object >( children, this, cmd, 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::ICommand& command );

    EQFABRIC_API void updateEvent( Event& event, int64_t time ); 

private:
    detail::Object* const _impl;
};

// Template Implementation
template< class C, class S > inline void
Object::commitChild( C* child, S* sender, uint32_t cmd,
                     const uint32_t incarnation )
{
    if( !child->isAttached( ))
    {
        LBASSERT( !isMaster( ));
        co::LocalNodePtr localNode = child->getConfig()->getLocalNode();
        lunchbox::Request< uint128_t > request =
            localNode->registerRequest< uint128_t >();
        co::NodePtr node = child->getServer().get();
        sender->send( node, cmd ) << request;

        LBCHECK( localNode->mapObject( child, request.wait(),
                                       co::VERSION_NONE ));
    }
    child->commit( incarnation );
}

template< class C, class S > inline void
Object::commitChildren( const std::vector< C* >& children, S* sender,
                        uint32_t cmd, 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, S >( child, sender, cmd, 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;
        LBASSERT( 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;
        LBASSERT( child->isMaster( )); // slaves are synced using version
        child->sync();
    }
}

template< class P, class C >
inline void Object::releaseChildren( const std::vector< C* >& children )
{
    for( size_t i = children.size(); i > 0; --i )
    {
        C* child = children[ i - 1 ];

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