Component.h

Go to the documentation of this file.

// Honeycomb, Copyright (C) 2015 NewGamePlus Inc.  Distributed under the Boost Software License v1.0.
#pragma once

#include "Honey/Object/Object.h"
#include "Honey/Object/ListenerList.h"
#include "Honey/Graph/Tree.h"
#include "Honey/Graph/Dep.h"

namespace honey
{



#define COMPONENT(...)                          EVAL(TOKCAT(COMPONENT_, NUMARGS(__VA_ARGS__))(__VA_ARGS__))

#define COMPONENT_1(Class)                      COMPONENT_2(Class, #Class)
#define COMPONENT_2(Class, typeId)              COMPONENT_SUB(, Class, typeId)

#define COMPONENT_SUB(...)                      EVAL(TOKCAT(COMPONENT_SUB_, NUMARGS(__VA_ARGS__))(__VA_ARGS__))
#define COMPONENT_SUB_2(SuperCom, Class)        COMPONENT_SUB_3(SuperCom, Class, #Class)
#define COMPONENT_SUB_3(SuperCom, Class, typeId)                                                                    \
    friend class ComRegistry;                                                                                       \
                                                                                                                    \
    typedef SharedPtr<Class> Ptr;                                                                                   \
    typedef SharedPtr<const Class> ConstPtr;                                                                        \
                                                                                                                    \
                                                                              \
    static ComRegistry::Type& s_comType()                                                                           \
    {                                                                                                               \
        mt_unused(__comReg_t); /* reference register var so it can't be compiled out */                             \
        static ComRegistry::Type obj(                                                                               \
            ComRegistry::Type(  typeId, mt::identity<Class>()                                                       \
                                IFEMPTY(, COMMA mt::identity<SuperCom>(), SuperCom)));                              \
        return obj;                                                                                                 \
    }                                                                                                               \
                                                                                                                    \
                                                                                  \
    virtual const ComRegistry::Type& comType() const        { return s_comType(); }                                 \
                                                                                                                    \
                                                                                       \
    static mt::Void __comReg()                                                                                      \
    {                                                                                                               \
        static bool init = false; if (init) return mt::Void(); init = true;                                         \
        ComRegistry::inst().reg<Class>();                                                                           \
        return mt::Void();                                                                                          \
    }                                                                                                               \
    static mt::Void __comReg_t; /* for templated component reg */                                                   \
    

#define COMPONENT_REG(Class)                    static mt::Void TOKCAT(__comReg_,__COUNTER__)(UNBRACKET(Class)::__comReg());
#define COMPONENT_REG_T(Template, Class)        UNBRACKET(Template) mt::Void UNBRACKET(Class)::__comReg_t(__comReg());

class Component;

namespace component
{ 
    template<class Com>
    typename std::enable_if<std::is_default_constructible<Com>::value && !std::is_abstract<Com>::value, Component&>::type
        create() { return *new Com; }
    template<class Com>
    typename mt::disable_if<std::is_default_constructible<Com>::value && !std::is_abstract<Com>::value, Component&>::type
        create() { error_("ComRegistry can't create non-default-constructible components. Must specialize component::create()."); return *static_cast<Component*>(nullptr); }
}

class ComRegistry
{
    friend class ComObject;
public:
    class Type : public NameId
    {
        friend class ComRegistry;
    public:
        template<class Com>
        Type(const String& name, mt::identity<Com>) :
            NameId(name),
            _node(this), _create(&component::create<Com>),
            _depNode(this, *this), _depCreate(&Com::createTypeDep), _depOrder(-1)  {}

        template<class Com, class SuperCom>
        Type(const String& name, mt::identity<Com> com, mt::identity<SuperCom>) :
            Type(name, com)                                 { _node.setParent(&SuperCom::s_comType()._node); }

        const vector<Type*>& hierarchy() const              { return _hierarchy; }
        int depOrder() const                                { return _depOrder; }

        bool isSubtypeOf(const Id& base) const
        {
            //For an early out, start at deepest subtype
            auto range = reversed(_hierarchy);
            return find(range, [&](auto& e) { return *e == base; }) != range.end();
        }

    private:
        typedef DepNode<Type*> DepNode;

        TreeNode<Type*> _node;
        vector<Type*> _hierarchy;
        function<Component& ()> _create;
        DepNode _depNode;
        function<DepNode ()> _depCreate;
        int _depOrder;
    };
    typedef Type::DepNode DepNode;
    typedef DepGraph<DepNode> DepGraph;

    static mt_global(ComRegistry, inst,);

    template<class Com>
    void reg()
    {
        Type& type = Com::s_comType();
        if (_types.find(type) != _types.end()) return; //Already registered
        _types[type] = &type;
        //build hierarchy
        for (auto* parent = &type._node; parent; parent = parent->getParent())
            type._hierarchy.insert(type._hierarchy.begin(), **parent);
    }

    Component& create(const Id& type) const
    {
        auto it = _types.find(type);
        assert(it != _types.end(), sout() << "Component type not registered: " << type);
        return it->second->_create();
    }

    Type& type(const Id& id) const
    {
        auto it = _types.find(id);
        assert(it != _types.end(), sout() << "Component type not registered: " << id);
        return *it->second;
    }

    const DepGraph& depGraph() const                        { return _depGraph; }

private:
    mt::Void buildDepGraph();

    unordered_map<Id, Type*> _types;
    DepGraph _depGraph;
};

class ComObject;

class Component : public Object
{
    friend class ComRegistry;
    friend class ComObject;
public:
    typedef SharedPtr<Component> Ptr;
    typedef SharedPtr<const Component> ConstPtr;

    Component()                                             : _comObj(nullptr) {}
    virtual ~Component() {}

    virtual const ComRegistry::Type& comType() const = 0;

    virtual void setInstId(const Id& id);

    ComObject& obj() const                                  { assert(hasObj()); return *_comObj; }
    bool hasObj() const                                     { return _comObj; }

    ListenerList& listeners()                               { return _listeners; }

protected:
    static ComRegistry::DepNode createTypeDep()             { return ComRegistry::DepNode(); }

    virtual void onComInsert() {}
    virtual void onComRemove() {}

private:
    ComObject* _comObj;
    ListenerList _listeners;
};


}