PropertyObject.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/Property.h"
#include "Honey/Memory/SmallAllocator.h"

namespace honey
{

struct PropertyError : Exception                                        { EXCEPTION(PropertyError) };

namespace property { namespace priv
{
    template<class T> static Property<T>& create(const String& name)    { return *new Property<T>(name); }
} }
class PropertyObject : public Object
{
public:
    typedef stdutil::unordered_map<Id, PropertyBase::Ptr, SmallAllocator> PropertyMap;
    typedef stdutil::unordered_map<Id, PropertyBase::ConstPtr, SmallAllocator> PropertyMapConst;
    
    PropertyObject() {}

    virtual ~PropertyObject() {}


    void addProp(PropertyBase& prop)
    {
        assert(prop.id() != idnull, "Property must have valid id");
        PropertyBase::Ptr ptr = &prop;
        auto res = _propMap.insert(make_pair(prop.id(), ptr));
        if (res.second) return;
        res.first->second = ptr;
    }

    void addProp(PropertyBase* prop)                                    { assert(prop); addProp(*prop); }

    bool hasProp(const Id& id) const                                    { return _propMap.find(id) != _propMap.end(); }

    template<class T>
    bool hasProp(const Id& id) const
    {
        auto it = _propMap.find(id);
        return it != _propMap.end() && it->second->type() == Property<T>::s_type();
    }

    template<class T>
    Property<T>& prop(const String& name)
    {
        Id id = name;
        PropertyBase* prop;
        auto it = _propMap.find(id);
        if (it != _propMap.end())
            prop = it->second;
        else
        {
            //Property doesn't exist, add it
            prop = &property::priv::create<T>(name);
            addProp(*prop);
        }
        assert(prop->type() == Property<T>::s_type(),
                    sout()  << "Component type mismatch: "
                            << "Request: " << Property<T>::s_type() << " ; Id: " << id
                            << " ; Found: " << prop->type());
        return static_cast<Property<T>&>(*prop);
    }
    
    template<class T>
    Property<T>& prop(const Id& id)                                     { return prop_<T>(id); }
    template<class T>
    const Property<T>& prop(const Id& id) const                         { return prop_<T>(id); }
    
    PropertyBase& prop(const Id& id)                                    { return prop_(id); }
    const PropertyBase& prop(const Id& id) const                        { return prop_(id); }
    
    template<class T, class T_ = typename mt::removeRef<T>::type>
    Property<T_>& prop(const String& name, T&& val)                     { return prop<T_>(name) = forward<T>(val); }
    template<class T, class T_ = typename mt::removeRef<T>::type>
    Property<T_>& prop(const Id& id, T&& val)                           { return prop<T_>(id) = forward<T>(val); }
    
    const PropertyMap& props()                                          { return _propMap; }
    const PropertyMapConst& props() const                               { return reinterpret_cast<const PropertyMapConst&>(_propMap); }
        
    PropertyBase::Ptr removeProp(PropertyBase& prop)                    { return removeProp(prop.id()); }

    PropertyBase::Ptr removeProp(const Id& id)
    {
        auto it = _propMap.find(id);
        return it != _propMap.end() ? removeProp(it) : nullptr;
    }

    void removeProps(const function<void (PropertyBase&)>& f = [](PropertyBase&){})
    {
        while (!_propMap.empty()) { f(*removeProp(_propMap.begin())); }
    }

private:
    template<class T>
    Property<T>& prop_(const Id& id) const
    {
        auto it = _propMap.find(id);
        if (it == _propMap.end()) throw_ PropertyError() << "Property not found. Id: " << id;
        PropertyBase* prop = it->second;
        assert(prop->type() == Property<T>::s_type(),
                    sout()  << "Component type mismatch: "
                            << "Request: " << Property<T>::s_type() << " ; Id: " << id
                            << " ; Found: " << prop->type());
        return static_cast<Property<T>&>(*prop);
    }
    
    PropertyBase& prop_(const Id& id) const
    {
        auto it = _propMap.find(id);
        if (it == _propMap.end()) throw_ PropertyError() << "Property not found. Id: " << id;
        return *it->second;
    }
    
    PropertyBase::Ptr removeProp(PropertyMap::iterator it)
    {
        PropertyBase::Ptr prop = it->second;
        _propMap.erase(it);
        return prop;
    }

    PropertyMap _propMap;
};


}