view release on metacpan or  search on metacpan

range-v3-0.12.0/include/range/v3/range/primitives.hpp  view on Meta::CPAN

            template<typename R>
            using _result_t =
                meta::invoke<
                    meta::conditional_t<
                        has_member_data<R>,
                        _member_data_,
                        _other_result_>,
                    R>;

        public:
            template(typename R)(
                requires has_member_data<R &> AND
                    std::is_pointer<_result_t<R &>>::value)
            constexpr _result_t<R &> operator()(R & r) const //
                noexcept(noexcept(r.data()))
            {
                return r.data();
            }
            template(typename R)(
                requires (!has_member_data<R &>) AND
                    std::is_pointer<_begin_::_t<R>>::value)
            constexpr _result_t<R> operator()(R && r) const //
                noexcept(noexcept(ranges::begin((R &&) r)))
            {
                return ranges::begin((R &&) r);
            }
            template(typename R)(
                requires (!has_member_data<R &>) AND
                    (!std::is_pointer<_begin_::_t<R>>::value) AND
                    contiguous_iterator<_begin_::_t<R>>)
            constexpr _result_t<R> operator()(R && r) const //
                noexcept(noexcept(
                    ranges::begin((R &&) r) == ranges::end((R &&) r)
                      ? nullptr
                      : detail::addressof(*ranges::begin((R &&) r))))
            {
                return ranges::begin((R &&) r) == ranges::end((R &&) r)
                  ? nullptr
                  : detail::addressof(*ranges::begin((R &&) r));
            }

#if RANGES_CXX_STD <= RANGES_CXX_STD_14
            template<typename charT, typename Traits, typename Alloc>
            constexpr charT * operator()(
                std::basic_string<charT, Traits, Alloc> & s) const noexcept
            {
                // string doesn't have non-const data before C++17
                return const_cast<charT *>(detail::as_const(s).data());
            }
#endif
        };

        template<typename R>
        using _t = decltype(fn{}(declval(R &&)));
    } // namespace _data_
    /// \endcond

    RANGES_INLINE_VARIABLE(_data_::fn, data)

    /// \cond
    namespace _cdata_
    {
        struct fn
        {
            template<typename R>
            constexpr _data_::_t<R const &> operator()(R const & r) const
                noexcept(noexcept(ranges::data(r)))
            {
                return ranges::data(r);
            }
            template<typename R>
            constexpr _data_::_t<R const> operator()(R const && r) const
                noexcept(noexcept(ranges::data((R const &&)r)))
            {
                return ranges::data((R const &&)r);
            }
        };
    } // namespace _cdata_
    /// \endcond

    /// \ingroup group-range
    /// \param r
    /// \return The result of calling `ranges::data` with a const-qualified
    ///    (lvalue or rvalue) reference to `r`.
    RANGES_INLINE_VARIABLE(_cdata_::fn, cdata)

    /// \cond
    namespace _empty_
    {
        // clang-format off
        /// \concept has_member_empty_
        /// \brief The \c has_member_empty_ concept
        template<typename T>
        CPP_requires(has_member_empty_,
            requires(T && t) //
            (
                bool(((T &&) t).empty())
            ));
        /// \concept has_member_empty
        /// \brief The \c has_member_empty concept
        template<typename T>
        CPP_concept has_member_empty =
            CPP_requires_ref(_empty_::has_member_empty_, T);

        /// \concept has_size_
        /// \brief The \c has_size_ concept
        template<typename T>
        CPP_requires(has_size_,
            requires(T && t) //
            (
                ranges::size((T &&) t)
            ));
        /// \concept has_size
        /// \brief The \c has_size concept
        template<typename T>
        CPP_concept has_size =
            CPP_requires_ref(_empty_::has_size_, T);
        // clang-format on

        struct fn
        {
            // Prefer member if it is valid.
            template(typename R)(
                requires has_member_empty<R>)
            constexpr bool operator()(R && r) const
                noexcept(noexcept(bool(((R &&) r).empty())))
            {
                return bool(((R &&) r).empty());
            }

            // Fall back to size == 0.
            template(typename R)(
                requires (!has_member_empty<R>) AND has_size<R>)
            constexpr bool operator()(R && r) const
                noexcept(noexcept(bool(ranges::size((R &&) r) == 0)))
            {
                return bool(ranges::size((R &&) r) == 0);
            }

            // Fall further back to begin == end.
            template(typename R)(
                requires (!has_member_empty<R>) AND (!has_size<R>) AND
                    forward_iterator<_begin_::_t<R>>)
            constexpr bool operator()(R && r) const
                noexcept(noexcept(bool(ranges::begin((R &&) r) == ranges::end((R &&) r))))
            {
                return bool(ranges::begin((R &&) r) == ranges::end((R &&) r));
            }
        };
    } // namespace _empty_
    /// \endcond

    /// \ingroup group-range
    /// \return true if and only if range contains no elements.
    RANGES_INLINE_VARIABLE(_empty_::fn, empty)

    namespace cpp20
    {
        // Specialize this is namespace ranges::
        using ranges::cdata;
        using ranges::data;
        using ranges::disable_sized_range;
        using ranges::empty;
        using ranges::size;
    } // namespace cpp20
} // namespace ranges

#include <range/v3/detail/epilogue.hpp>

#endif