PluginFactory.hpp

Go to the documentation of this file.

/*
 * Copyright (c) 2015 - 2024 Intel Corporation
 * SPDX-License-Identifier: BSD-3-Clause
 */
 
#ifndef PLUGINFACTORY_HPP_INCLUDE
#define PLUGINFACTORY_HPP_INCLUDE
 
#include <functional>
#include <map>
#include <memory>
#include <string>
#include <vector>
 
#include "geopm_public.h"
 
#include "Exception.hpp"
 
namespace geopm
{
    template<class T> class PluginFactory
    {
        public:
            PluginFactory() = default;
            virtual ~PluginFactory() = default;
            PluginFactory(const PluginFactory &other) = delete;
            PluginFactory &operator=(const PluginFactory &other) = delete;
            void register_plugin(const std::string &plugin_name,
                                 std::function<std::unique_ptr<T>()> make_plugin,
                                 const std::map<std::string, std::string> &dictionary = m_empty_dictionary)
            {
                auto result = m_name_func_map.emplace(plugin_name, make_plugin);
                if (!result.second) {
                    throw Exception("PluginFactory::register_plugin(): name: \"" +
                                    plugin_name + "\" has been previously registered",
                                    GEOPM_ERROR_INVALID, __FILE__, __LINE__);
                }
                m_dictionary.emplace(plugin_name, dictionary);
                m_plugin_names.push_back(plugin_name);
            }
            std::unique_ptr<T> make_plugin(const std::string &plugin_name) const
            {
                auto it = m_name_func_map.find(plugin_name);
                if (it == m_name_func_map.end()) {
                    throw Exception("PluginFactory::make_plugin(): name: \"" +
                                    plugin_name + "\" has not been previously registered",
                                    GEOPM_ERROR_INVALID, __FILE__, __LINE__);
                }
                return it->second();
            }
            std::vector<std::string> plugin_names(void) const
            {
                return m_plugin_names;
            }
            const std::map<std::string, std::string> &dictionary(const std::string &plugin_name) const
            {
                auto it = m_dictionary.find(plugin_name);
                if (it == m_dictionary.end()) {
                    throw Exception("PluginFactory::dictionary(): Plugin named \"" + plugin_name +
                                    "\" has not been registered with the factory.",
                                    GEOPM_ERROR_INVALID, __FILE__, __LINE__);
                }
                return it->second;
            }
        private:
            std::map<std::string, std::function<std::unique_ptr<T>()> > m_name_func_map;
            std::vector<std::string> m_plugin_names;
            std::map<std::string, const std::map<std::string, std::string> > m_dictionary;
            static const std::map<std::string, std::string> m_empty_dictionary;
    };
 
    template <class Type>
    const std::map<std::string, std::string> PluginFactory<Type>::m_empty_dictionary = {};
 
}
#endif