group.h

/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
#pragma once
 
// Local Includes
#include "resource.h"
#include "resourceptr.h"
#include "rtti/objectptr.h"
#include "resource.h"
 
namespace nap
{
    namespace group
    {
        constexpr const char* members  = "Members";                     
        constexpr const char* children = "Children";                    
    }
 
 
    // Group Interface
 
    class NAPAPI IGroup : public Resource
    {
        RTTI_ENABLE(Resource)
    public:
        IGroup(rtti::TypeInfo memberType, std::string&& membersName, std::string&& childrenName) :
            mMemberType(memberType),
            mMembersPropertyName(std::move(membersName)),
            mChildrenPropertyName(std::move(childrenName))              { }
 
        rtti::TypeInfo getMemberType() const                            { return mMemberType; }
 
        rttr::property getMembersProperty() const;
 
        rttr::property getChildrenProperty() const;
 
        const std::string& membersPropertyName() const                  { return mMembersPropertyName; }
 
        const std::string& childrenPropertyName() const                 { return mChildrenPropertyName; }
 
    private:
        rtti::TypeInfo mMemberType;
        std::string mMembersPropertyName;
        std::string mChildrenPropertyName;
    };
 
 
    // Group
 
    template<typename T>
    class Group : public IGroup
    {
        RTTI_ENABLE(IGroup)
    public:
        Group() : IGroup(RTTI_OF(T), group::members, group::children) { }
 
        virtual bool init(utility::ErrorState& errorState) override;
 
        rtti::ObjectPtr<T> findObject(const std::string& id) const;
 
        rtti::ObjectPtr<T> findObjectRecursive(const std::string& id) const;
 
        template<typename M>
        rtti::ObjectPtr<M> findObject(const std::string& id) const;
 
        template<typename M>
        rtti::ObjectPtr<M> findObjectRecursive(const std::string& id) const;
 
        std::vector<rtti::ObjectPtr<T>> mMembers;                   
        std::vector<rtti::ObjectPtr<Group<T>>> mChildren;           
 
    private:
        std::unordered_map<std::string, T*> mMap;                   
    };
 
 
    // Group Definitions
 
    // Default NAP (resource) group.
    using ResourceGroup = Group<Resource>;
 
 
    // Template Definitions
 
    template<typename T>
    bool nap::Group<T>::init(utility::ErrorState& errorState)
    {
        mMap.reserve(mMembers.size());
        for (const auto& member : mMembers)
        {
            mMap.emplace(std::make_pair(member->mID, member.get()));
        }
        return true;
    }
 
    template<typename T>
    rtti::ObjectPtr<T> nap::Group<T>::findObject(const std::string& id) const
    {
        // Find in this group
        auto it = mMap.find(id);
        if (it != mMap.end())
            return rtti::ObjectPtr<T>(it->second);
        return nullptr;
    }
 
    template<typename T>
    rtti::ObjectPtr<T> nap::Group<T>::findObjectRecursive(const std::string& id) const
    {
        // Find in this group
        rtti::ObjectPtr<T> object = findObject(id);
        if (object != nullptr)
            return object;
 
        // Find in sub-groups
        for (const auto& child : mChildren)
        {
            rtti::ObjectPtr<T> object = child->findObjectRecursive(id);
            if (object != nullptr)
                return object;
        }
        return nullptr;
    }
 
    template<typename T>
    template<typename M>
    rtti::ObjectPtr<M> nap::Group<T>::findObject(const std::string& id) const
    {
        return rtti::ObjectPtr<M>(findObject(id));
    }
 
    template<typename T>
    template<typename M>
    rtti::ObjectPtr<M> nap::Group<T>::findObjectRecursive(const std::string& id) const
    {
        return rtti::ObjectPtr<M>(findObjectRecursive(id));
    }
}
 
 
// Group registration
 
// Backwards compatible -> registration without description
#define DEFINE_GROUP_1(Type)                                                                                                                            \
    RTTI_BEGIN_CLASS(Type)                                                                                                                              \
        RTTI_PROPERTY(nap::group::members,  &Type::mMembers,    nap::rtti::EPropertyMetaData::Embedded | nap::rtti::EPropertyMetaData::ReadOnly)        \
        RTTI_PROPERTY(nap::group::children, &Type::mChildren,   nap::rtti::EPropertyMetaData::Embedded | nap::rtti::EPropertyMetaData::ReadOnly)        \
    RTTI_END_CLASS
 
// Group registration with description
#define DEFINE_GROUP_2(Type, ObjectType)                                                                                                                \
    RTTI_BEGIN_CLASS(Type, "Groups together a set of '"#ObjectType"' objects")                                                                          \
        RTTI_PROPERTY(nap::group::members,  &Type::mMembers,    nap::rtti::EPropertyMetaData::Embedded | nap::rtti::EPropertyMetaData::ReadOnly)        \
        RTTI_PROPERTY(nap::group::children, &Type::mChildren,   nap::rtti::EPropertyMetaData::Embedded | nap::rtti::EPropertyMetaData::ReadOnly)        \
    RTTI_END_CLASS
 
#define GET_DEFINE_GROUP_MACRO(_1,_2,NAME,...) NAME
 
#define DEFINE_GROUP(...) GET_DEFINE_GROUP_MACRO(__VA_ARGS__, DEFINE_GROUP_2, DEFINE_GROUP_1)(__VA_ARGS__)