path: root/include/qdotnetobject.h

/***************************************************************************************************
 Copyright (C) 2023 The Qt Company Ltd.
 SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
***************************************************************************************************/

#pragma once

#include "qdotnettype.h"

#ifdef __GNUC__
#   pragma GCC diagnostic push
#   pragma GCC diagnostic ignored "-Wconversion"
#endif
#include <QList>
#include <QString>
#ifdef __GNUC__
#   pragma GCC diagnostic pop
#endif

struct QDotNetEventHandler;

class QDotNetObject : public QDotNetRef
{
private:
    // nullptr and void* ctors
#define Q_DOTNET_OBJECT_REF(T)\
    T(nullptr_t);\
    T(const void *)

    // Copy ctor and assignment
#define Q_DOTNET_OBJECT_COPY(T)\
    T(const T &);\
    T &operator =(const T &)

    // Move ctor and assignment
#define Q_DOTNET_OBJECT_MOVE(T)\
    T(T &&) noexcept;\
    T &operator=(T &&) noexcept

    // Fully qualified .NET class name
#define Q_DOTNET_OBJECT_TYPE(T,type_name)\
    static inline const QString &AssemblyQualifiedName = QString(type_name)

    // All required declarations
#define Q_DOTNET_OBJECT(T,type_name)\
    Q_DOTNET_OBJECT_REF(T);\
    Q_DOTNET_OBJECT_COPY(T);\
    Q_DOTNET_OBJECT_MOVE(T);\
    Q_DOTNET_OBJECT_TYPE(T, type_name)

    // nullptr and void* ctors
#define Q_DOTNET_OBJECT_REF_IMPL(T,...)\
    T::T(nullptr_t) \
        : QDotNetObject(nullptr) __VA_ARGS__ \
    {}\
    T::T(const void *objectRef) \
        : QDotNetObject(objectRef) __VA_ARGS__ \
    {}

    // Copy ctor and assignment
#define Q_DOTNET_OBJECT_COPY_IMPL(T,...)\
    T::T(const T &cpySrc) \
        : QDotNetObject(cpySrc) __VA_ARGS__ \
    {}\
    T &T::operator=(const T &cpySrc)\
    {\
        QDotNetObject::operator=(cpySrc);\
        return *this;\
    }

    // Move ctor and assignment
#define Q_DOTNET_OBJECT_MOVE_IMPL(T,...)\
    T::T(T &&movSrc) noexcept \
        : QDotNetObject(std::move(movSrc)) __VA_ARGS__\
    {}\
    T &T::operator=(T &&movSrc) noexcept\
    {\
        QDotNetObject::operator=(std::move(movSrc));\
        return *this;\
    }

    // All required ctor and assignment implementations
#define Q_DOTNET_OBJECT_IMPL(T,...)\
    Q_DOTNET_OBJECT_REF_IMPL(T, __VA_ARGS__)\
    Q_DOTNET_OBJECT_COPY_IMPL(T, __VA_ARGS__)\
    Q_DOTNET_OBJECT_MOVE_IMPL(T, __VA_ARGS__)

    // nullptr and void* ctors
#define Q_DOTNET_OBJECT_REF_INLINE(T,...)\
    T(nullptr_t)\
        : QDotNetObject(nullptr) __VA_ARGS__\
    {}\
    T(const void *objectRef)\
        : QDotNetObject(objectRef) __VA_ARGS__\
    {}

    // Copy ctor and assignment
#define Q_DOTNET_OBJECT_COPY_INLINE(T,...)\
    T(const T &cpySrc)\
        : QDotNetObject(cpySrc) __VA_ARGS__\
    {}\
    T &operator=(const T &cpySrc)\
    {\
        QDotNetObject::operator=(cpySrc);\
        return *this;\
    }

    // Move ctor and assignment
#define Q_DOTNET_OBJECT_MOVE_INLINE(T,...)\
    T(T &&movSrc) noexcept\
        : QDotNetObject(std::move(movSrc)) __VA_ARGS__\
    {}\
    T &operator=(T &&movSrc) noexcept\
    {\
        QDotNetObject::operator=(std::move(movSrc));\
        return *this;\
    }

    // All required ctor and assignment implementations
#define Q_DOTNET_OBJECT_INLINE(T,type_name,...)\
    Q_DOTNET_OBJECT_REF_INLINE(T, __VA_ARGS__)\
    Q_DOTNET_OBJECT_COPY_INLINE(T, __VA_ARGS__)\
    Q_DOTNET_OBJECT_MOVE_INLINE(T, __VA_ARGS__)\
    Q_DOTNET_OBJECT_TYPE(T, type_name)

    // Member initialization list for derived class
#define Q_DOTNET_OBJECT_INIT(...) , __VA_ARGS__

public:
    static inline const QString &AssemblyQualifiedName = QStringLiteral("System.Object");

