serviceregistry.h

#ifndef QTMVVM_SERVICEREGISTRY_H
#define QTMVVM_SERVICEREGISTRY_H

#include <functional>

#include <QtCore/qscopedpointer.h>
#include <QtCore/qvariant.h>
#include <QtCore/qexception.h>

#include "QtMvvmCore/qtmvvmcore_global.h"
#include "QtMvvmCore/injection.h"

namespace QtMvvm {

class ServiceRegistryPrivate;
class Q_MVVMCORE_EXPORT ServiceRegistry
{
public:
    ServiceRegistry(ServiceRegistryPrivate *d_ptr);
    ~ServiceRegistry();

    static ServiceRegistry* instance();

    template <typename TInterface>
    bool isRegistered() const;
    bool isRegistered(const QByteArray &iid) const;

    template <typename TInterface, typename TService>
    void registerInterface(bool weak = false);
    template <typename TInterface, typename TService, typename TFunc>
    void registerInterface(const TFunc &fn, bool weak = false);
    template <typename TInterface, typename TService>
    void registerInterface(TService *service, bool weak = false);
    template <typename TService>
    void registerObject(bool weak = false);
    template <typename TService, typename TFunc>
    void registerObject(const TFunc &fn, bool weak = false);
    template <typename TService>
    void registerObject(TService *service, bool weak = false);

    void registerService(const QByteArray &iid,
                         const QMetaObject *metaObject,
                         bool weak = false);
    void registerService(const QByteArray &iid,
                         const std::function<QObject*(const QObjectList &)> &fn,
                         QByteArrayList injectables,
                         bool weak = false);

    template <typename TInterface>
    TInterface *service();
    QObject *serviceObj(const QByteArray &iid);

    void injectServices(QObject *object);
    template <typename TClass>
    TClass *constructInjected(QObject *parent = nullptr);
    QObject *constructInjected(const QMetaObject *metaObject, QObject *parent = nullptr);

private:
    friend class QtMvvm::ServiceRegistryPrivate;
    QScopedPointer<ServiceRegistryPrivate> d;
};

class Q_MVVMCORE_EXPORT ServiceExistsException : public QException
{
public:
    ServiceExistsException(const QByteArray &iid);

    const char *what() const noexcept override;

    void raise() const override;
    QException *clone() const override;

protected:
    ServiceExistsException(const ServiceExistsException * const other);

    const QByteArray _msg;
};

class Q_MVVMCORE_EXPORT ServiceConstructionException : public QException
{
public:
    ServiceConstructionException(const QByteArray &message);

    const char *what() const noexcept override;

    void raise() const override;
    QException *clone() const override;

protected:
    ServiceConstructionException(const ServiceConstructionException * const other);

    const QByteArray _msg;
};

class Q_MVVMCORE_EXPORT ServiceDependencyException : public ServiceConstructionException
{
public:
    ServiceDependencyException(const QByteArray &iid);

    void raise() const override;
    QException *clone() const override;

protected:
    ServiceDependencyException(const ServiceDependencyException * const other);
};

// ------------- Generic Implementation -------------

template<typename TInterface>
bool ServiceRegistry::isRegistered() const
{
    return isRegistered(__helpertypes::inject_iid<TInterface*>());
}

#define QTMVVM_SERVICE_ASSERT(tint, tsvc) \
    static_assert(__helpertypes::is_valid_interface<TInterface, TService>::value, "TService must implement the given TInterface interface and be a qobject class"); \
    Q_ASSERT_X(qobject_interface_iid<TInterface*>(), Q_FUNC_INFO, "TInterface must be registered with Q_DECLARE_INTERFACE");

template<typename TInterface, typename TService>
void ServiceRegistry::registerInterface(bool weak)
{
    QTMVVM_SERVICE_ASSERT(TInterface, TService)
    registerService(qobject_interface_iid<TInterface*>(), &TService::staticMetaObject, weak);
}

template <typename TInterface, typename TService, typename TFunc>
void ServiceRegistry::registerInterface(const TFunc &fn, bool weak)
{
    QTMVVM_SERVICE_ASSERT(TInterface, TService)
    QByteArrayList injectables;
    auto packed_fn = __helpertypes::pack_function(fn, injectables);
    registerService(qobject_interface_iid<TInterface*>(), packed_fn, injectables, weak);
}

template<typename TInterface, typename TService>
void ServiceRegistry::registerInterface(TService *service, bool weak)
{
    QTMVVM_SERVICE_ASSERT(TInterface, TService)
    registerService(qobject_interface_iid<TInterface*>(), [service](const QObjectList &params) -> QObject* {
        Q_UNUSED(params);
        return service;
    }, QByteArrayList(), weak);
}

#undef QTMVVM_SERVICE_ASSERT
#define QTMVVM_SERVICE_ASSERT(tsvc) \
    static_assert(__helpertypes::is_qobj<tsvc>::value, "TService must be a qobject class");

template<typename TService>
void ServiceRegistry::registerObject(bool weak)
{
    QTMVVM_SERVICE_ASSERT(TService)
    registerService(__helpertypes::qobject_iid<TService*>(), &TService::staticMetaObject, weak);
}

template<typename TService, typename TFunc>
void ServiceRegistry::registerObject(const TFunc &fn, bool weak)
{
    QTMVVM_SERVICE_ASSERT(TService)
    QByteArrayList injectables;
    auto packed_fn = __helpertypes::pack_function(fn, injectables);
    registerService(__helpertypes::qobject_iid<TService*>(), packed_fn, injectables, weak);
}

template<typename TService>
void ServiceRegistry::registerObject(TService *service, bool weak)
{
    QTMVVM_SERVICE_ASSERT(TService)
    registerService(__helpertypes::qobject_iid<TService*>(), [service](const QObjectList &params) -> QObject* {
        Q_UNUSED(params);
        return service;
    }, QByteArrayList(), weak);
}

#undef QTMVVM_SERVICE_ASSERT

template<typename TInterface>
TInterface *ServiceRegistry::service()
{
    return qobject_cast<TInterface*>(serviceObj(__helpertypes::inject_iid<TInterface*>()));
}

template<typename TClass>
TClass *ServiceRegistry::constructInjected(QObject *parent)
{
    static_assert(__helpertypes::is_qobj<TClass>::value, "TClass must be a qobject class");
    return qobject_cast<TClass*>(constructInjected(&TClass::staticMetaObject, parent));
}

}

#endif // QTMVVM_SERVICEREGISTRY_H