range.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_RANGE_H
#define SWIFT_MISC_RANGE_H
 
#include <algorithm>
#include <iterator>
#include <type_traits>
 
#include <QDebug>
#include <QtGlobal>
 
#include "misc/algorithm.h"
#include "misc/iterator.h"
#include "misc/predicates.h"
#include "misc/typetraits.h"
 
namespace swift::misc
{
    template <class>
    class CRange;
 
    template <class Derived>
    class CRangeBase
    {
    public:
        template <class F>
        inline auto transform(F function) const;
 
        template <class Predicate>
        inline auto findBy(Predicate p) const;
 
        template <class K0, class V0, class... KeysValues>
        inline auto findBy(K0 k0, V0 v0, KeysValues... keysValues) const;
 
        template <class Predicate>
        const auto &findFirstBy(Predicate p) const
        {
            return findBy(p).front();
        }
 
        template <class K, class V>
        const auto &findFirstBy(K key, V value) const
        {
            return findBy(key, value).front();
        }
 
        template <class Predicate, class Value>
        auto findFirstByOrDefault(Predicate p, const Value &def) const
        {
            return findBy(p).frontOrDefault(def);
        }
 
        template <class Predicate>
        auto findFirstByOrDefault(Predicate p) const
        {
            return findBy(p).frontOrDefault();
        }
 
        template <class K, class V, class Value>
        auto findFirstByOrDefault(K key, V value, const Value &def) const
        {
            return findBy(key, value).frontOrDefault(def);
        }
 
        template <class T, class K, class V>
        auto findFirstByOrDefault(K T::*key, V value) const
        {
            return findBy(key, value).frontOrDefault();
        }
 
        template <class Predicate>
        bool containsBy(Predicate p) const
        {
            return std::any_of(derived().cbegin(), derived().cend(), p);
        }
 
        template <class T>
        bool contains(const T &object) const
        {
            return derived().find(object) != derived().cend();
        }
 
        template <class K0, class V0, class... KeysValues>
        bool contains(K0 k0, V0 v0, KeysValues... keysValues) const
        {
            return containsBy(swift::misc::predicates::MemberEqual(k0, v0, keysValues...));
        }
 
        template <class T, class Predicate>
        bool equalsBy(const T &other, Predicate c) const
        {
            if (equalPointers(&derived(), &other)) { return true; }
            return std::equal(derived().begin(), derived().end(), other.begin(), other.end(), c);
        }
 
        template <class T, class Key0, class... Keys>
        bool equalsByKeys(const T &other, Key0 k0, Keys... keys) const
        {
            return equalsBy(other, swift::misc::predicates::EqualsByMembers(k0, keys...));
        }
 
        template <class T>
        T randomElement() const
        {
            return this->randomElements(1).front();
        }
 
        Derived randomElements(int n) const
        {
            Derived result;
            swift::misc::copyRandomElements(derived().begin(), derived().end(), std::inserter(result, result.end()), n);
            return result;
        }
 
        Derived sampleElements(int n) const
        {
            Derived result;
            swift::misc::copySampleElements(derived().begin(), derived().end(), std::inserter(result, result.end()), n);
            return result;
        }
 
    protected:
        template <typename T, typename U>
        static bool equalPointers(const T *a, const U *b)
        {
            if constexpr (TIsEqualityComparable<const T *, const U *>::value) { return a == b; }
            else { return false; }
        }
 
    private:
        Derived &derived() { return static_cast<Derived &>(*this); }
        const Derived &derived() const { return static_cast<const Derived &>(*this); }
    };
 
    template <class I>
    class CRange : public CRangeBase<CRange<I>>
    {
    public:
        typedef typename std::iterator_traits<I>::value_type value_type;
        typedef typename std::iterator_traits<I>::reference reference;
        typedef typename std::iterator_traits<I>::difference_type difference_type;
        typedef const value_type &const_reference;
        typedef value_type key_type;
        typedef difference_type size_type;
        typedef I iterator;
        typedef I const_iterator;
        typedef std::reverse_iterator<I> reverse_iterator;
        typedef std::reverse_iterator<I> const_reverse_iterator;
 
        CRange(I begin, I end) : m_begin(begin), m_end(end) { check(&begin, &end); }
 
        const_iterator begin() const { return m_begin; }
        const_iterator cbegin() const { return m_begin; }
        const_iterator end() const { return m_end; }
        const_iterator cend() const { return m_end; }
 