    QDotNetObject(const void *objectRef = nullptr)
        : QDotNetRef(objectRef)
    {}

    QDotNetObject(const QDotNetObject &cpySrc)
        : QDotNetRef(cpySrc)
    {}

    QDotNetObject &operator =(const QDotNetObject &cpySrc)
    {
        QDotNetRef::operator=(cpySrc);
        return *this;
    }

    QDotNetObject(QDotNetObject &&movSrc) noexcept
        : QDotNetRef(std::move(movSrc))
    {}

    QDotNetObject &operator=(QDotNetObject &&movSrc) noexcept
    {
        QDotNetRef::operator=(std::move(movSrc));
        return *this;
    }

    virtual ~QDotNetObject() override = default;

    const QDotNetType &type() const
    {
        if (!fnGetType.isValid()) {
            method("GetType", fnGetType);
            objType = fnGetType.invoke(*this);
        }
        return objType;
    }

    template<typename TResult, typename ...TArg>
    QDotNetFunction<TResult, TArg...> method(const QString &methodName) const
    {
        const QList<QDotNetParameter> parameters
        {
            QDotNetInbound<TResult>::Parameter,
            QDotNetOutbound<TArg>::Parameter...
        };
        return adapter().resolveInstanceMethod(*this, methodName, parameters);
    }

    template<typename TResult, typename ...TArg>
    QDotNetFunction<TResult, TArg...> &method(const QString &methodName,
        QDotNetFunction<TResult, TArg...> &func) const
    {
        if (!func.isValid())
            func = method<TResult, TArg...>(methodName);
        return func;
    }

    template<typename TResult, typename ...TArg>
    QDotNetSafeMethod<TResult, TArg...> &method(const QString &methodName,
        QDotNetSafeMethod<TResult, TArg...> &func) const
    {
        if (!func.isValid())
            func = method<TResult, TArg...>(methodName);
        return func;
    }

    template<typename TResult, typename ...TArg>
    QDotNetFunction<TResult, TArg...> staticMethod(const QString &methodName) const
    {
        return type().staticMethod<TResult, TArg...>(methodName);
    }

    template<typename TResult, typename ...TArg>
    QDotNetFunction<TResult, TArg...> &staticMethod(const QString &methodName,
        QDotNetFunction<TResult, TArg...> &func) const
    {
        if (!func.isValid())
            func = type().staticMethod<TResult, TArg...>(methodName);
        return func;
    }

    template<typename TResult, typename ...TArg>
    QDotNetSafeMethod<TResult, TArg...> &staticMethod(const QString &methodName,
        QDotNetSafeMethod<TResult, TArg...> &func) const
    {
        if (!func.isValid())
            func = type().staticMethod<TResult, TArg...>(methodName);
        return func;
    }

    template<typename ...TArg>
    static QDotNetFunction<QDotNetObject, TArg...> constructor(const QString &typeName)
    {
        return QDotNetType::constructor<QDotNetObject, TArg...>(typeName);
    }

    template<typename ...TArg>
    static QDotNetFunction<QDotNetObject, TArg...> &constructor(const QString &typeName,
        QDotNetFunction<QDotNetObject, TArg...> &ctor)
    {
        return QDotNetType::constructor(typeName, ctor);
    }

    template<typename ...TArg>
    static QDotNetSafeMethod<QDotNetObject, TArg...> &constructor(const QString &typeName,
        QDotNetSafeMethod<QDotNetObject, TArg...> &ctor)
    {
        return QDotNetType::constructor(typeName, ctor);
    }

    template<typename T>
    QDotNetFunction<T, QDotNetRef> fieldGet(const QString &fieldName)
    {
        const QList<QDotNetParameter> parameters
        {
            QDotNetInbound<T>::Parameter,
            QDotNetOutbound<QDotNetRef>::Parameter
        };

        return adapter().resolveInstanceFieldGet(*this, fieldName, parameters);
    }

    template<typename T>
    QDotNetFunction<T, QDotNetRef> fieldGet(const QString &fieldName,
        QDotNetFunction<T, QDotNetRef> &func)
    {
        if (!func.isValid())
            func = fieldGet<T>(fieldName);
        return func;
    }

    template<typename T>
    QDotNetFunction<void, QDotNetRef, T> fieldSet(const QString &fieldName)
    {
        const QList<QDotNetParameter> parameters
        {
            QDotNetInbound<void>::Parameter,
            QDotNetOutbound<QDotNetRef>::Parameter,
            QDotNetOutbound<T>::Parameter,
        };

        return adapter().resolveInstanceFieldSet(*this, fieldName, parameters);
    }

