propertyindex.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (C) 2013 swift Project Community / Contributors
// SPDX-License-Identifier: GPL-3.0-or-later OR LicenseRef-swift-pilot-client-1
 
 
#ifndef SWIFT_MISC_PROPERTYINDEX_H
#define SWIFT_MISC_PROPERTYINDEX_H
 
#include <initializer_list>
#include <type_traits>
 
#include <QList>
#include <QMetaType>
#include <QString>
 
#include "misc/metaclass.h"
#include "misc/mixin/mixincompare.h"
#include "misc/mixin/mixindatastream.h"
#include "misc/mixin/mixindbus.h"
#include "misc/mixin/mixinhash.h"
#include "misc/mixin/mixinjson.h"
#include "misc/mixin/mixinmetatype.h"
#include "misc/mixin/mixinstring.h"
#include "misc/propertyindexref.h"
#include "misc/swiftmiscexport.h"
#include "misc/typetraits.h"
 
namespace swift::misc
{
    class SWIFT_MISC_EXPORT CPropertyIndex :
        public mixin::MetaType<CPropertyIndex>,
        public mixin::HashByMetaClass<CPropertyIndex>,
        public mixin::DBusByMetaClass<CPropertyIndex>,
        public mixin::DataStreamByMetaClass<CPropertyIndex>,
        public mixin::JsonOperators<CPropertyIndex>,
        public mixin::EqualsByMetaClass<CPropertyIndex>,
        public mixin::LessThanByMetaClass<CPropertyIndex>,
        public mixin::CompareByMetaClass<CPropertyIndex>,
        public mixin::String<CPropertyIndex>
    {
        // In the first trial I have used CSequence<int> as base class. This has created too much circular dependencies
        // of the headers CIndexVariantMap is used in CValueObject, CPropertyIndex in CIndexVariantMap
 
    public:
        CPropertyIndex() = default;
 
        CPropertyIndex(int singleProperty);
 
        CPropertyIndex(std::initializer_list<int> il);
 
        CPropertyIndex(const QList<int> &indexes);
 
        CPropertyIndex(const QString &indexes);
 
        operator CPropertyIndexRef() const;
 
        Q_REQUIRED_RESULT CPropertyIndex copyFrontRemoved() const;
 
        bool isNested() const;
 
        bool isMyself() const;
 
        bool isEmpty() const;
 
        QList<int> indexList() const;
 
        void prepend(int newLeftIndex);
 
        bool contains(int index) const;
 
        template <class EnumType>
        bool contains(EnumType ev) const
        {
            static_assert(std::is_enum_v<EnumType>, "Argument must be an enum");
            return this->contains(static_cast<int>(ev));
        }
 
        int frontToInt() const;
 
        bool startsWith(int index) const;
 
        template <class CastType>
        CastType frontCasted() const
        {
            static_assert(std::is_enum_v<CastType> || std::is_integral_v<CastType>,
                          "CastType must be an enum or integer");
            return static_cast<CastType>(frontToInt());
        }
 
        template <class EnumType>
        bool startsWithPropertyIndexEnum(EnumType ev) const
        {
            static_assert(std::is_enum_v<EnumType>, "Argument must be an enum");
            return this->startsWith(static_cast<int>(ev));
        }
 
        auto comparator() const
        {
            return [index = *this](const auto &a, const auto &b) {
                using T = std::decay_t<decltype(a)>;
                if constexpr (THasComparePropertyByIndex<T>::value) { return a.comparePropertyByIndex(index, b); }
                else if constexpr (THasPropertyByIndex<T>::value)
                {
                    return compare(a.propertyByIndex(index), b.propertyByIndex(index));
                }
                else
                {
                    qFatal("Not implemented");
                    return 0;
                }
            };
        }
 
        QString convertToQString(bool i18n = false) const;
 
        QJsonObject toJson() const;
 
        void convertFromJson(const QJsonObject &json);
 
        static const CPropertyIndex &empty()
        {
            static const CPropertyIndex pi;
            return pi;
        }
 
    protected:
        void parseFromString(const QString &indexes);
 
    private:
        QList<int> m_indexes;
 
        SWIFT_METACLASS(
            CPropertyIndex,
            SWIFT_METAMEMBER(indexes));
    };
} // namespace swift::misc
 
Q_DECLARE_METATYPE(swift::misc::CPropertyIndex)
 
#endif // SWIFT_MISC_PROPERTYINDEX_H