plugindependency.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2024 Manuel Schneider
// SPDX-License-Identifier: MIT
 
#pragma once
#include <QCoreApplication>
#include <albert/export.h>
#include <albert/extensionregistry.h>
#include <albert/logging.h>
 
namespace albert
{
 
template<class T>
class ALBERT_EXPORT Dependency
{
public:
 
    inline operator T() const { return dependency; }
    inline operator bool() const { return dependency != nullptr; }
    const T* operator->() const { return dependency; }
    T* operator->() { return dependency; }
    const T* get() const { return dependency; }
    T* get() { return dependency; }
 
protected:
 
    T *dependency = nullptr;
 
    explicit Dependency(ExtensionRegistry &registry, const QString &id)
    {
        try {
            auto *e = registry.extensions().at(id);
            dependency = dynamic_cast<T*>(e);
            if (!dependency)
                WARN << QString("Found '%1' but failed casting to expected type.").arg(id);
        } catch (const std::out_of_range &) {}
    }
};
 
template<class T>
class ALBERT_EXPORT StrongDependency final : public Dependency<T>
{
public:
 
    explicit StrongDependency(ExtensionRegistry &registry, const QString &id):
        Dependency<T>(registry, id)
    {
        if (!this->dependency)
        {
            auto m = QCoreApplication::translate(
                        "Dependency",
                        "Required dependency '%1' not available.").arg(id);
            throw std::runtime_error(m.toStdString());
        }
    }
};
 
template<class T>
class ALBERT_EXPORT WeakDependency final : public Dependency<T>
{
public:
 
    explicit WeakDependency(ExtensionRegistry &registry, const QString &id,
                            std::function<void(bool)> registeredCallback = {}):
        Dependency<T>(registry, id),
        callback(registeredCallback)
    {
        conn_add_ = QObject::connect(&registry, &ExtensionRegistry::added, [this](Extension *e)
        {
            if (e->id() != id_)
                return;
 
            if (!this->dependency)
            {
                if (auto *d = dynamic_cast<T*>(e); d)
                {
                    this->dependency = d;
                    if (callback)
                        callback(true);
                }
                else
                    WARN << QString("Failed casting '%1' to expected type.").arg(id_);
            }
            else
                WARN << "WeakDependency already set. Internal logic error?";
 
        });
 
        conn_rem_ = QObject::connect(&registry, &ExtensionRegistry::removed, [this](Extension *e)
        {
            if (e->id() != id_)
                return;
 
            if (this->dependency)
            {
                if (auto *d = dynamic_cast<T*>(e); d)
                {
                    if (callback)
                        callback(false);  // the dependency should still be usable in the callback
                    this->dependency = nullptr;
                }
                else
                    WARN << QString("Failed casting '%1' to expected type.").arg(id_);
            }
            else
                WARN << "WeakDependency already unset. Internal logic error?";
        });
    }
 
    ~WeakDependency()
    {
        QObject::disconnect(conn_add_);
        QObject::disconnect(conn_rem_);
    }
 
    std::function<void(bool)> callback;
 
private:
 
    QMetaObject::Connection conn_add_;
    QMetaObject::Connection conn_rem_;
    const QString id_;
 
};
 
}