File Coverage

/usr/local/lib/perl5/site_perl/5.26.1/XS/librangeV3.x/i/range/v3/view_interface.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 2014-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_VIEW_INTERFACE_HPP
#define RANGES_V3_VIEW_INTERFACE_HPP

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

namespace ranges
{
    inline namespace v3
    {
        /// \cond
        namespace detail
        {
            template
            struct slice_bounds
            {
                From from;
                To to;
                template
                    CONCEPT_REQUIRES_(ConvertibleTo() && ConvertibleTo())>
                constexpr slice_bounds(F from, T to)
                  : from(from), to(to)
                {}
            };

            template
            struct from_end_
            {
                Int dist_;

                template
                    CONCEPT_REQUIRES_(Integral() && ExplicitlyConvertibleTo())>
                constexpr operator from_end_ () const
                {
                    return {static_cast(dist_)};
                }
            };
        }
        /// \endcond

        /// \addtogroup group-core
        /// @{
        template
        struct view_interface
          : basic_view
        {
        protected:
            RANGES_CXX14_CONSTEXPR Derived &derived() noexcept
            {
                CONCEPT_ASSERT(DerivedFrom());
                return static_cast(*this);
            }
            /// \overload
            constexpr Derived const &derived() const noexcept
            {
                CONCEPT_ASSERT(DerivedFrom());
                return static_cast(*this);
            }
            ~view_interface() = default;
        public:
            view_interface() = default;
            view_interface(view_interface &&) = default;
            view_interface(view_interface const &) = default;
            view_interface &operator=(view_interface &&) = default;
            view_interface &operator=(view_interface const &) = default;
            // A few ways of testing whether a range can be empty:
            CONCEPT_REQUIRES(Cardinality >= 0 || Cardinality == infinite)
            constexpr bool empty() const noexcept
            {
                return Cardinality == 0;
            }
            template
                CONCEPT_REQUIRES_(Same() &&
                    Cardinality < 0 && Cardinality != infinite &&
                    ForwardRange())>
            RANGES_CXX14_CONSTEXPR bool empty()
                noexcept(noexcept(bool(ranges::begin(std::declval()) ==
                    ranges::end(std::declval()))))
            {
                return ranges::begin(derived()) == ranges::end(derived());
            }
            template
                CONCEPT_REQUIRES_(Same() &&
                    Cardinality < 0 && Cardinality != infinite &&
                    ForwardRange())>
            constexpr bool empty() const
                noexcept(noexcept(bool(ranges::begin(std::declval()) ==
                    ranges::end(std::declval()))))
            {
                return ranges::begin(derived()) == ranges::end(derived());
            }
            template())>
            constexpr auto operator!() const
            RANGES_DECLTYPE_NOEXCEPT(ranges::empty(std::declval()))
            {
                return ranges::empty(derived());
            }
            template()),
                typename = decltype(ranges::empty(std::declval()))>
            constexpr explicit operator bool() const
                noexcept(noexcept(ranges::empty(std::declval())))
            {
                return !ranges::empty(derived());
            }
            /// Access the size of the range, if it can be determined:
            template
                CONCEPT_REQUIRES_(Same() && Cardinality >= 0)>
            constexpr range_size_type_t size() const noexcept
            {
                return (range_size_type_t)Cardinality;
            }
            template
                CONCEPT_REQUIRES_(Same() && Cardinality < 0 &&
                    SizedSentinel, iterator_t>() &&
                    ForwardRange())>
            constexpr range_size_type_t size() const
            {
                return iter_size(derived().begin(), derived().end());
            }
            template
                CONCEPT_REQUIRES_(Same() && Cardinality < 0 &&
                    SizedSentinel, iterator_t>() &&
                    ForwardRange())>
            RANGES_CXX14_CONSTEXPR range_size_type_t size()
            {
                return iter_size(derived().begin(), derived().end());
            }
            /// Access the first element in a range:
            template
                CONCEPT_REQUIRES_(Same() && ForwardRange())>
            RANGES_CXX14_CONSTEXPR range_reference_t front()
            {
                return *derived().begin();
            }
            /// \overload
            template
                CONCEPT_REQUIRES_(Same() && ForwardRange())>
            constexpr range_reference_t front() const
            {
                return *derived().begin();
            }
            /// Access the last element in a range:
            template
                CONCEPT_REQUIRES_(Same() && BoundedRange() && BidirectionalRange())>
            RANGES_CXX14_CONSTEXPR range_reference_t back()
            {
                return *prev(derived().end());
            }
            /// \overload
            template
                CONCEPT_REQUIRES_(Same() && BoundedRange() && BidirectionalRange())>
            constexpr range_reference_t back() const
            {
                return *prev(derived().end());
            }
            /// Simple indexing:
            template
                CONCEPT_REQUIRES_(Same() && RandomAccessRange())>
            RANGES_CXX14_CONSTEXPR auto operator[](range_difference_type_t n) ->
                decltype(std::declval().begin()[n])
            {
                return derived().begin()[n];
            }
            /// \overload
            template
                CONCEPT_REQUIRES_(Same() && RandomAccessRange())>
            constexpr auto operator[](range_difference_type_t n) const ->
                decltype(std::declval().begin()[n])
            {
                return derived().begin()[n];
            }
            /// Python-ic slicing:
            //      rng[{4,6}]
            template
                CONCEPT_REQUIRES_(Same())>
            RANGES_CXX14_CONSTEXPR
            auto operator[](detail::slice_bounds> offs) & ->
                decltype(std::declval()(std::declval(), offs.from, offs.to))
            {
                return Slice{}(derived(), offs.from, offs.to);
            }
            /// \overload
            template
                CONCEPT_REQUIRES_(Same())>
            constexpr
            auto operator[](detail::slice_bounds> offs) const & ->
                decltype(std::declval()(std::declval(), offs.from, offs.to))
            {
                return Slice{}(derived(), offs.from, offs.to);
            }
            /// \overload
            template
                CONCEPT_REQUIRES_(Same())>
            RANGES_CXX14_CONSTEXPR
            auto operator[](detail::slice_bounds> offs) && ->
                decltype(std::declval()(std::declval(), offs.from, offs.to))
            {
                return Slice{}(detail::move(derived()), offs.from, offs.to);
            }
            //      rng[{4,end-2}]
            /// \overload
            template
                CONCEPT_REQUIRES_(Same())>
            RANGES_CXX14_CONSTEXPR
            auto operator[](detail::slice_bounds,
                detail::from_end_>> offs) & ->
                decltype(std::declval()(std::declval(), offs.from, offs.to))
            {
                return Slice{}(derived(), offs.from, offs.to);
            }
            /// \overload
            template
                CONCEPT_REQUIRES_(Same())>
            constexpr auto operator[](detail::slice_bounds,
                detail::from_end_>> offs) const & ->
                decltype(std::declval()(std::declval(), offs.from, offs.to))
            {
                return Slice{}(derived(), offs.from, offs.to);
            }
            /// \overload
            template
                CONCEPT_REQUIRES_(Same())>
            RANGES_CXX14_CONSTEXPR
            auto operator[](detail::slice_bounds,
                detail::from_end_>> offs) && ->
                decltype(std::declval()(std::declval(), offs.from, offs.to))
            {
                return Slice{}(detail::move(derived()), offs.from, offs.to);
            }
            //      rng[{end-4,end-2}]
            /// \overload
            template
                CONCEPT_REQUIRES_(Same())>
            RANGES_CXX14_CONSTEXPR
            auto operator[](detail::slice_bounds>,
                detail::from_end_>> offs) & ->
                decltype(std::declval()(std::declval(), offs.from, offs.to))
            {
                return Slice{}(derived(), offs.from, offs.to);
            }
            /// \overload
            template
                CONCEPT_REQUIRES_(Same())>
            constexpr
            auto operator[](detail::slice_bounds>,
                detail::from_end_>> offs) const & ->
                decltype(std::declval()(std::declval(), offs.from, offs.to))
            {
                return Slice{}(derived(), offs.from, offs.to);
            }
            /// \overload
            template
                CONCEPT_REQUIRES_(Same())>
            RANGES_CXX14_CONSTEXPR
            auto operator[](detail::slice_bounds>,
                detail::from_end_>> offs) && ->
                decltype(std::declval()(std::declval(), offs.from, offs.to))
            {
                return Slice{}(detail::move(derived()), offs.from, offs.to);
            }
            //      rng[{4,end}]
            /// \overload
            template
                CONCEPT_REQUIRES_(Same())>
            RANGES_CXX14_CONSTEXPR
            auto operator[](detail::slice_bounds, end_fn> offs) & ->
                decltype(std::declval()(std::declval(), offs.from, offs.to))
            {
                return Slice{}(derived(), offs.from, offs.to);
            }
            /// \overload
            template
                CONCEPT_REQUIRES_(Same())>
            constexpr
            auto operator[](detail::slice_bounds, end_fn> offs) const & ->
                decltype(std::declval()(std::declval(), offs.from, offs.to))
            {
                return Slice{}(derived(), offs.from, offs.to);
            }
            /// \overload
            template
                CONCEPT_REQUIRES_(Same())>
            RANGES_CXX14_CONSTEXPR
            auto operator[](detail::slice_bounds, end_fn> offs) && ->
                decltype(std::declval()(std::declval(), offs.from, offs.to))
            {
                return Slice{}(detail::move(derived()), offs.from, offs.to);
            }
            //      rng[{end-4,end}]
            /// \overload
            template
                CONCEPT_REQUIRES_(Same())>
            RANGES_CXX14_CONSTEXPR
            auto operator[](detail::slice_bounds>, end_fn> offs) & ->
                decltype(std::declval()(std::declval(), offs.from, offs.to))
            {
                return Slice{}(derived(), offs.from, offs.to);
            }
            /// \overload
            template
                CONCEPT_REQUIRES_(Same())>
            constexpr
            auto operator[](detail::slice_bounds>, end_fn> offs) const & ->
                decltype(std::declval()(std::declval(), offs.from, offs.to))
            {
                return Slice{}(derived(), offs.from, offs.to);
            }
            /// \overload
            template
                CONCEPT_REQUIRES_(Same())>
            RANGES_CXX14_CONSTEXPR
            auto operator[](detail::slice_bounds>, end_fn> offs) && ->
                decltype(std::declval()(std::declval(), offs.from, offs.to))
            {
                return Slice{}(detail::move(derived()), offs.from, offs.to);
            }
            /// Returns a reference to the element at specified location pos, with bounds checking.
            template
                CONCEPT_REQUIRES_(Same() && RandomAccessRange() && SizedRange())>
            RANGES_CXX14_CONSTEXPR auto at(range_difference_type_t n) ->
                decltype(std::declval().begin()[n])
            {
                using size_type = range_size_type_t;
                if (n < 0 || size_type(n) >= ranges::size(derived()))
                {
                    throw std::out_of_range("view_interface::at");
                }
                return derived().begin()[n];
            }
            /// \overload
            template
                CONCEPT_REQUIRES_(Same() && RandomAccessRange() && SizedRange())>
            RANGES_CXX14_CONSTEXPR auto at(range_difference_type_t n) const  ->
                decltype(std::declval().begin()[n])
            {
                using size_type = range_size_type_t;
                if (n < 0 || size_type(n) >= ranges::size(derived()))
                {
                    throw std::out_of_range("view_interface::at");
                }
                return derived().begin()[n];
            }
            /// Implicit conversion to something that looks like a container.
            template
                typename = typename Container::allocator_type, // HACKHACK
                CONCEPT_REQUIRES_(detail::ConvertibleToContainer())>
            RANGES_CXX14_CONSTEXPR operator Container ()
            {
                return ranges::to_(derived());
            }
            /// \overload
            template
                typename = typename Container::allocator_type, // HACKHACK
                CONCEPT_REQUIRES_(detail::ConvertibleToContainer())>
            constexpr operator Container () const
            {
                return ranges::to_(derived());
            }
            /// \brief Print a range to an ostream
        private:
            template
                CONCEPT_REQUIRES_(Same>>())>
            static Stream &print_(Stream &sout, Rng &rng)
            {
                sout << '[';
                auto it = ranges::begin(rng);
                auto const e = ranges::end(rng);
                if(it != e)
                {
                    for(;;)
                    {
                        sout << *it;
                        if(++it == e) break;
                        sout << ',';
                    }
                }
                sout << ']';
                return sout;
            }

            template
                CONCEPT_REQUIRES_(Same() && InputRange())>
            friend std::ostream &operator<<(std::ostream &sout, Derived const &rng)
            {
                return view_interface::print_(sout, rng);
            }
            /// \overload
            template
                CONCEPT_REQUIRES_(Same() && !Range() && InputRange())>
            friend std::ostream &operator<<(std::ostream &sout, Derived &rng)
            {
                return view_interface::print_(sout, rng);
            }
            /// \overload
            template
                CONCEPT_REQUIRES_(Same() && !Range() && InputRange())>
            friend std::ostream &operator<<(std::ostream &sout, Derived &&rng)
            {
                return view_interface::print_(sout, rng);
            }
        };
        /// @}
    }
}

#endif