ComObject.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/Component.h"

namespace honey
{



class ComObject : public Object
{
    friend class Component;

    struct Slot
    {
        Slot()                  : type(nullptr) {}
        typedef stdutil::unordered_map<Id, Component*, SmallAllocator> Map;
        typedef vector<Component::Ptr> List;
        Map map;                
        List list;              
        const ComRegistry::Type* type;
    };
    typedef stdutil::unordered_map<Id, Slot, SmallAllocator> SlotMap;

public:
    SIGNAL_DECL(ComObject)
    SIGNAL(sigComInsert, (ComObject& src, Component& com));
    SIGNAL(sigComRemove, (ComObject& src, Component& com));
    SIGNAL(sigSetInstId, (ComObject& src, Id id));

    virtual ~ComObject()                                        { removeComs(); }

    virtual void setInstId(const Id& id)
    {
        listeners().dispatch<sigSetInstId>(*this, id);
        Object::setInstId(id);
    }


    void addCom(Component& com, bool createDeps = false)        { insertCom_priv(com, -1, createDeps); }

    void addCom(Component* com, bool createDeps = false)        { assert(com); addCom(*com, createDeps); }


    void insertCom(Component& com, szt index, bool createDeps = false)
                                                                { insertCom_priv(com, index, createDeps); }

    template<class Com>
    bool hasCom(const Id& id = idnull) const                    { return hasComInSlot(Com::s_comType(), id); }

    bool hasComInSlot(const Id& type, const Id& id = idnull) const
    {
        auto slot = this->slot(type);
        if (!slot) return false;
        if (id != idnull)
        {
            auto it = slot->map.find(id);
            return it != slot->map.end();
        }
        return slot->list.size();
    }

    template<class Com>
    szt comCount() const                                        { return comCountInSlot(Com::s_comType()); }

    szt comCountInSlot(const Id& type) const
    {
        auto slot = this->slot(type);
        return slot ? slot->list.size() : 0;
    }

    auto comSlots() const -> decltype(keys(declval<const SlotMap>()))
                                                                { return keys(_slotMap); } 

    template<class Com>
    Com& com() const
    {
        auto slot = this->slot(Com::s_comType());
        assert(slot && slot->list.size(), sout() << "Component type not found: Request type: " << Com::s_comType());
        return static_cast<Com&>(*slot->list[0]);
    }

    template<class Com>
    Com& com(const Id& id) const                                { return static_cast<Com&>(comInSlot(Com::s_comType(), id)); }

    Component& comInSlot(const Id& type, const Id& id = idnull) const
    {
        Component* com = nullptr;
        auto slot = this->slot(type);
        if (slot)
        {
            if (id != idnull)
            {
                auto it = slot->map.find(id);
                com = it != slot->map.end() ? it->second : nullptr;
            }
            else
                com = slot->list[0];
        }
        assert(com, sout() << "Component type not found: Request type: " << type << " ; Id : " << id);
        return *com;
    }

    template<class Com>
    const vector<typename Com::Ptr>& coms() const               { return reinterpret_cast<const vector<typename Com::Ptr>&>(comsInSlot(Com::s_comType())); }

    const vector<Component::Ptr>& comsInSlot(const Id& type) const
    {
        auto slot = this->slot(type);
        return slot ? slot->list : _nullComs;
    }


    void removeCom(Component& com, bool removeDeps = false)
    {
        auto slotIt = _slotMap.find(com.comType());
        if (slotIt == _slotMap.end()) return;
        auto& slot = slotIt->second;
        auto it = std::find(slot.list.begin(), slot.list.end(), &com);
        if (it != slot.list.end()) removeComInSlot(slotIt, it, removeDeps);
    }

    template<class Com>
    void removeCom(const Id& id = idnull, bool removeDeps = false)
    {
        if (!hasCom<Com>(id)) return;
        removeCom(com<Com>(id), removeDeps);
    }

    template<class Com>
    void removeComAtIndex(szt index, bool removeDeps = false)   { removeComInSlot(Com::s_comType(), index, removeDeps); }

    void removeComInSlot(const Id& type, szt index, bool removeDeps = false)
    {
        auto slotIt = _slotMap.find(type);
        assert(slotIt != _slotMap.end() && index < slotIt->second.list.size());
        removeComInSlot(slotIt, slotIt->second.list.begin() + index, removeDeps);
    }

    template<class Com>
    void removeComs(bool removeDeps = false)                    { removeComsInSlot(Com::s_comType(), removeDeps); }
    void removeComs();
    void removeComsInSlot(const Id& type, bool removeDeps = false)
    {
        auto slotIt = _slotMap.find(type);
        if (slotIt == _slotMap.end()) return;
        removeComsInSlot(slotIt, removeDeps);
    }

    ListenerList& listeners()                                   { return _listeners; }

private:
    struct slotDepOrderCmp { bool operator() (const ComRegistry::Type* type, const ComRegistry::Type* type2) const { return type->depOrder() < type2->depOrder(); } };
    typedef multiset<const ComRegistry::Type*, slotDepOrderCmp, SmallAllocator<const ComRegistry::Type*>> SlotDepOrder;
    
    const Slot* slot(const Id& type) const                      { auto it = _slotMap.find(type); return it != _slotMap.end() ? &it->second : nullptr; }
    Slot* slot(const Id& type)                                  { auto it = _slotMap.find(type); return it != _slotMap.end() ? &it->second : nullptr; }

    void insertCom_priv(Component& com, sdt index, bool createDeps);
    void removeComInSlot(SlotMap::iterator slotIt, Slot::List::iterator it, bool removeDeps);
    void removeComsInSlot(SlotMap::iterator slotIt, bool removeDeps);

    void updateComMap(Component& com, const Id& id);

    SlotMap _slotMap;
    SlotDepOrder _slotDepOrder;
    ListenerList _listeners;

    static const vector<Component::Ptr> _nullComs;
};


}