wxcreator.h

Go to the documentation of this file.

 
#ifndef wxcreator_h
#define wxcreator_h
 
// WarpX includes
#include "wxexcept.h"
#include "wmopaqueptr.h"
 
// std includes
#include <iostream>
#include <unordered_map>
#include <stdexcept>
#include <string>
#include <vector>
#include <typeinfo>
#include <memory>
 
namespace wxm
{
namespace detail
{
class creator_base
{
public:
    std::string name_;
    const std::type_info* type_;
 
    creator_base(std::string name, const std::type_info* dtype)
        : name_(std::move(name)), type_(dtype)
    {
    }
 
    virtual ~creator_base() = default;
};
 
// TODO: do we actually need two different lists?
extern std::unordered_map<std::string, std::unique_ptr<creator_base>>&
creatorsForDefault();
 
extern std::unordered_map<std::string, std::unique_ptr<creator_base>>&
creatorsForChildren();
 
} // namespace detail
} // namespace wxm
 
template<class B> class WxCreatorBase;
template<class B> class WxCreatorForChildrenBase;
 
template<class B> class WxCreatorMapBase
{
public:
    static wxm::detail::creator_base& addCreator(const std::string& nm,
                                                 wxm::detail::creator_base* b)
    {
        auto v = wxm::detail::creatorsForDefault().emplace(
            nm, std::unique_ptr<wxm::detail::creator_base>(b));
        if (!v.second)
        {
            WxExcept wxe;
            wxe << "Duplicate Creator for class " << nm;
            throw wxe;
        }
        return *v.first->second;
    }
 
    static wxm::detail::creator_base& addCreatorForChildren(const std::string& nm,
                                                            wxm::detail::creator_base* b)
    {
        auto v = wxm::detail::creatorsForChildren().emplace(
            nm, std::unique_ptr<wxm::detail::creator_base>(b));
        if (!v.second)
        {
            WxExcept wxe;
            wxe << "Duplicate Creator for class " << nm;
            throw wxe;
        }
        return *v.first->second;
    }
 
    static void removeCreatorForDefault(const std::string& nm)
    {
        std::cout << "unregistering " << nm << std::endl;
        wxm::detail::creatorsForDefault().erase(nm);
    }
 
    static void removeCreatorForChild(const std::string& nm)
    {
        std::cout << "unregistering " << nm << std::endl;
        wxm::detail::creatorsForChildren().erase(nm);
    }
};
 
template<class B> class WxCreatorMap : public WxCreatorMapBase<B>
{
public:
    static B* getNew(const std::string& nm)
    {
        auto i = wxm::detail::creatorsForDefault().find(nm);
        if (i != wxm::detail::creatorsForDefault().end())
        {
            return reinterpret_cast<WxCreatorBase<B>*>(i->second.get())->getNew();
        }
 
        WxExcept wxe;
        wxe << "Creator for class " << nm << " not found";
        throw wxe;
    }
 
    static B* getNew(const std::string& nm, const WmConstOpaquePtr& parentPointer)
    {
        auto i = wxm::detail::creatorsForChildren().find(nm);
        if (i != wxm::detail::creatorsForChildren().end())
        {
            return reinterpret_cast<WxCreatorForChildrenBase<B>*>(i->second.get())
                ->getNew(parentPointer);
        }
 
        WxExcept wxe;
        wxe << "Creator for class " << nm << " not found";
        throw wxe;
    }
 
    static const std::string getRegisteredName(const std::type_info& type)
    {
 
        // check default constructor creators first
        for (auto& i : wxm::detail::creatorsForDefault())
        {
            if (*(i.second->type_) == type)
            {
                return i.first;
            }
        }
 
        // not found, so check 'ForChildren' constructor creators second
        for (auto& i : wxm::detail::creatorsForChildren())
        {
            if (*(i.second->type_) == type)
            {
                return i.first;
            }
        }
 
        std::string nomatch;
        return nomatch;
    }
};
template<class B> class WxCreatorBase : public wxm::detail::creator_base
{
public:
    WxCreatorBase(std::string nm, const std::type_info* dtype)
        : wxm::detail::creator_base(std::move(nm), dtype)
    {
    }
 
    virtual B* getNew() = 0;
};
 
template<class D, class B> class WxCreator : public WxCreatorBase<B>
{
public:
    WxCreator(std::string name) : WxCreatorBase<B>(std::move(name), &typeid(D))
    {
    }
 
    B* getNew()
    {
        D* d = new D;
        return static_cast<B*>(d);
    }
};
 
template<class B> class WxCreatorForChildrenBase : public wxm::detail::creator_base
{
public:
    WxCreatorForChildrenBase(std::string nm, const std::type_info* dtype)
        : wxm::detail::creator_base(std::move(nm), dtype)
    {
    }
 
    virtual B* getNew(const WmConstOpaquePtr& parentPointer) = 0;
};
 
template<class D, class B> class WxCreatorForChildren : public WxCreatorForChildrenBase<B>
{
public:
    WxCreatorForChildren(std::string name)
        : WxCreatorForChildrenBase<B>(std::move(name), &typeid(D))
    {
    }
 
    B* getNew(const WmConstOpaquePtr& parentPointer)
    {
        D* d = new D(parentPointer);
        return static_cast<B*>(d);
    }
};
 
#if defined(__GNUC__)
#define WXM_UNUSED __attribute__((unused))
#elif defined(_MSC_VER) && !defined(__clang__)
#define WXM_UNUSED
#else
#define WXM_UNUSED
#endif
 
// Check that __COUNTER__ is defined and that __COUNTER__ increases by 1
// every time it is expanded. X + 1 == X + 0 is used in case X is defined to be
// empty. If X is empty the expression becomes (+1 == +0).
#if defined(__COUNTER__) && (__COUNTER__ + 1 == __COUNTER__ + 0)
#define WXM_PRIVATE_UNIQUE_ID __COUNTER__
#else
#define WXM_PRIVATE_UNIQUE_ID __LINE__
#endif
 
// Helpers for generating unique variable names
#define WXM_PRIVATE_NAME(n) WXM_PRIVATE_CONCAT(wxm_creator_, WXM_PRIVATE_UNIQUE_ID, n)
#define WXM_PRIVATE_CONCAT(a, b, c) WXM_PRIVATE_CONCAT2(a, b, c)
#define WXM_PRIVATE_CONCAT2(a, b, c) a##b##c##_
 
#define REGISTER_CREATOR(name, specialization, base)                                     \
    namespace                                                                            \
    {                                                                                    \
    static auto& WXM_PRIVATE_NAME(registered) WXM_UNUSED =                               \
        (WxCreatorMapBase<base>::addCreator(name,                                        \
                                            new WxCreator<specialization, base>(name))); \
    }
 
#define REGISTER_CREATOR_FOR_CHILDREN(name, specialization, base)                        \
    namespace                                                                            \
    {                                                                                    \
    static auto& WXM_PRIVATE_NAME(registered)                                            \
        WXM_UNUSED = (WxCreatorMapBase<base>::addCreatorForChildren(                     \
            name,                                                                        \
            new WxCreatorForChildren<specialization, base>(name)));                      \
    }
 
#endif // wxcreator_h