factoryRegistry.ipp

Go to the documentation of this file.

 
// Note this is a template implementation file and should not be included directly.
// The typical header protection macro is not added to avoid it showing up in Doxygen API
// documentation.
#pragma once
 
#include <algorithm>
#include <cassert>
 
namespace rtctk::componentFramework {
 
template <class BaseIf>
FactoryRegistry<BaseIf>::~FactoryRegistry() {
    // Check that all factories are unregistered at the time we are destroying this factory registry
    // object. If this is not the case, then either a library is incorrectly implemented and not
    // cleaning up properly, or the registry is being destroyed before all shared libraries got a
    // chance to cleanup and deregister their factories. In either case, this is a bug, which this
    // assertion failure exposes.
#ifndef NDEBUG
    std::scoped_lock lock(m_mutex);
    assert(m_factories.size() == 0);
#endif
}
 
template <class BaseIf>
void FactoryRegistry<BaseIf>::Register(const FactoryIf* factory) {
    // Note that we should not log in this function, since it will likely be called during process
    // startup when no logging facilities are configured or appropriate.
    std::scoped_lock lock(m_mutex);
    auto position = std::find(m_factories.begin(), m_factories.end(), factory);
    if (position == m_factories.end()) {
        m_factories.push_back(factory);
    }
}
 
template <class BaseIf>
void FactoryRegistry<BaseIf>::Deregister(const FactoryIf* factory) noexcept {
    // Note that similar logging restriction applies to this method as for Register, but during
    // process termination.
    std::scoped_lock lock(m_mutex);
    auto position = std::find(m_factories.begin(), m_factories.end(), factory);
    if (position != m_factories.end()) {
        m_factories.erase(position);
    }
}
 
template <class BaseIf>
const typename FactoryRegistry<BaseIf>::FactoryIf*
FactoryRegistry<BaseIf>::FindCompatibleFactory(const AdapterIdType& id) const noexcept {
    std::scoped_lock lock(m_mutex);
    auto factory = std::find_if(
        m_factories.begin(), m_factories.end(), [&](auto& x) { return x->CanHandle(id); });
    if (factory != m_factories.end()) {
        return *factory;
    } else {
        return nullptr;
    }
}
 
template <class BaseIf>
std::shared_ptr<FactoryRegistry<BaseIf>> FactoryRegistry<BaseIf>::GetInstance() {
    // Using a static local shared pointer to the global instance, since the C++ language guarantees
    // will defer the initialisation of an empty registry object to the very first call of
    // GetInstance. And this is done in a thread-safe manner. In addition, on the Linux platform at
    // least, the linker will ensure there is only one copy of this object, even if the symbol was
    // compiled into multiple translation units.
    // The advantage of the static local variable versus a static class attribute is that this
    // approach is more generic. Whenever a new type for T is used by the end user of this class,
    // there is nothing special that needs to be done by the user. While using a static class
    // attribute, e.g. s_registry, would require adding additional template specialisations to the
    // common shared library of the following form:
    //
    //   template<>
    //   std::shared_ptr<FactoryRegistry<MyInterface>> FactoryRegistry<MyInterface>::s_registry {};
    //
    // This would limit how flexible the FactoryRegistry class is.
    //
    // The reason to use a shared_ptr is to use reference counting to control the life-cycle of the
    // registry object. The RegisterFactory must hold a shared pointer to the factory registry
    // object for as long as the RegisterFactory exists, i.e. for as long as it has registered a
    // factory with the registry. Using shared pointers should guarantee that the registry object
    // will only be deleted once all relevant RegisterFactory classes are cleaned up.
    // Experience has shown that if we do not use a shared_ptr and simply return a reference to a
    // local object, the cleanup order becomes dependent on the link order of the shared libraries,
    // i.e. undefined.
    //
    static std::shared_ptr<FactoryRegistry<BaseIf>> registry =
        std::make_shared<FactoryRegistry<BaseIf>>();
    return registry;
}
 
template <class BaseIf, class Factory>
RegisterFactory<BaseIf, Factory>::RegisterFactory()
    : m_registry(FactoryRegistry<BaseIf>::GetInstance()) {
    m_registry->Register(&m_factory);
}
 
template <class BaseIf, class Factory>
RegisterFactory<BaseIf, Factory>::~RegisterFactory() {
    m_registry->Deregister(&m_factory);
}
 
}  // namespace rtctk::componentFramework