object.h

/* Copyright (c) 2005-2017, 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

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&);
}

#endif // CO_OBJECT_H