File Coverage

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

Criterion	Covered	Total	%
statement	4	4	100.0
branch			n/a
condition			n/a
subroutine			n/a
pod			n/a
total	4	4	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_SIZE_HPP
#define RANGES_V3_SIZE_HPP

#include
#include
#include
#include

namespace ranges
{
    inline namespace v3
    {
        /// \addtogroup group-concepts
        // Specialize this if the default is wrong.
        template
        struct disable_sized_range : std::false_type {};

        /// \cond
        namespace _size_
        {
            template
            void size(T const &) = delete;

#ifdef RANGES_WORKAROUND_MSVC_620035
            void size();
#endif

            struct fn : iter_size_fn
            {
            private:
                template
                static constexpr std::size_t impl_(R (&)[N], int) noexcept
                {
                    return N;
                }

                // Prefer member if it returns Integral.
                template
                    typename = meta::if_c()>,
                    typename N = decltype(aux::copy(std::declval().size())),
                    CONCEPT_REQUIRES_(Integral())>
                static constexpr N impl_(R &r, int)
                RANGES_AUTO_RETURN_NOEXCEPT
                (
                    r.size()
                )

                // Use ADL if it returns Integral.
                template
                    typename = meta::if_c()>,
                    typename N = decltype(aux::copy(size(std::declval()))),
                    CONCEPT_REQUIRES_(Integral())>
                static constexpr N impl_(R &r, long)
                RANGES_AUTO_RETURN_NOEXCEPT
                (
                    size(r)
                )

                template
                    typename I = decltype(ranges::cbegin(std::declval())),
                    CONCEPT_REQUIRES_(ForwardIterator())>
                static RANGES_CXX14_CONSTEXPR auto impl_(R &r, ...)
                RANGES_DECLTYPE_AUTO_RETURN_NOEXCEPT
                (
                    ranges::iter_size(ranges::cbegin(r), ranges::cend(r))
                )

            public:
                using iter_size_fn::operator();

                template
                constexpr auto operator()(R &&r) const
                RANGES_DECLTYPE_AUTO_RETURN_NOEXCEPT
                (
                    fn::impl_(r, 42)
                )

                template
                constexpr auto operator()(std::reference_wrapper ref) const
                RANGES_DECLTYPE_AUTO_RETURN_NOEXCEPT
                (
                    Fn()(ref.get())
                )

                template
                constexpr auto operator()(ranges::reference_wrapper ref) const
                RANGES_DECLTYPE_AUTO_RETURN_NOEXCEPT
                (
                    Fn()(ref.get())
                )
            };
        }
        /// \endcond

        /// \ingroup group-core
        /// \return The result of an unqualified call to `size`
        inline namespace CPOs
        {
            RANGES_INLINE_VARIABLE(_size_::fn, size)
        }
    }
}

#endif