factory.h

Go to the documentation of this file.

/*********************************************************************
 *
 *  Software License Agreement
 *
 *  Copyright (c) 2020,
 *  TU Dortmund - Institute of Control Theory and Systems Engineering.
 *  All rights reserved.
 *
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
 *
 *  Authors: Christoph Rösmann
 *********************************************************************/

#ifndef SRC_CORE_INCLUDE_CORBO_CORE_FACTORY_H_
#define SRC_CORE_INCLUDE_CORBO_CORE_FACTORY_H_

#include <corbo-core/console.h>
#include <corbo-core/macros.h>
#include <functional>
#include <memory>
#include <string>
#include <type_traits>
#include <unordered_map>

namespace corbo {

template <typename Base>
class Factory
{
 public:
    static Factory& instance()
    {
        static Factory factory;
        return factory;
    }

    bool hasObject(const std::string& name) { return _object_map.count(name) > 0; }

    template <typename Derived = Base>
    std::shared_ptr<Derived> create(const std::string& name, bool print_error = true) const
    {
        static_assert(std::is_base_of<Base, Derived>::value, "Factory::create(): specified dervied class type is an actual subclass of base.");

        auto obj = _object_map.find(name);
        if (obj == _object_map.end())
        {
            PRINT_ERROR_COND(print_error, "Factory<" << typeid(Base).name() << ">::create():: unkown object '" << name << "'.");
            return std::shared_ptr<Derived>();
        }

        std::shared_ptr<Derived> derived_ptr = std::dynamic_pointer_cast<Derived>(obj->second->getInstance());
        PRINT_ERROR_COND(!derived_ptr && print_error, "Factory::create():: cannot cast base object " << typeid(Base).name() << " to derived object "
                                                                                                     << typeid(Derived).name() << ".");
        return derived_ptr;
    }

    bool registerObject(const std::string& name, std::shared_ptr<Base> object_type)
    {
        _object_map[name] = object_type;
        return true;
    }

    void printObjects() const
    {
        for (auto it = _object_map.begin(); it != _object_map.end(); ++it) PRINT_INFO("* " << it->first);
    }
    
    const std::unordered_map<std::string, std::shared_ptr<Base>>& getObjectMap() const { return _object_map; }

 private:
    std::unordered_map<std::string, std::shared_ptr<Base>> _object_map;
};

#define FACTORY_REGISTER_OBJECT_ID(type, base, id)               \
    static const bool corbo_CAT(corbo_CAT(type, __regged), id) = \
        Factory<base>::instance().registerObject(corbo_STRINGIZE(type), std::make_shared<type>());

#define FACTORY_REGISTER_OBJECT(type, base) FACTORY_REGISTER_OBJECT_ID(type, base, 0)

template <typename Object>
std::shared_ptr<Object> create_from_factory(const std::string& name)
{
    return Object::getFactory().template create<Object>(name);
}

}  // namespace corbo

#endif  // SRC_CORE_INCLUDE_CORBO_CORE_FACTORY_H_