LayoutSourceProviderRegistry.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2026 fuddlesworth
// SPDX-License-Identifier: LGPL-2.1-or-later
 
#pragma once
 
#include <phosphorlayoutapi_export.h>
 
#include <PhosphorLayoutApi/ILayoutSourceFactory.h>
 
#include <QDebug>
#include <QList>
#include <QMutex>
#include <QString>
 
#include <functional>
#include <memory>
#include <type_traits>
#include <typeindex>
#include <unordered_map>
 
namespace PhosphorLayout {
 
class PHOSPHORLAYOUTAPI_EXPORT FactoryContext
{
public:
    template<typename T>
    bool set(std::type_identity_t<T*> service)
    {
        // Compile-time guard for the void*-round-trip invariants
        // documented above. T must be a class type (no plain pointers
        // sneaking in via deduction), and its inheritance chain MUST be
        // single (single-base) to keep static_cast<void*>(T*) ↔
        // static_cast<T*>(void*) at a fixed offset. We can't statically
        // detect virtual inheritance with pre-C++26 traits, but we can
        // catch the most common silent-bug shape: a Concrete that
        // multiply-inherits two non-related abstract bases would still
        // round-trip safely under T == Concrete, but the documented
        // pattern is to set<Interface>(...) — and that one does
        // round-trip provided Interface itself sits at offset 0 in T.
        // The runtime test in test_factory_context_typing covers the
        // remaining cases.
        static_assert(std::is_class_v<T>, "FactoryContext::set<T>: T must be a class type");
        static_assert(!std::is_pointer_v<T>,
                      "FactoryContext::set<T>: pass the interface type, not a pointer type "
                      "(write set<IFoo>(p), not set<IFoo*>(p))");
        const auto key = std::type_index(typeid(T));
        const bool duplicate = m_services.find(key) != m_services.end();
        Q_ASSERT_X(!duplicate, "FactoryContext::set",
                   "service key already registered; duplicate set<T>() is a programmer error");
        if (duplicate) {
            qWarning("FactoryContext::set: ignoring duplicate registration for type '%s' (first registration kept)",
                     key.name());
            return false;
        }
        m_services[key] = static_cast<void*>(service);
        return true;
    }
 
    template<typename T>
    T* get() const
    {
        static_assert(std::is_class_v<T>, "FactoryContext::get<T>: T must be a class type");
        static_assert(!std::is_pointer_v<T>,
                      "FactoryContext::get<T>: pass the interface type, not a pointer type "
                      "(write get<IFoo>(), not get<IFoo*>())");
        const auto it = m_services.find(std::type_index(typeid(T)));
        return it == m_services.end() ? nullptr : static_cast<T*>(it->second);
    }
 
private:
    std::unordered_map<std::type_index, void*> m_services;
};
 
struct PHOSPHORLAYOUTAPI_EXPORT PendingLayoutSourceProvider
{
    QString name;
    int priority = 100;
    std::function<std::unique_ptr<ILayoutSourceFactory>(const FactoryContext&)> builder;
};
 
PHOSPHORLAYOUTAPI_EXPORT QList<PendingLayoutSourceProvider>& pendingLayoutSourceProviders();
 
PHOSPHORLAYOUTAPI_EXPORT QMutex& pendingLayoutSourceProvidersMutex();
 
class PHOSPHORLAYOUTAPI_EXPORT LayoutSourceProviderRegistrar
{
public:
    LayoutSourceProviderRegistrar(QString name, int priority,
                                  std::function<std::unique_ptr<ILayoutSourceFactory>(const FactoryContext&)> builder);
};
 
template<typename Registry, typename Factory>
inline std::unique_ptr<ILayoutSourceFactory> makeProviderFactory(const FactoryContext& ctx)
{
    auto* registry = ctx.get<Registry>();
    if (!registry) {
        return nullptr;
    }
    return std::make_unique<Factory>(registry);
}
 
} // namespace PhosphorLayout