        const_reverse_iterator rbegin() const { return const_reverse_iterator(m_end); }
        const_reverse_iterator crbegin() const { return const_reverse_iterator(m_end); }
        const_reverse_iterator rend() const { return const_reverse_iterator(m_begin); }
        const_reverse_iterator crend() const { return const_reverse_iterator(m_begin); }
 
        CRange<const_reverse_iterator> reverse() const
        {
            static_assert(std::is_same_v<decltype(*rbegin()), decltype(*begin())>, "");
            return { rbegin(), rend() };
        }
 
        template <class T, class = std::enable_if_t<std::is_convertible_v<value_type, typename T::value_type>>>
        operator T() const
        {
            return to<T>();
        }
 
        template <class T>
        T to() const
        {
            T container;
            std::copy(begin(), end(), Iterators::makeInsertIterator(container));
            return container;
        }
        template <template <class...> class T>
        auto to() const
        {
            return to<T<value_type>>();
        }
 
        bool empty() const { return begin() == end(); }
        bool isEmpty() const { return empty(); }
 
        size_type size() const { return std::distance(begin(), end()); }
 
        const_reference front() const
        {
            Q_ASSERT(!empty());
            return *begin();
        }
 
        const_reference frontOrDefault() const
        {
            static const value_type def {};
            return empty() ? def : *begin();
        }
 
        value_type frontOrDefault(value_type def) const { return empty() ? def : *begin(); }
 
    private:
        I m_begin;
        I m_end;
 
        void check(...) {}
        template <class I2, class F>
        void check(Iterators::ConditionalIterator<I2, F> *begin, Iterators::ConditionalIterator<I2, F> *end)
        {
            begin->checkEnd(*end);
        }
    };
 
 
    template <class I>
    QDebug operator<<(QDebug d, const CRange<I> &range)
    {
        for (const auto &v : range) { d << v; }
        return d;
    }
    template <class I>
    QNoDebug operator<<(QNoDebug d, const CRange<I> &)
    {
        return d;
    }
 
    template <class I, class I2>
    auto makeRange(I begin, I2 end) -> CRange<I>
    {
        return { begin, static_cast<I>(end) };
    }
 
 
    template <class T>
    auto makeRange(T &container) -> CRange<decltype(container.begin())>
    {
        return { container.begin(), container.end() };
    }
    template <class T>
    auto makeRange(const T &container) -> CRange<decltype(container.begin())>
    {
        return { container.begin(), container.end() };
    }
 
    template <class T>
    auto makeConstRange(const T &container) -> CRange<decltype(container.cbegin())>
    {
        return { container.cbegin(), container.cend() };
    }
 
 
    template <class T>
    auto makeKeysRange(const T &container)
    {
        return makeRange(container.keyBegin(), container.keyEnd());
    }
    template <class T>
    void makeKeysRange(T &container)
    {
        container.detach(); // http://doc.qt.io/qt-5/containers.html#implicit-sharing-iterator-problem
        return makeRange(container.keyValueBegin(), container.keyValueEnd());
    }
 
 
    template <class T>
    auto makePairsRange(const T &container)
    {
        return makeRange(container.keyValueBegin(), container.keyValueEnd());
    }
    template <class T>
    auto makePairsRange(T &container)
    {
        container.detach(); // http://doc.qt.io/qt-5/containers.html#implicit-sharing-iterator-problem
        return makeRange(container.keyValueBegin(), container.keyValueEnd());
    }
 
    template <class T>
    void makeKeysRange(const T &&container) = delete;
 
    template <class T>
    void makePairsRange(const T &&container) = delete;
 
    /*
     * Member functions of CRangeBase template defined out of line, because they depend on CRange etc.
     */
    template <class Derived>
    template <class F>
    auto CRangeBase<Derived>::transform(F function) const
    {
        return makeRange(Iterators::makeTransformIterator(derived().cbegin(), function), derived().cend());
    }
 
    template <class Derived>
    template <class Predicate>
    auto CRangeBase<Derived>::findBy(Predicate p) const
    {
        return makeRange(Iterators::makeConditionalIterator(derived().cbegin(), derived().cend(), p), derived().cend());
    }
 
    template <class Derived>
    template <class K0, class V0, class... KeysValues>
    auto CRangeBase<Derived>::findBy(K0 k0, V0 v0, KeysValues... keysValues) const
    {
        return findBy(swift::misc::predicates::MemberEqual(k0, v0, keysValues...));
    }
 
} // namespace swift::misc
 
#endif // SWIFT_MISC_RANGE_H