File Coverage

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

Criterion	Covered	Total	%
statement	21	21	100.0
branch	5	10	50.0
condition			n/a
subroutine			n/a
pod			n/a
total	26	31	83.8

/// \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_VIEW_TRANSFORM_HPP
#define RANGES_V3_VIEW_TRANSFORM_HPP

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

namespace ranges
{
    inline namespace v3
    {
        /// \cond
        namespace detail
        {
            constexpr cardinality transform2_cardinality(cardinality c1, cardinality c2)
            {
                return c1 >= 0 || c2 >= 0 ?
                    (c1 >= 0 && c2 >= 0 ? (c1 < c2 ? c1 : c2) : finite) :
                    c1 == finite || c2 == finite ?
                        finite :
                        c1 == unknown || c2 == unknown ?
                            unknown :
                            infinite;
            }
        }
        /// \endcond

        /// \addtogroup group-views
        /// @{
        template
        struct iter_transform_view
          : view_adaptor, Rng>
        {
        private:
            friend range_access;
            semiregular_t fun_;
            using use_sentinel_t =
                meta::or_>, SinglePass>>;

            template
            struct adaptor : adaptor_base
            {
            private:
                friend struct adaptor;
                using CRng = meta::const_if_c;
                using fun_ref_ = semiregular_ref_or_val_t;
                fun_ref_ fun_;
            public:
                using value_type =
                    detail::decay_t>>;
                adaptor() = default;
                adaptor(fun_ref_ fun)
                  : fun_(std::move(fun))
                {}
                template
                    CONCEPT_REQUIRES_(IsConst && (!Other))>
                adaptor(adaptor that)
                  : fun_(std::move(that.fun_))
                {}
                auto read(iterator_t it) const
                RANGES_DECLTYPE_AUTO_RETURN_NOEXCEPT
                (
                    invoke(fun_, it)
                )
                auto iter_move(iterator_t it) const
                RANGES_DECLTYPE_AUTO_RETURN_NOEXCEPT
                (
                    invoke(fun_, move_tag{}, it)
                )
            };

            adaptor begin_adaptor()
            {
                return {fun_};
            }
            template
                CONCEPT_REQUIRES_(Range() && Invocable>())>
            adaptor begin_adaptor() const
            {
                return {fun_};
            }
            meta::if_> end_adaptor()
            {
                return {fun_};
            }
            template
                CONCEPT_REQUIRES_(Range() && Invocable>())>
            meta::if_> end_adaptor() const
            {
                return {fun_};
            }
        public:
            iter_transform_view() = default;
            iter_transform_view(Rng rng, Fun fun)
              : iter_transform_view::view_adaptor{std::move(rng)}
              , fun_(std::move(fun))
            {}
            CONCEPT_REQUIRES(SizedRange())
            constexpr range_size_type_t size() const
            {
                return static_cast>(ranges::size(this->base()));
            }
            CONCEPT_REQUIRES(SizedRange())
            RANGES_CXX14_CONSTEXPR range_size_type_t size()
            {
                return static_cast>(ranges::size(this->base()));
            }
        };

        template
        struct transform_view
          : iter_transform_view>
        {
            transform_view() = default;
            transform_view(Rng rng, Fun fun)
              : iter_transform_view>{std::move(rng),
                    indirect(std::move(fun))}
            {}
        };

        template
        struct iter_transform2_view
          : view_facade<
                iter_transform2_view,
                detail::transform2_cardinality(
                    range_cardinality::value,
                    range_cardinality::value)>
        {
        private:
            friend range_access;
            semiregular_t fun_;
            Rng1 rng1_;
            Rng2 rng2_;
            using difference_type_ = common_type_t, range_difference_type_t>;
            using size_type_ = meta::_t>;

            static constexpr cardinality my_cardinality = detail::transform2_cardinality(
                range_cardinality::value,
                range_cardinality::value);

            template
            struct cursor;

            template
            struct sentinel
            {
            private:
                friend struct cursor;
                sentinel_t> end1_;
                sentinel_t> end2_;
            public:
                sentinel() = default;
                sentinel(meta::const_if_c &parent, decltype(end))
                  : end1_(end(parent.rng1_)), end2_(end(parent.rng2_))
                {}
                template
                sentinel(sentinel that)
                  : end1_(std::move(that.end1_))
                  , end2_(std::move(that.end2_))
                {}
            };

            template
            struct cursor
            {
            private:
                using fun_ref_ = semiregular_ref_or_val_t;
                using R1 = meta::const_if_c;
                using R2 = meta::const_if_c;
                fun_ref_ fun_;
                iterator_t it1_;
                iterator_t it2_;

            public:
                using difference_type = difference_type_;
                using single_pass = meta::or_c<
                    (bool) SinglePass>(),
                    (bool) SinglePass>()>;
                using value_type =
                    detail::decay_t<
                        invoke_result_t<
                            meta::const_if_c &,
                            copy_tag,
                            iterator_t,
                            iterator_t>>;

                cursor() = default;
                template
                cursor(meta::const_if_c &parent, BeginEndFn begin_end)
                  : fun_(parent.fun_), it1_(begin_end(parent.rng1_)), it2_(begin_end(parent.rng2_))
                {}
                template
                cursor(cursor that)
                  : fun_(std::move(that.fun_))
                  , it1_(std::move(that.end1_))
                  , it2_(std::move(that.end2_))
                {}
                auto read() const
                RANGES_DECLTYPE_AUTO_RETURN_NOEXCEPT
                (
                    invoke(fun_, it1_, it2_)
                )
                void next()
                {
                    ++it1_;
                    ++it2_;
                }
                bool equal(cursor const &that) const
                {
                    // By returning true if *any* of the iterators are equal, we allow
                    // transformed ranges to be of different lengths, stopping when the first
                    // one reaches the end.
                    return it1_ == that.it1_ || it2_ == that.it2_;
                }
                bool equal(sentinel const &s) const
                {
                    // By returning true if *any* of the iterators are equal, we allow
                    // transformed ranges to be of different lengths, stopping when the first
                    // one reaches the end.
                    return it1_ == s.end1_ || it2_ == s.end2_;
                }
                CONCEPT_REQUIRES(BidirectionalRange() && BidirectionalRange())
                void prev()
                {
                    --it1_;
                    --it2_;
                }
                CONCEPT_REQUIRES(RandomAccessRange() && RandomAccessRange())
                void advance(difference_type n)
                {
                    ranges::advance(it1_, n);
                    ranges::advance(it2_, n);
                }
                CONCEPT_REQUIRES(
                    SizedSentinel, iterator_t>() &&
                    SizedSentinel, iterator_t>())
                difference_type distance_to(cursor const &that) const
                {
                    // Return the smallest distance (in magnitude) of any of the iterator
                    // pairs. This is to accommodate zippers of sequences of different length.
                    difference_type d1 = that.it1_ - it1_, d2 = that.it2_ - it2_;
                    return 0 < d1 ? ranges::min(d1, d2) : ranges::max(d1, d2);
                }
                auto move() const
                RANGES_DECLTYPE_AUTO_RETURN_NOEXCEPT
                (
                    invoke(fun_, move_tag{}, it1_, it2_)
                )
            };

            template
            using end_cursor_t =
                meta::if_c<
                    BoundedRange>() &&
                    BoundedRange>() &&
                    !SinglePass>>() &&
                    !SinglePass>>(),
                    cursor,
                    sentinel>;

            cursor() && simple_view()>
            begin_cursor()
            {
                return {*this, ranges::begin};
            }
            end_cursor_t() && simple_view()> end_cursor()
            {
                return {*this, ranges::end};
            }
            template
                CONCEPT_REQUIRES_(Range() && Range() &&
                    IndirectInvocable, iterator_t>())>
            cursor begin_cursor() const
            {
                return {*this, ranges::begin};
            }
            template
                CONCEPT_REQUIRES_(Range() && Range() &&
                    IndirectInvocable, iterator_t>())>
            end_cursor_t end_cursor() const
            {
                return {*this, ranges::end};
            }
            template
            static constexpr size_type_ size_(Self& self)
            {
                return ranges::min(
                    static_cast(ranges::size(self.rng1_)),
                    static_cast(ranges::size(self.rng2_)));
            }
        public:
            iter_transform2_view() = default;
            iter_transform2_view(Rng1 rng1, Rng2 rng2, Fun fun)
              : fun_(std::move(fun))
              , rng1_(std::move(rng1))
              , rng2_(std::move(rng2))
            {}
            CONCEPT_REQUIRES(my_cardinality >= 0)
            constexpr size_type_ size() const
            {
                return static_cast(my_cardinality);
            }
            CONCEPT_REQUIRES(my_cardinality < 0 &&
                SizedRange() && SizedRange())
            constexpr size_type_ size() const
            {
                return size_(*this);
            }
            CONCEPT_REQUIRES(my_cardinality < 0 &&
                SizedRange() && SizedRange())
            RANGES_CXX14_CONSTEXPR size_type_ size()
            {
                return size_(*this);
            }
        };

        template
        struct transform2_view
          : iter_transform2_view>
        {
            transform2_view() = default;
            transform2_view(Rng1 rng1, Rng2 rng2, Fun fun)
              : iter_transform2_view>{std::move(rng1),
                    std::move(rng2), indirect(std::move(fun))}
            {}
        };

        namespace view
        {
            struct iter_transform_fn
            {
            private:
                friend view_access;
                template
                static auto bind(iter_transform_fn iter_transform, Fun fun)
                RANGES_DECLTYPE_AUTO_RETURN
                (
                    make_pipeable(std::bind(iter_transform, std::placeholders::_1,
                        protect(std::move(fun))))
                )
            public:
                template
                using Concept = meta::and_<
                    InputRange,
                    CopyConstructible,
                    Invocable>,
                    Invocable>,
                    Invocable>>;

                template
                using Concept2 = meta::and_<
                    InputRange,
                    InputRange,
                    CopyConstructible,
                    Invocable, iterator_t>,
                    Invocable, iterator_t>,
                    Invocable, iterator_t>>;

                template
                    CONCEPT_REQUIRES_(Concept())>
                iter_transform_view, Fun> operator()(Rng && rng, Fun fun) const
                {
                    return {all(static_cast(rng)), std::move(fun)};
                }

                template
                    CONCEPT_REQUIRES_(Concept2())>
                iter_transform2_view, all_t, Fun>
                operator()(Rng1 && rng1, Rng2 && rng2, Fun fun) const
                {
                    return {all(static_cast(rng1)), all(static_cast(rng2)), std::move(fun)};
                }

            #ifndef RANGES_DOXYGEN_INVOKED
                template
                    CONCEPT_REQUIRES_(!Concept())>
                void operator()(Rng &&, Fun) const
                {
                    CONCEPT_ASSERT_MSG(InputRange(),
                        "The object on which view::iter_transform operates must be a model of the "
                        "InputRange concept.");
                    CONCEPT_ASSERT_MSG(
                        CopyConstructible(),
                        "The function passed to view::iter_transform must be CopyConstructible.");
                    CONCEPT_ASSERT_MSG(
                        Invocable>(),
                        "The function passed to view::iter_transform must be callable with an argument "
                        "of the range's iterator type.");
                    CONCEPT_ASSERT_MSG(
                        Invocable>(),
                        "The function passed to view::iter_transform must be callable with "
                        "copy_tag and an argument of the range's iterator type.");
                    CONCEPT_ASSERT_MSG(
                        Invocable>(),
                        "The function passed to view::iter_transform must be callable with "
                        "move_tag and an argument of the range's iterator type.");
                }

                template
                    CONCEPT_REQUIRES_(!Concept2())>
                void operator()(Rng1 &&, Rng2 &&, Fun) const
                {
                    CONCEPT_ASSERT_MSG(InputRange(),
                        "The first object on which view::iter_transform operates must be a model of the "
                        "InputRange concept.");
                    CONCEPT_ASSERT_MSG(InputRange(),
                        "The second object on which view::iter_transform operates must be a model of the "
                        "InputRange concept.");
                    CONCEPT_ASSERT_MSG(
                        CopyConstructible(),
                        "The function passed to view::iter_transform must be CopyConstructible.");
                    CONCEPT_ASSERT_MSG(
                        Invocable, iterator_t>(),
                        "The function passed to view::iter_transform must be callable with argument "
                        "of the ranges' iterator types.");
                    CONCEPT_ASSERT_MSG(
                        Invocable, iterator_t>(),
                        "The function passed to view::iter_transform must be callable with "
                        "copy_tag and arguments of the ranges' iterator types.");
                    CONCEPT_ASSERT_MSG(
                        Invocable, iterator_t>(),
                        "The function passed to view::iter_transform must be callable with "
                        "move_tag and arguments of the rangess iterator types.");
                }
            #endif
            };

            /// \relates iter_transform_fn
            /// \ingroup group-views
            RANGES_INLINE_VARIABLE(view, iter_transform)

            struct transform_fn
            {
            private:
                friend view_access;
                template
                static auto bind(transform_fn transform, Fun fun)
                RANGES_DECLTYPE_AUTO_RETURN
                (
                    make_pipeable(std::bind(transform, std::placeholders::_1,
                        protect(std::move(fun))))
                )
            public:
                // Don't forget to update view::for_each whenever this set
                // of concepts changes
                template
                using Concept = meta::and_<
                    InputRange,
                    CopyConstructible,
                    Invocable>,
                    meta::not_
                        Fun&, range_reference_t>>>>;

                template
                using Concept2 = meta::and_<
                    InputRange,
                    InputRange,
                    CopyConstructible,
                    Invocable, range_reference_t>,
                    meta::not_
                        Fun&, range_reference_t, range_reference_t>>>>;

                template
                    CONCEPT_REQUIRES_(Concept())>
                transform_view, Fun> operator()(Rng && rng, Fun fun) const
                {
                    return {all(static_cast(rng)), std::move(fun)};
                }

                template
                    CONCEPT_REQUIRES_(Concept2())>
                transform2_view, all_t, Fun>
                operator()(Rng1 && rng1, Rng2 && rng2, Fun fun) const
                {
                    return {all(static_cast(rng1)), all(static_cast(rng2)),
                        std::move(fun)};
                }

            #ifndef RANGES_DOXYGEN_INVOKED
                template
                    CONCEPT_REQUIRES_(!Concept())>
                void operator()(Rng &&, Fun) const
                {
                    CONCEPT_ASSERT_MSG(InputRange(),
                        "The object on which view::transform operates must be a model of the "
                        "InputRange concept.");
                    CONCEPT_ASSERT_MSG(
                        CopyConstructible(),
                        "The function passed to view::transform must be CopyConstructible.");
                    CONCEPT_ASSERT_MSG(
                        Invocable>(),
                        "The function passed to view::transform must be callable with an argument "
                        "of the range's reference type.");
                    CONCEPT_ASSERT_MSG(
                        meta::not_
                            Fun&, range_reference_t>>>(),
                        "The function passed to view::transform must return non-void when called "
                        "with an argument of the range's reference type.");
                }

                template
                    CONCEPT_REQUIRES_(!Concept2())>
                void operator()(Rng1 &&, Rng2 &&, Fun) const
                {
                    CONCEPT_ASSERT_MSG(InputRange(),
                        "The first object on which view::transform operates must be a model of the "
                        "InputRange concept.");
                    CONCEPT_ASSERT_MSG(InputRange(),
                        "The second object on which view::transform operates must be a model of the "
                        "InputRange concept.");
                    CONCEPT_ASSERT_MSG(
                        CopyConstructible(),
                        "The function passed to view::transform must be CopyConstructible.");
                    CONCEPT_ASSERT_MSG(
                        Invocable, range_reference_t>(),
                        "The function passed to view::transform must be callable with arguments "
                        "of the ranges' reference types.");
                    CONCEPT_ASSERT_MSG(
                        meta::not_
                            Fun&, range_reference_t, range_reference_t>>>(),
                        "The function passed to view::transform must return non-void when called "
                        "with arguments of the ranges' reference types.");
                }
            #endif
            };

            /// \relates transform_fn
            /// \ingroup group-views
            RANGES_INLINE_VARIABLE(view, transform)
        }
        /// @}
    }
}

RANGES_SATISFY_BOOST_RANGE(::ranges::v3::iter_transform_view)
RANGES_SATISFY_BOOST_RANGE(::ranges::v3::transform_view)

#endif