metaclass.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (C) 2016 swift Project Community / Contributors
// SPDX-License-Identifier: GPL-3.0-or-later OR LicenseRef-swift-pilot-client-1
 
 
#ifndef SWIFT_MISC_METACLASS_H
#define SWIFT_MISC_METACLASS_H
 
#include <functional>
#include <type_traits>
 
#include <QHash>
#include <QLatin1String>
#include <QString>
 
#include "misc/invoke.h"
#include "misc/tuple.h"
 
 
// Work around MinGW problem with combination of constexpr and extern template
#if defined(Q_OS_WIN) && defined(Q_CC_GNU)
#    define SWIFT_NO_EXPORT_CONSTEXPR constexpr inline __attribute__((always_inline))
#else
#    define SWIFT_NO_EXPORT_CONSTEXPR constexpr
#endif
 
// MSVC, GCC, Clang all have non-standard extensions for skipping trailing
// commas in variadic macros, but the MSVC extension differs from the others.
#ifdef Q_CC_MSVC
#    define SWIFT_TRAILING_VA_ARGS(...) , __VA_ARGS__
#else
#    define SWIFT_TRAILING_VA_ARGS(...) , ##__VA_ARGS__
#endif
 
 
#define SWIFT_METACLASS(CLASS, ...)                                                                                    \
    friend struct swift::misc::private_ns::CMetaClassAccessor;                                                         \
    struct MetaClass : public swift::misc::CMetaClass                                                                  \
    {                                                                                                                  \
        using Class = CLASS;                                                                                           \
        SWIFT_NO_EXPORT_CONSTEXPR static auto getMemberList() { return makeMetaMemberList(__VA_ARGS__); }              \
    }
 
#define SWIFT_METAMEMBER(MEMBER, ...) makeMetaMember(&Class::m_##MEMBER, #MEMBER SWIFT_TRAILING_VA_ARGS(__VA_ARGS__))
 
#define SWIFT_METAMEMBER_NAMED(MEMBER, NAME, ...)                                                                      \
    makeMetaMember(&Class::m_##MEMBER, NAME SWIFT_TRAILING_VA_ARGS(__VA_ARGS__))
 
inline size_t qHash(const std::string &key, uint seed) { return qHash(QString::fromStdString(key), seed); }
 
inline size_t qHash(const std::string &key) { return qHash(QString::fromStdString(key)); }
 
namespace swift::misc
{
    class CVariant;
 
    struct CExplicitLatin1String
    {
        const QLatin1String m_latin1;
 
        constexpr CExplicitLatin1String(QLatin1String s) : m_latin1(s) {}
 
        constexpr operator QLatin1String() const { return m_latin1; }
    };
 
    template <quint64 F>
    struct MetaFlags : public std::integral_constant<quint64, F>
    {
        constexpr operator std::bool_constant<static_cast<bool>(F)>() const { return {}; }
    };
 
    template <quint64 A, quint64 B>
    constexpr MetaFlags<A | B> operator|(MetaFlags<A>, MetaFlags<B>)
    {
        return {};
    }
 
    template <quint64 A, quint64 B>
    constexpr MetaFlags<A & B> operator&(MetaFlags<A>, MetaFlags<B>)
    {
        return {};
    }
 
    template <typename M, quint64 Flags>
    struct CMetaMember
    {
        const M m_ptr;
 
        const char *const m_name;
 
        const int m_index;
 
        const MetaFlags<Flags> m_flags;
 
        template <typename Flags2>
        static constexpr bool has(Flags2 flags)
        {
            return (MetaFlags<Flags>() & flags) == flags;
        }
 
        template <typename T, typename... Ts>
        decltype(auto) in(T &&object, Ts &&...args) const
        {
            return std::invoke(m_ptr, std::forward<T>(object), std::forward<Ts>(args)...);
        }
 
        constexpr auto latin1Name() const { return QLatin1String(m_name); }
    };
 
    template <typename... Members>
    struct CMetaMemberList
    {
        const private_ns::tuple<Members...> m_members;
 
        static constexpr size_t c_size = sizeof...(Members);
    };
 
    enum MetaFlag
    {
        DisabledForComparison = 1 << 0, 
        DisabledForMarshalling = 1 << 1, 
        DisabledForDebugging = 1 << 2, 
        DisabledForHashing = 1 << 3, 
        DisabledForJson = 1 << 4, 
        CaseInsensitiveComparison = 1 << 5, 
        LosslessMarshalling = 1 << 6, 
        RequiredForJson = 1 << 7 
    };
 
    class CMetaClass
    {
    protected:
        constexpr static MetaFlags<MetaFlag::DisabledForComparison> DisabledForComparison {};
        constexpr static MetaFlags<MetaFlag::DisabledForMarshalling> DisabledForMarshalling {};
        constexpr static MetaFlags<MetaFlag::DisabledForDebugging> DisabledForDebugging {};
        constexpr static MetaFlags<MetaFlag::DisabledForHashing> DisabledForHashing {};
        constexpr static MetaFlags<MetaFlag::DisabledForJson> DisabledForJson {};
        constexpr static MetaFlags<MetaFlag::CaseInsensitiveComparison> CaseInsensitiveComparison {};
        constexpr static MetaFlags<MetaFlag::LosslessMarshalling> LosslessMarshalling {};
        constexpr static MetaFlags<MetaFlag::RequiredForJson> RequiredForJson {};
 
        template <typename... Members>
        constexpr static CMetaMemberList<Members...> makeMetaMemberList(Members... members)
        {
            return { { { { members }... } } };
        }
 
        template <typename M, quint64 Flags = 0>
        constexpr static CMetaMember<M, Flags> makeMetaMember(M ptrToMember, const char *name = nullptr, int index = 0,
                                                              MetaFlags<Flags> flags = {})
        {
            static_assert(std::is_member_object_pointer_v<M>, "M must be a pointer to member object");
            return { ptrToMember, name, index, flags };
        }
    };
 
    template <typename MetaClass>
    class CMetaClassIntrospector
    {
    public:
        template <typename F>
        static void forEachMember(F &&visitor)
        {
            MetaClass::getMemberList().m_members.for_each(std::forward<F>(visitor));
        }
    };
 
    namespace private_ns
    {
        struct CMetaClassAccessor
        {
            template <typename T>
            constexpr static auto getIntrospector()
            {
                return CMetaClassIntrospector<typename T::MetaClass>();
            }
        };
    } // namespace private_ns
 
    template <typename T>
    constexpr auto introspect()
    {
        return private_ns::CMetaClassAccessor::getIntrospector<T>();
    }
 
} // namespace swift::misc
 
#endif // SWIFT_MISC_METACLASS_H