File Coverage

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

Criterion	Covered	Total	%
statement	34	34	100.0
branch	15	22	68.1
condition			n/a
subroutine			n/a
pod			n/a
total	49	56	87.5

/// \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_REMOVE_IF_HPP
#define RANGES_V3_VIEW_REMOVE_IF_HPP

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

RANGES_DISABLE_WARNINGS

namespace ranges
{
    inline namespace v3
    {
        /// \addtogroup group-views
        /// @{
        template
        struct RANGES_EMPTY_BASES remove_if_view
          : view_adaptor<
                remove_if_view,
                Rng,
                is_finite::value ? finite : range_cardinality::value>
          , private box>
        {
            remove_if_view() = default;
            constexpr remove_if_view(Rng rng, Pred pred)
              : remove_if_view::view_adaptor{detail::move(rng)}
              , remove_if_view::box(detail::move(pred))
            {}
        private:
            friend range_access;

            struct adaptor : adaptor_base
            {
                adaptor() = default;
                constexpr adaptor(remove_if_view &rng) noexcept
                  : rng_(&rng)
                {}
                static RANGES_CXX14_CONSTEXPR iterator_t begin(remove_if_view &rng)
                {
                    return *rng.begin_;
                }
                RANGES_CXX14_CONSTEXPR void next(iterator_t &it) const
                {
                    RANGES_ASSERT(it != ranges::end(rng_->base()));
                    rng_->satisfy_forward(++it);
                }
                CONCEPT_REQUIRES(BidirectionalRange())
                RANGES_CXX14_CONSTEXPR void prev(iterator_t &it) const
                {
                    rng_->satisfy_reverse(it);
                }
                void advance() = delete;
                void distance_to() = delete;
            private:
                remove_if_view *rng_;
            };
            RANGES_CXX14_CONSTEXPR adaptor begin_adaptor()
            {
                cache_begin();
                return {*this};
            }
            CONCEPT_REQUIRES(!BoundedRange())
            constexpr adaptor_base end_adaptor() const noexcept
            {
                return {};
            }
            CONCEPT_REQUIRES(BoundedRange())
            RANGES_CXX14_CONSTEXPR adaptor end_adaptor()
            {
                if(BidirectionalRange()) cache_begin();
                return {*this};
            }

            RANGES_CXX14_CONSTEXPR void satisfy_forward(iterator_t &it)
            {
                auto const last = ranges::end(this->base());
                auto &pred = this->remove_if_view::box::get();
                while (it != last && invoke(pred, *it))
                    ++it;
            }
            RANGES_CXX14_CONSTEXPR void satisfy_reverse(iterator_t &it)
            {
                RANGES_ASSERT(begin_);
                auto const &first = *begin_;
                auto &pred = this->remove_if_view::box::get();
                do
                {
                    RANGES_ASSERT(it != first); (void)first;
                    --it;
                } while(invoke(pred, *it));
            }

            RANGES_CXX14_CONSTEXPR void cache_begin()
            {
                if(begin_) return;
                auto it = ranges::begin(this->base());
                satisfy_forward(it);
                begin_.emplace(std::move(it));
            }

            detail::non_propagating_cache> begin_;
        };

        namespace view
        {
            /// \cond
            template
            struct remove_if_fn_
            {
            private:
                friend view_access;
                template
                static auto bind(remove_if_fn_ remove_if, Pred pred)
                RANGES_DECLTYPE_AUTO_RETURN_NOEXCEPT
                (
                    make_pipeable(std::bind(remove_if, std::placeholders::_1,
                        protect(std::move(pred))))
                )

                template
                static auto bind(remove_if_fn_ remove_if, Pred pred, Proj proj)
                RANGES_DECLTYPE_AUTO_RETURN_NOEXCEPT
                (
                    make_pipeable(std::bind(remove_if, std::placeholders::_1,
                        protect(std::move(pred)), protect(std::move(proj))))
                )
            public:
                template
                using Constraint = meta::and_<
                    InputRange,
                    IndirectPredicate, Proj>>>;

                template
                    typename M = detail::decay_t>,
                    CONCEPT_REQUIRES_(Constraint())>
                RANGES_CXX14_CONSTEXPR
                auto operator()(Rng &&rng, Pred&& pred) const
                RANGES_DECLTYPE_AUTO_RETURN_NOEXCEPT
                (
                    remove_if_view, M>{
                        all(static_cast(rng)),
                        Modifier{}(std::move(pred))
                    }
                )

                template
                    typename M = detail::decay_t>,
                    CONCEPT_REQUIRES_(Constraint())>
                RANGES_CXX14_CONSTEXPR
                auto operator()(Rng &&rng, Pred pred, Proj proj) const
                RANGES_DECLTYPE_AUTO_RETURN_NOEXCEPT
                (
                    remove_if_view, composed>{
                        all(static_cast(rng)),
                        compose(Modifier{}(std::move(pred)), std::move(proj))
                    }
                )

            #ifndef RANGES_DOXYGEN_INVOKED
                template
                    CONCEPT_REQUIRES_(!Constraint())>
                void operator()(Rng &&, Pred) const
                {
                    CONCEPT_ASSERT_MSG(InputRange(),
                        "The first argument to view::remove_if/filter must "
                        "be a model of the InputRange concept");
                    using Itr = iterator_t;
                    CONCEPT_ASSERT_MSG(IndirectPredicate(),
                        "The second argument to view::remove_if/filter must "
                        "accept arguments of the range's value type.");
                }

                template
                    CONCEPT_REQUIRES_(!Constraint())>
                void operator()(Rng &&, Pred, Proj) const
                {
                    CONCEPT_ASSERT_MSG(InputRange(),
                        "The first argument to view::remove_if/filter must "
                        "be a model of the InputRange concept");
                    using Itr = iterator_t;
                    CONCEPT_ASSERT_MSG(IndirectInvocable(),
                        "The projection function must accept arguments of the iterator's "
                        "value type, reference type, and common reference type.");
                    CONCEPT_ASSERT_MSG(IndirectPredicate>(),
                        "The second argument to view::remove_if/filter must accept values "
                        "returned by the projection function.");
                }
            #endif
            };
            /// \endcond

            /// Given a source range, unary predicate, and optional projection,
            /// present a view of the elements that do not satisfy the predicate.
            using remove_if_fn = remove_if_fn_;

            /// \relates remove_if_fn
            /// \ingroup group-views
            RANGES_INLINE_VARIABLE(view, remove_if)
        }
        /// @}
    }
}

RANGES_RE_ENABLE_WARNINGS

RANGES_SATISFY_BOOST_RANGE(::ranges::v3::remove_if_view)

#endif