Forge.hpp

/*
 * Copyright (C) 2020 Alexander Kornilov (akornilov.82@gmail.com)
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
#ifndef CPP_MATE_FORGE_HPP
#define CPP_MATE_FORGE_HPP
 
#include <CppMate/Checkers.hpp>
 
#include <string>
#include <utility>
#include <memory>
#include <vector>
#include <map>
#include <stdexcept>
 
namespace CppMate {
namespace Forge {
 
template<typename T, typename I, typename P>
class Factory
{
public:
 
    Factory(const Factory& other) = delete;
 
    Factory(Factory&& other) = default;
 
    Factory& operator=(const Factory& other) = delete;
 
    Factory& operator=(Factory&& other) = default;
 
    template<typename... A>
    std::unique_ptr<T> createInstance(const std::string& name, A&&... args) const {
        return getProvider(name).getInstance(std::forward<A>(args)...);
    }
 
    template<typename... A>
    std::unique_ptr<T> requestInstance(A&&... args) const {
        for (const auto& pair: _providers) {
            try {
                return pair.second->getInstance(std::forward<A>(args)...);
            } catch(const std::invalid_argument&) {
                // Ignore, try next provider
            }
        }
        throw std::invalid_argument("Appropriate provider not found");
    }
 
    std::vector<std::string> getProviders() const {
        std::vector<std::string> names;
        for (const auto& pair: _providers) {
            names.push_back(pair.first);
        }
        return names;
    }
 
    I getInfo(const std::string& name) const {
        return getProvider(name).getInfo();
    }
 
    void registerProvider(std::unique_ptr<P> provider, bool override = false) {
        checkArg(provider.get());
        const auto& name = provider->getInfo().getName();
        if (!override) {
            checkArg(_providers.find(name) == std::end(_providers));
        }
        _providers[name] = std::move(provider);
    }
 
    bool deregisterProvider(const std::string& name) {
        return _providers.erase(name) > 0;
    }
 
protected:
 
    Factory() = default;
 
    virtual ~Factory() = default;
 
    P& getProvider(const std::string& name) const {
        auto it = _providers.find(name);
        checkArg(it != std::end(_providers));
        return *it->second;
    }
 
    std::map<std::string, std::unique_ptr<P> > _providers;
};
 
class Info
{
public:
 
    explicit Info(const std::string& name): _name(name) {}
 
    virtual ~Info() = default;
 
    virtual std::string getName() const {
        return _name;
    }
 
protected:
 
    std::string _name;
};
 
template <typename T>
class Provider
{
public:
 
    explicit Provider(const T& info): _info(info) {}
 
    virtual ~Provider() = default;
 
    virtual T getInfo() const {
        return _info;
    }
 
protected:
 
    T _info;
};
 
} // namespace Forge
} // namespace CppMate
 
#endif // CPP_MATE_FORGE_HPP