File Coverage

/usr/local/lib/perl5/site_perl/5.26.1/XS/librangeV3.x/i/range/v3/iterator_range.hpp

Criterion	Covered	Total	%
statement	3	3	100.0
branch			n/a
condition			n/a
subroutine			n/a
pod			n/a
total	3	3	100.0

/// \file
// Range v3 library
//
//  Copyright Eric Niebler 2013-present
//
//  Use, modification and distribution is subject to the
//  Boost Software License, Version 1.0. (See accompanying
//  file LICENSE_1_0.txt or copy at
//  http://www.boost.org/LICENSE_1_0.txt)
//
// Project home: https://github.com/ericniebler/range-v3
//

#ifndef RANGES_V3_ITERATOR_RANGE_HPP
#define RANGES_V3_ITERATOR_RANGE_HPP

#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include

namespace ranges
{
    inline namespace v3
    {
        /// \addtogroup group-core
        /// @{
        template
        struct RANGES_EMPTY_BASES iterator_range
          : tagged_compressed_tuple
          , view_interface>
        {
        private:
            using base_t = tagged_compressed_tuple;
        public:
            using iterator = I;
            using sentinel = S;
        #ifndef RANGES_DOXYGEN_INVOKED
            using const_iterator = I; // Mostly to avoid spurious errors in Boost.Range
        #endif

            using base_t::begin;
            using base_t::end;

            iterator_range() = default;
            constexpr iterator_range(I begin, S end)
              : base_t{detail::move(begin), detail::move(end)}
            {}
            template
                CONCEPT_REQUIRES_(Constructible() && Constructible())>
            constexpr iterator_range(iterator_range rng)
              : base_t{detail::move(rng.begin()), detail::move(rng.end())}
            {}
            template
                CONCEPT_REQUIRES_(Constructible() && Constructible())>
            explicit constexpr iterator_range(std::pair rng)
              : base_t{detail::move(rng.first), detail::move(rng.second)}
            {}
            template
                CONCEPT_REQUIRES_(Assignable() && Assignable())>
            iterator_range &operator=(iterator_range rng)
            {
                begin() = detail::move(rng).begin();
                end() = detail::move(rng).end();
                return *this;
            }
            template
                CONCEPT_REQUIRES_(ConvertibleTo() && ConvertibleTo())>
            constexpr operator std::pair() const
            {
                return {begin(), end()};
            }
            constexpr bool empty() const
            {
                return begin() == end();
            }
        };

        // Like iterator_range, but with a known size. The first and second members
        // are private to prevent inadvertent violations of the class invariant.
        //
        // Class invariant:
        //   distance(begin(), end()) == size()
        //
        template
        struct sized_iterator_range
          : view_interface>
        {
        private:
            template
            friend struct sized_iterator_range;
            iterator_range rng_;
            size_type_t size_;
        public:
            using iterator = I;
            using sentinel = S;
        #ifndef RANGES_DOXYGEN_INVOKED
            using const_iterator = I; // Mostly to avoid spurious errors in Boost.Range
        #endif

            sized_iterator_range() = default;
            RANGES_NDEBUG_CONSTEXPR sized_iterator_range(I begin, S end, size_type_t size)
              : rng_{detail::move(begin), detail::move(end)}, size_(size)
            {
            #ifndef NDEBUG
                RANGES_ASSERT(!ForwardIterator() ||
                    static_cast>(ranges::distance(rng_)) == size_);
            #endif
            }
            template
                CONCEPT_REQUIRES_(Constructible() && Constructible())>
            RANGES_NDEBUG_CONSTEXPR sized_iterator_range(std::pair rng, size_type_t size)
              : sized_iterator_range{detail::move(rng).first, detail::move(rng).second, size}
            {}
            template
                CONCEPT_REQUIRES_(Constructible() && Constructible())>
            RANGES_NDEBUG_CONSTEXPR sized_iterator_range(iterator_range rng, size_type_t size)
              : sized_iterator_range{detail::move(rng).first(), detail::move(rng).second, size}
            {}
            template
                CONCEPT_REQUIRES_(Constructible() && Constructible())>
            RANGES_NDEBUG_CONSTEXPR sized_iterator_range(sized_iterator_range rng)
              : sized_iterator_range{detail::move(rng).rng_.first(), detail::move(rng).rng_.second, rng.size_}
            {}
            template
                CONCEPT_REQUIRES_(Assignable() && Assignable())>
            sized_iterator_range &operator=(sized_iterator_range rng)
            {
                rng_ = detail::move(rng).rng_;
                size_ = rng.size_;
                return *this;
            }
            I begin() const
            {
                return rng_.begin();
            }
            S end() const
            {
                return rng_.end();
            }
            size_type_t size() const
            {
                return size_;
            }
            template
                CONCEPT_REQUIRES_(ConvertibleTo() && ConvertibleTo())>
            constexpr operator std::pair() const
            {
                return rng_;
            }
            template
                CONCEPT_REQUIRES_(ConvertibleTo() && ConvertibleTo())>
            constexpr operator iterator_range() const
            {
                return rng_;
            }
            constexpr operator iterator_range const &() const & noexcept
            {
                return rng_;
            }
        };

        struct make_iterator_range_fn
        {
            /// \return `{begin, end}`
            template
                CONCEPT_REQUIRES_(Sentinel())>
            constexpr iterator_range operator()(I begin, S end) const
            {
                CONCEPT_ASSERT(Sentinel());
                return {detail::move(begin), detail::move(end)};
            }

            /// \return `{begin, end, size}`
            template
                CONCEPT_REQUIRES_(Sentinel())>
            constexpr sized_iterator_range operator()(I begin, S end, size_type_t size) const
            {
                CONCEPT_ASSERT(Sentinel());
                return {detail::move(begin), detail::move(end), size};
            }
        };

        /// \ingroup group-core
        /// \sa `make_iterator_range_fn`
        RANGES_INLINE_VARIABLE(make_iterator_range_fn, make_iterator_range)

        /// Tuple-like access for `sized_iterator_range`
        template
            CONCEPT_REQUIRES_(N < 2)>
        constexpr auto get(sized_iterator_range const &p)
        RANGES_DECLTYPE_AUTO_RETURN
        (
            ranges::get(static_cast const &>(p))
        )

        /// \overload
        template
            CONCEPT_REQUIRES_(N == 2)>
        constexpr size_type_t get(sized_iterator_range const &p)
        {
            return p.size();
        }


        // TODO add specialization of range_cardinality for when we can determine the range is infinite

        /// @}
    }
}

// The standard is inconsistent about whether these are classes or structs
RANGES_DIAGNOSTIC_PUSH
RANGES_DIAGNOSTIC_IGNORE_MISMATCHED_TAGS

/// \cond
namespace std
{
    template
    struct tuple_size< ::ranges::v3::iterator_range>
      : std::integral_constant
    {};

    template
    struct tuple_element<0, ::ranges::v3::iterator_range>
    {
        using type = I;
    };

    template
    struct tuple_element<1, ::ranges::v3::iterator_range>
    {
        using type = S;
    };

    template
    struct tuple_size< ::ranges::v3::sized_iterator_range>
      : std::integral_constant
    {};

    template
    struct tuple_element<0, ::ranges::v3::sized_iterator_range>
    {
        using type = I;
    };

    template
    struct tuple_element<1, ::ranges::v3::sized_iterator_range>
    {
        using type = S;
    };

    template
    struct tuple_element<2, ::ranges::v3::sized_iterator_range>
    {
        using type = ::ranges::v3::size_type_t;
    };
}
/// \endcond

RANGES_DIAGNOSTIC_POP

#endif