typetraits.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_TYPETRAITS_H
#define SWIFT_MISC_TYPETRAITS_H
 
#include <type_traits>
#include <utility> // for std::swap
 
class QDBusArgument;
 
namespace swift::misc
{
 
    class CPropertyIndexRef;
 
    namespace private_ns
    {
        template <typename T, bool = std::is_class_v<T>>
        struct SyntheticDerived : public T
        {};
        template <typename T>
        struct SyntheticDerived<T, false>
        {};
    } // namespace private_ns

    enum class ParameterPassBy
    {
        Value,
        ConstRef
    };

    template <typename T>
    struct TParameter
    {
        static constexpr ParameterPassBy passBy =
            (sizeof(T) <= 16 && std::is_trivially_copy_constructible_v<T> && std::is_trivially_destructible_v<T>) ?
                ParameterPassBy::Value :
                ParameterPassBy::ConstRef;
    };

    template <typename T, typename = std::void_t<>>
    struct THasToQString : public std::false_type
    {};

    template <typename T>
    struct THasToQString<T, std::void_t<decltype(std::declval<T>().toQString())>> : public std::true_type
    {};

    template <typename T, typename = std::void_t<>>
    struct THasPushBack : public std::false_type
    {};

    template <typename T>
    struct THasPushBack<T, std::void_t<decltype(std::declval<T>().push_back(std::declval<typename T::value_type>()))>> :
        public std::true_type
    {};

    template <typename T, typename = std::void_t<>>
    struct THasGetLogCategories : public std::false_type
    {};

    template <typename T>
    struct THasGetLogCategories<T, std::void_t<decltype(T::getLogCategories())>> : public std::true_type
    {};

    template <typename T, typename = std::void_t<>>
    struct TModelsQHashKey : public std::false_type
    {};

    template <typename T>
    struct TModelsQHashKey<T, std::void_t<decltype(std::declval<T>() == std::declval<T>(), qHash(std::declval<T>()))>> :
        public std::true_type
    {};

    template <typename T, typename = std::void_t<>>
    struct TModelsQMapKey : public std::false_type
    {};

    template <typename T>
    struct TModelsQMapKey<T, std::void_t<decltype(std::declval<T>() < std::declval<T>())>> : public std::true_type
    {};

    template <typename T, typename U, typename = std::void_t<>>
    struct THasCompare : public std::false_type
    {};

    template <typename T, typename U>
    struct THasCompare<T, U, std::void_t<decltype(compare(std::declval<T>(), std::declval<U>()))>> :
        public std::true_type
    {};

    template <typename T, typename = std::void_t<>>
    struct THasComparePropertyByIndex : public std::false_type
    {};

    template <typename T>
    struct THasComparePropertyByIndex<T, std::void_t<decltype(std::declval<T>().comparePropertyByIndex(
                                             std::declval<CPropertyIndexRef>(), std::declval<const T &>()))>> :
        public std::true_type
    {};

    template <typename T, typename = std::void_t<>>
    struct THasPropertyByIndex : public std::false_type
    {};

    template <typename T>
    struct THasPropertyByIndex<
        T, std::void_t<decltype(std::declval<T>().propertyByIndex(std::declval<CPropertyIndexRef>()))>> :
        public std::true_type
    {};

    template <typename T, typename U, typename = std::void_t<>>
    struct TIsEqualityComparable : public std::false_type
    {};

    template <typename T, typename U>
    struct TIsEqualityComparable<T, U, std::void_t<decltype(std::declval<T>() == std::declval<U>())>> :
        public std::true_type
    {};

    template <typename T, typename = std::void_t<>>
    struct THasMarshallMethods : public std::false_type
    {};

    template <typename T>
    struct THasMarshallMethods<
        T, std::void_t<decltype(std::declval<const T &>().marshallToDbus(std::declval<QDBusArgument &>()),
                                std::declval<T &>().unmarshallFromDbus(std::declval<const QDBusArgument &>()))>> :
        public std::true_type
    {};

    template <typename T, typename = std::void_t<>>
    struct TIsQPrivateSignal : public std::false_type
    {};

    template <typename T>
    struct TIsQPrivateSignal<T, std::void_t<typename private_ns::SyntheticDerived<T>::QPrivateSignal>> :
        public std::is_same<T, typename private_ns::SyntheticDerived<T>::QPrivateSignal>
    {};
 
} // namespace swift::misc
 
#endif // SWIFT_MISC_TYPETRAITS_H