path: root/tests/auto/conversion/comutil_p.h

// Copyright (C) 2023 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause

#ifndef COMUTIL_P_H
#define COMUTIL_P_H

//
//  W A R N I N G
//  -------------
//
// This file is not part of the Qt API. It exists purely as an
// implementation detail. This header file may change from version to
// version without notice, or even be removed.
//
// We mean it.
//

#include <QtCore/QtGlobal>
#include <comdef.h>
#include <type_traits>
#include <oleauto.h>
#include <wrl/client.h>

using Microsoft::WRL::ComPtr;

template<typename T>
ComPtr<T> makeComObject()
{
    ComPtr<T> ptr;
    *ptr.GetAddressOf() = new T;
    return ptr;
}

class ComBstr
{
public:
    ComBstr() = default;

    ComBstr(decltype(nullptr)) { }

    ~ComBstr() { ::SysFreeString(m_str); }

    explicit ComBstr(const wchar_t *str) noexcept
    {
        if (!str)
            return;

        m_str = ::SysAllocString(str);
        Q_ASSERT(m_str);
    }

    ComBstr(const ComBstr &src) noexcept
    {
        if (!src.m_str)
            return;

        m_str = ::SysAllocStringByteLen(reinterpret_cast<char *>(src.m_str),
                                        ::SysStringByteLen(m_str));
        Q_ASSERT(m_str);
    }

    ComBstr(ComBstr &&src) noexcept : m_str{ src.m_str } { src.m_str = nullptr; }

    ComBstr &operator=(const ComBstr &rhs) noexcept
    {
        if (&rhs == this)
            return *this;

        clear();

        m_str = rhs.copy();

        return *this;
    }

    ComBstr &operator=(ComBstr &&rhs) noexcept
    {
        if (&rhs == this)
            return *this;

        clear();

        m_str = rhs.m_str;
        rhs.m_str = nullptr;

        return *this;
    }

    [[nodiscard]] BSTR copy() const
    {
        if (!m_str)
            return nullptr;

        return ::SysAllocStringByteLen(reinterpret_cast<char *>(m_str), ::SysStringByteLen(m_str));
    }

private:
    void clear() { ::SysFreeString(m_str); }

    BSTR m_str = nullptr;
};

template<typename T>
constexpr VARTYPE ValueType()
{
    using ValueType = std::remove_cv_t<std::remove_pointer_t<T>>;

    constexpr VARTYPE maybeByref = std::is_pointer_v<T> ? VT_BYREF : VT_EMPTY;
    if constexpr (std::is_same_v<ValueType, bool>)
        return VT_BOOL | maybeByref;
    else if constexpr (std::is_same_v<ValueType, char>)
        return VT_I1 | maybeByref;
    else if constexpr (std::is_same_v<ValueType, unsigned char>)
        return VT_UI1 | maybeByref;
    else if constexpr (std::is_same_v<ValueType, short>)
        return VT_I2 | maybeByref;
    else if constexpr (std::is_same_v<ValueType, unsigned short>)
        return VT_UI2 | maybeByref;
    else if constexpr (std::is_same_v<ValueType, int>)
        return VT_I4 | maybeByref;
    else if constexpr (std::is_same_v<ValueType, unsigned int>)
        return VT_UI4 | maybeByref;
    else if constexpr (std::is_same_v<ValueType, long long>)
        return VT_I8 | maybeByref;
    else if constexpr (std::is_same_v<ValueType, unsigned long long>)
        return VT_UI8 | maybeByref;
    else if constexpr (std::is_same_v<ValueType, float>)
        return VT_R4 | maybeByref;
    else if constexpr (std::is_same_v<ValueType, double>)
        return VT_R8 | maybeByref;
    else if constexpr (std::is_same_v<const ValueType *, const wchar_t *>)
        return VT_BSTR;
    else if constexpr (std::is_base_of_v<IDispatch, ValueType>)
        return VT_DISPATCH;
    else if constexpr (std::is_base_of_v<IUnknown, ValueType>)
        return VT_UNKNOWN;
    else
        return VT_EMPTY;
};

