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 <co/objectOCommand.h> // used inline send()
#include <co/objectVersion.h>  // member
#include <co/serializable.h>   // base class
#include <eq/fabric/api.h>
#include <eq/fabric/error.h> // enum
#include <eq/fabric/types.h>

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