factoryRegistry.hpp

Go to the documentation of this file.

 
#ifndef RTCTK_COMPONENTFRAMEWORK_FACTORYREGISTRY_HPP
#define RTCTK_COMPONENTFRAMEWORK_FACTORYREGISTRY_HPP
 
#include <memory>
#include <mutex>
#include <vector>
 
namespace rtctk::componentFramework {
 
template <class BaseIf>
class FactoryRegistry final {
public:
    using AdapterIdType = typename BaseIf::AdapterIdType;
 
    class FactoryIf {
    public:
        using AdapterIdType = typename BaseIf::AdapterIdType;
 
        FactoryIf() = default;
        virtual ~FactoryIf() = default;
 
        virtual bool CanHandle(const AdapterIdType& id) const = 0;
 
        virtual std::unique_ptr<BaseIf> CreateInstance(const AdapterIdType& id) const = 0;
 
    private:
        // Do not allow copying of this class.
        FactoryIf(const FactoryIf&) = delete;
        FactoryIf& operator=(const FactoryIf&) = delete;
        FactoryIf(FactoryIf&&) = delete;
        FactoryIf& operator=(FactoryIf&&) = delete;
    };
 
    FactoryRegistry() = default;
 
    // Note that virtual is not needed, since this class is final and is not part of a class tree.
    ~FactoryRegistry();
 
    void Register(const FactoryIf* factory);
 
    void Deregister(const FactoryIf* factory) noexcept;
 
    const FactoryIf* FindCompatibleFactory(const AdapterIdType& id) const noexcept;
 
    static std::shared_ptr<FactoryRegistry<BaseIf>> GetInstance();
 
private:
    // Do not allow copying of this class.
    FactoryRegistry(const FactoryRegistry&) = delete;
    FactoryRegistry& operator=(const FactoryRegistry&) = delete;
    FactoryRegistry(FactoryRegistry&&) = delete;
    FactoryRegistry& operator=(FactoryRegistry&&) = delete;
 
    mutable std::mutex m_mutex;
 
    std::vector<const FactoryIf*> m_factories;
};
 
template <class BaseIf, class Factory>
class RegisterFactory final {
public:
    RegisterFactory();
    ~RegisterFactory();
 
private:
    // Do not allow copying of this class.
    RegisterFactory(const RegisterFactory&) = delete;
    RegisterFactory& operator=(const RegisterFactory&) = delete;
    RegisterFactory(RegisterFactory&&) = delete;
    RegisterFactory& operator=(RegisterFactory&&) = delete;
 
    // Need to hold a shared pointer to the registry that we will be registering with, so that the
    // registry is kept alive as long as we have not unregistered the factory.
    std::shared_ptr<FactoryRegistry<BaseIf>> m_registry;
 
    // The instance of the factory that will be registered with the registry.
    Factory m_factory;
};
 
}  // namespace rtctk::componentFramework
 
#include <rtctk/componentFramework/factoryRegistry.ipp>
 
#endif  // RTCTK_COMPONENTFRAMEWORK_FACTORYREGISTRY_HPP