    template<typename T>
    QDotNetFunction<void, QDotNetRef, T> fieldSet(const QString &fieldName,
        QDotNetFunction<void, QDotNetRef, T> &func)
    {
        if (!func.isValid())
            func = fieldSet<T>(fieldName);
        return func;
    }

    void subscribe(const QString &eventName, QDotNetEventHandler *eventHandler)
    {
        adapter().addEventHandler(*this, eventName, eventHandler, eventCallback);
    }

    void unsubscribe(const QString &eventName, QDotNetEventHandler *eventHandler)
    {
        adapter().removeEventHandler(*this, eventName, eventHandler);
    }

    QDotNetObject object(const QString &path)
    {
        return adapter().object(*this, path);
    }

    template<typename TResult, typename ...TArg>
    TResult call(const QString &methodName, TArg... arg) const
    {
        return method<TResult, TArg...>(methodName).invoke(*this, arg...);
    }

    template<typename ...TArg>
    void call(const QString &methodName, TArg... arg) const
    {
        method<void, TArg...>(methodName).invoke(*this, arg...);
    }

protected:
    template<typename T, typename ...TArg>
    static QDotNetFunction<T, TArg...> constructor()
    {
        return QDotNetType::constructor<T, TArg...>(T::AssemblyQualifiedName);
    }

    template<typename T, typename ...TArg>
    static QDotNetFunction<T, TArg...> &constructor(QDotNetFunction<T, TArg...> &ctor)
    {
        return QDotNetType::constructor(T::AssemblyQualifiedName, ctor);
    }

    template<typename T, typename ...TArg>
    static QDotNetSafeMethod<T, TArg...> &constructor(QDotNetSafeMethod<T, TArg...> &ctor)
    {
        return QDotNetType::constructor(T::AssemblyQualifiedName, ctor);
    }

private:
    static inline void QDOTNETFUNCTION_CALLTYPE eventCallback(void *context, void *eventNameChars,
        void *eventSourceRef, void *eventArgsRef);

    mutable QDotNetFunction<QDotNetType> fnGetType;
    mutable QDotNetType objType = nullptr;
    mutable QDotNetFunction<QString> fnToString;
    mutable QDotNetFunction<bool, QDotNetRef> fnEquals;
};

struct QDotNetEventHandler
{
    virtual ~QDotNetEventHandler() = default;
    virtual void handleEvent(const QString &eventName, QDotNetObject &eventSource,
        QDotNetObject &eventArgs) = 0;
};

template<typename T = nullptr_t>
struct QDotNetEventHandlerHelper : public QDotNetEventHandler
{
    QDotNetEventHandlerHelper(const QString &eventName, QDotNetObject *receiver, T *d = nullptr)
        : eventName(eventName), receiver(receiver), d(d)
    {
        receiver->subscribe(eventName, this);
    }

    ~QDotNetEventHandlerHelper() override
    {
        // TO_DO: figure out why this crashes on app shutdown
        if (receiver && receiver->isValid())
            receiver->unsubscribe(eventName, this);
    }

    const QString eventName{ };
    QDotNetObject *receiver{ nullptr };
    T *d{ nullptr };
};

#define Q_DOTNET_EVENT_HANDLER(event_name,context) \
struct event_name##EventHandler : public QDotNetEventHandlerHelper<context> \
{ \
    event_name##EventHandler(QDotNetObject *receiver, context *d = nullptr) \
    : QDotNetEventHandlerHelper<context>(#event_name, receiver, d) {} \
    void handleEvent(const QString &name, QDotNetObject &sender, QDotNetObject &args) override; \
}; \
event_name##EventHandler

#define Q_DOTNET_CONTEXT_FREE_EVENT_HANDLER(event_name) \
struct event_name##EventHandler : public QDotNetEventHandlerHelper<> \
{ \
    event_name##EventHandler(QDotNetObject *receiver) \
    : QDotNetEventHandlerHelper<>(#event_name, receiver) {} \
    void handleEvent(const QString &name, QDotNetObject &sender, QDotNetObject &args) override; \
}; \
event_name##EventHandler

inline void QDOTNETFUNCTION_CALLTYPE QDotNetObject::eventCallback(void *context, void *eventNameChars,
    void *eventSourceRef, void *eventArgsRef)
{
    auto *receiver = static_cast<QDotNetEventHandler *>(context);
    const QString eventName(static_cast<const QChar *>(eventNameChars));
    QDotNetObject eventSource(eventSourceRef);
    QDotNetObject eventArgs(eventArgsRef);
    receiver->handleEvent(eventName, eventSource, eventArgs);
}

template<typename T>
struct QDotNetTypeOf<T, std::enable_if_t<std::is_base_of_v<QDotNetObject, T>>>
{
    static inline const QString TypeName = T::AssemblyQualifiedName;
    static inline UnmanagedType MarshalAs = UnmanagedType::ObjectRef;
};