template<typename T>
constexpr auto ValueField()
{
    using Type = std::remove_const_t<T>;
    if constexpr (std::is_same_v<Type, bool>)
        return &VARIANT::boolVal;
    else if constexpr (std::is_same_v<Type, bool *>)
        return &VARIANT::pboolVal;
    else if constexpr (std::is_same_v<Type, char>)
        return &VARIANT::cVal;
    else if constexpr (std::is_same_v<Type, char *>)
        return &VARIANT::pcVal;
    else if constexpr (std::is_same_v<Type, unsigned char>)
        return &VARIANT::bVal;
    else if constexpr (std::is_same_v<Type, unsigned char *>)
        return &VARIANT::pbVal;
    else if constexpr (std::is_same_v<Type, short>)
        return &VARIANT::iVal;
    else if constexpr (std::is_same_v<Type, short *>)
        return &VARIANT::piVal;
    else if constexpr (std::is_same_v<Type, unsigned short>)
        return &VARIANT::uiVal;
    else if constexpr (std::is_same_v<Type, unsigned short *>)
        return &VARIANT::puiVal;
    else if constexpr (std::is_same_v<Type, int>)
        return &VARIANT::intVal;
    else if constexpr (std::is_same_v<Type, int *>)
        return &VARIANT::pintVal;
    else if constexpr (std::is_same_v<Type, unsigned int>)
        return &VARIANT::uintVal;
    else if constexpr (std::is_same_v<Type, unsigned int *>)
        return &VARIANT::puintVal;
    else if constexpr (std::is_same_v<Type, long long>)
        return &VARIANT::llVal;
    else if constexpr (std::is_same_v<Type, long long *>)
        return &VARIANT::pllVal;
    else if constexpr (std::is_same_v<Type, unsigned long long>)
        return &VARIANT::ullVal;
    else if constexpr (std::is_same_v<Type, unsigned long long *>)
        return &VARIANT::pullVal;
    else if constexpr (std::is_same_v<Type, float>)
        return &VARIANT::fltVal;
    else if constexpr (std::is_same_v<Type, float *>)
        return &VARIANT::pfltVal;
    else if constexpr (std::is_same_v<Type, double>)
        return &VARIANT::dblVal;
    else if constexpr (std::is_same_v<Type, double *>)
        return &VARIANT::pdblVal;
    else if constexpr (std::is_same_v<T, const wchar_t *>)
        return &VARIANT::bstrVal;
    else if constexpr (std::is_base_of_v<IDispatch, std::remove_pointer_t<Type>>)
        return &VARIANT::pdispVal;
    else if constexpr (std::is_base_of_v<IUnknown, std::remove_pointer_t<Type>>)
        return &VARIANT::punkVal;
}

class ComVariant : public tagVARIANT
{
public:
    ComVariant() noexcept : VARIANT{} { ::VariantInit(this); }

    ~ComVariant()
    {
        const HRESULT hr = ::VariantClear(this);
        Q_ASSERT(hr == S_OK);
        Q_UNUSED(hr)
    }

    ComVariant(const ComVariant &src) : ComVariant() { copy(&src); }
    ComVariant(const VARIANT &src) noexcept : ComVariant() { copy(&src); }

    template<typename T>
    ComVariant(const T &value) : ComVariant()
    {
        assign(value);
    }

    ComVariant &operator=(const ComVariant &rhs) noexcept
    {
        if (this == &rhs)
            return *this;

        clear();
        copy(&rhs);

        return *this;
    }

    template<typename T>
    ComVariant &operator=(const T &rhs)
    {
        assign(rhs);
        return *this;
    }

    void clear()
    {
        const HRESULT hr = ::VariantClear(this);

        Q_ASSERT(hr == S_OK);
        Q_UNUSED(hr)
    }

    void copy(const VARIANT *src)
    {
        vt = VT_EMPTY;
        const HRESULT hr = ::VariantCopy(this, const_cast<VARIANT *>(src));

        Q_ASSERT(hr == S_OK);
        Q_UNUSED(hr)
    }

    bool operator==(const ComVariant &rhs) const
    {
        auto *lhs = const_cast<tagVARIANT *>(static_cast<const tagVARIANT *>(this));
        auto *other = const_cast<tagVARIANT *>(static_cast<const tagVARIANT *>(&rhs));
        return compare(lhs, other, LOCALE_USER_DEFAULT, 0) == static_cast<HRESULT>(VARCMP_EQ);
    }

private:
    template<typename T>
    void assign(const T &value)
    {
        constexpr VARTYPE valueType = ValueType<T>();
        static_assert(valueType != VT_EMPTY, "Invalid type for ComVariant");

        vt = valueType;

        constexpr auto VARIANT::*field = ValueField<T>();
        if constexpr (valueType == VT_BSTR)
            this->*field = ComBstr{ value }.copy();
        else
            this->*field = value;

        if constexpr (valueType == VT_UNKNOWN || valueType == VT_DISPATCH)
            value->AddRef();
    }

    static HRESULT compare(VARIANT *lhs, VARIANT *rhs, LCID lcid, ULONG flags)
    {
        // Workaround missing support for VT_I1, VT_UI2, VT_UI4 and VT_UI8 in VarCmp
        switch (lhs->vt) {
        case VT_I1:
            if (lhs->cVal == rhs->cVal)
                return VARCMP_EQ;
            return lhs->cVal > rhs->cVal ? VARCMP_GT : VARCMP_LT;
        case VT_UI2:
            if (lhs->uiVal == rhs->uiVal)
                return VARCMP_EQ;
            return lhs->uiVal > rhs->uiVal ? VARCMP_GT : VARCMP_LT;
        case VT_UI4:
            if (lhs->uintVal == rhs->uintVal)
                return VARCMP_EQ;
            return lhs->uintVal > rhs->uintVal ? VARCMP_GT : VARCMP_LT;
        case VT_UI8:
            if (lhs->ullVal == rhs->ullVal)
                return VARCMP_EQ;
            return lhs->ullVal > rhs->ullVal ? VARCMP_GT : VARCMP_LT;
        }
        return ::VarCmp(lhs, rhs, lcid, flags);
    }
};

#endif