#882

Committed 31 Aug 2023 07:44PM UTC coverage: 41.798% (-44.7%) from 86.546%

Build # #882

Build Type

push

Committed by

Commit Message

Run Details

19442 of 46514 relevant lines covered (41.8%)

126375.38 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

88.89

/libs/core/iterator_support/include/hpx/iterator_support/iterator_adaptor.hpp

//  Copyright (c) 2016-2025 Hartmut Kaiser
//
//  SPDX-License-Identifier: BSL-1.0
//  Distributed under 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)
//
//  This code is based on boost::iterators::iterator_facade
// (C) Copyright David Abrahams 2002.
// (C) Copyright Jeremy Siek    2002.
// (C) Copyright Thomas Witt    2002.

#pragma once

#include <hpx/config.hpp>
#include <hpx/iterator_support/iterator_facade.hpp>
#include <hpx/iterator_support/traits/is_iterator.hpp>
#include <hpx/modules/type_support.hpp>

#include <iterator>
#include <type_traits>
#include <utility>

namespace hpx::util {

    // Default template argument handling for iterator_adaptor
    namespace detail {

        ///////////////////////////////////////////////////////////////////////
        template <typename Iterator>
        struct value_type_iterator_traits_helper
        {
            using type = typename std::iterator_traits<Iterator>::value_type;
        };

        template <typename Iterator>
        struct reference_iterator_traits_helper
        {
            using type = typename std::iterator_traits<Iterator>::reference;
        };

        template <typename Iterator>
        struct category_iterator_traits_helper
        {
            using type =
                typename std::iterator_traits<Iterator>::iterator_category;
        };

        template <typename Iterator>
        struct difference_type_iterator_traits_helper
        {
            using type =
                typename std::iterator_traits<Iterator>::difference_type;
        };

        // A meta-function which computes an iterator_adaptor's base class,
        // a specialization of iterator_facade.
        template <typename Derived, typename Base, typename Value,
            typename Category, typename Reference, typename Difference,
            typename Pointer>
        struct iterator_adaptor_base
        {
            // the following type calculations use lazy_conditional to avoid
            // premature instantiations
            using value_type = std::conditional_t<std::is_void_v<Value>,
                util::lazy_conditional_t<std::is_void_v<Reference>,
                    value_type_iterator_traits_helper<Base>,
                    std::remove_reference<Reference>>,
                Value>;

            using reference_type = std::conditional_t<std::is_void_v<Reference>,
                util::lazy_conditional_t<std::is_void_v<Value>,
                    reference_iterator_traits_helper<Base>,
                    std::add_lvalue_reference<Value>>,
                Reference>;

            using iterator_category =
                util::lazy_conditional_t<std::is_void_v<Category>,
                    category_iterator_traits_helper<Base>,
                    hpx::type_identity<Category>>;

            using difference_type =
                util::lazy_conditional_t<std::is_void_v<Difference>,
                    difference_type_iterator_traits_helper<Base>,
                    hpx::type_identity<Difference>>;

            using type = iterator_facade<Derived, value_type, iterator_category,
                reference_type, difference_type, Pointer>;
        };
    }    // namespace detail

    // Iterator adaptor
    //
    // The idea is that when the user needs to fiddle with the reference type it
    // is highly likely that the iterator category has to be adjusted as well.
    // Any of the following four template arguments may be omitted or explicitly
    // replaced by void.
    //
    //   Value - if supplied, the value_type of the resulting iterator, unless
    //      const. If const, a conforming compiler strips constness for the
    //      value_type. If not supplied, iterator_traits<Base>::value_type is
    //      used
    //
    //   Category - the traversal category of the resulting iterator. If not
    //      supplied, iterator_traversal<Base>::type is used.
    //
    //   Reference - the reference type of the resulting iterator, and in
    //      particular, the result type of operator*(). If not supplied but
    //      Value is supplied, Value& is used. Otherwise,
    //      iterator_traits<Base>::reference is used.
    //
    //   Difference - the difference_type of the resulting iterator. If not
    //      supplied, iterator_traits<Base>::difference_type is used.
    //
    HPX_CXX_EXPORT template <typename Derived, typename Base,
        typename Value = void, typename Category = void,
        typename Reference = void, typename Difference = void,
        typename Pointer = void>
    class iterator_adaptor
      : public hpx::util::detail::iterator_adaptor_base<Derived, Base, Value,
            Category, Reference, Difference, Pointer>::type
    {
    protected:
        using base_adaptor_type =
            typename hpx::util::detail::iterator_adaptor_base<Derived, Base,
                Value, Category, Reference, Difference, Pointer>::type;

        friend class hpx::util::iterator_core_access;

    public:
        // NOLINTBEGIN(bugprone-crtp-constructor-accessibility)
        HPX_HOST_DEVICE iterator_adaptor() = default;

        HPX_HOST_DEVICE explicit constexpr iterator_adaptor(
            Base const& iter) noexcept
          : iterator_(iter)
        {
        }
        // NOLINTEND(bugprone-crtp-constructor-accessibility)

        using base_type = Base;

        HPX_HOST_DEVICE HPX_FORCEINLINE constexpr Base const& base()
            const noexcept
        {
            return iterator_;
        }

    protected:
        // for convenience in derived classes
        using iterator_adaptor_ = iterator_adaptor<Derived, Base, Value,
            Category, Reference, Difference, Pointer>;

        // lvalue access to the Base object for Derived
        HPX_HOST_DEVICE HPX_FORCEINLINE constexpr Base const& base_reference()
            const noexcept
        {
            return iterator_;
        }

        HPX_HOST_DEVICE HPX_FORCEINLINE Base& base_reference() noexcept
        {
            return iterator_;
        }

    private:
        // Core iterator interface for iterator_facade.  This is private
        // to prevent temptation for Derived classes to use it, which
        // will often result in an error.  Derived classes should use
        // base_reference(), above, to get direct access to m_iterator.
        HPX_HOST_DEVICE HPX_FORCEINLINE constexpr
            typename base_adaptor_type::reference
            dereference() const noexcept(noexcept(*std::declval<Base>()))
        {
            return *iterator_;
        }

        template <typename OtherDerived, typename OtherIterator, typename V,
            typename C, typename R, typename D, typename P>
        HPX_HOST_DEVICE HPX_FORCEINLINE constexpr bool equal(
            iterator_adaptor<OtherDerived, OtherIterator, V, C, R, D, P> const&
                x) const
            noexcept(
                noexcept(std::declval<Base>() == std::declval<OtherIterator>()))
        {
            // Maybe re-add with same_distance
            //  static_assert(
            //      (detail::same_category_and_difference<Derived,OtherDerived>::value)
            //  );
            return iterator_ == x.base();
        }

        // prevent this function from being instantiated if not needed
        template <typename DifferenceType>
        HPX_HOST_DEVICE HPX_FORCEINLINE void advance(DifferenceType n) noexcept(
            noexcept(std::advance(
                std::declval<Base&>(), std::declval<DifferenceType>())))
        {
            std::advance(iterator_, n);
        }

        HPX_HOST_DEVICE HPX_FORCEINLINE void increment() noexcept(
            noexcept(++std::declval<Base&>()))
        {
            ++iterator_;
        }

        // prevent this function from being instantiated if not needed
        template <typename Iterator = Base,
            typename Enable =
                std::enable_if_t<traits::is_bidirectional_iterator_v<Iterator>>>
        HPX_HOST_DEVICE HPX_FORCEINLINE void decrement() noexcept(
            noexcept(--std::declval<Base&>()))
        {
            --iterator_;
        }

        template <typename OtherDerived, typename OtherIterator, typename V,
            typename C, typename R, typename D, typename P>
        HPX_HOST_DEVICE HPX_FORCEINLINE constexpr
            typename base_adaptor_type::difference_type
            distance_to(iterator_adaptor<OtherDerived, OtherIterator, V, C, R,
                D, P> const& y) const
            noexcept(noexcept(std::distance(
                std::declval<Base>(), std::declval<OtherIterator>())))
        {
            // Maybe re-add with same_distance
            //  static_assert(
            //      (detail::same_category_and_difference<Derived,OtherDerived>::value)
            //  );
            return std::distance(iterator_, y.base());
        }

    private:    // data members
        Base iterator_;
    };
}    // namespace hpx::util

1	// Copyright (c) 2016-2025 Hartmut Kaiser
2	//
3	// SPDX-License-Identifier: BSL-1.0
4	// Distributed under the Boost Software License, Version 1.0. (See accompanying
5	// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
6	//
7	// This code is based on boost::iterators::iterator_facade
8	// (C) Copyright David Abrahams 2002.
9	// (C) Copyright Jeremy Siek 2002.
10	// (C) Copyright Thomas Witt 2002.
11
12	#pragma once
13
14	#include <hpx/config.hpp>
15	#include <hpx/iterator_support/iterator_facade.hpp>
16	#include <hpx/iterator_support/traits/is_iterator.hpp>
17	#include <hpx/modules/type_support.hpp>
18
19	#include <iterator>
20	#include <type_traits>
21	#include <utility>
22
23	namespace hpx::util {
24
25	// Default template argument handling for iterator_adaptor
26	namespace detail {
27
28	///////////////////////////////////////////////////////////////////////
29	template <typename Iterator>
30	struct value_type_iterator_traits_helper
31	{
32	using type = typename std::iterator_traits<Iterator>::value_type;
33	};
34
35	template <typename Iterator>
36	struct reference_iterator_traits_helper
37	{
38	using type = typename std::iterator_traits<Iterator>::reference;
39	};
40
41	template <typename Iterator>
42	struct category_iterator_traits_helper
43	{
44	using type =
45	typename std::iterator_traits<Iterator>::iterator_category;
46	};
47
48	template <typename Iterator>
49	struct difference_type_iterator_traits_helper
50	{
51	using type =
52	typename std::iterator_traits<Iterator>::difference_type;
53	};
54
55	// A meta-function which computes an iterator_adaptor's base class,
56	// a specialization of iterator_facade.
57	template <typename Derived, typename Base, typename Value,
58	typename Category, typename Reference, typename Difference,
59	typename Pointer>
60	struct iterator_adaptor_base
61	{
62	// the following type calculations use lazy_conditional to avoid
63	// premature instantiations
64	using value_type = std::conditional_t<std::is_void_v<Value>,
65	util::lazy_conditional_t<std::is_void_v<Reference>,
66	value_type_iterator_traits_helper<Base>,
67	std::remove_reference<Reference>>,
68	Value>;
69
70	using reference_type = std::conditional_t<std::is_void_v<Reference>,
71	util::lazy_conditional_t<std::is_void_v<Value>,
72	reference_iterator_traits_helper<Base>,
73	std::add_lvalue_reference<Value>>,
74	Reference>;
75
76	using iterator_category =
77	util::lazy_conditional_t<std::is_void_v<Category>,
78	category_iterator_traits_helper<Base>,
79	hpx::type_identity<Category>>;
80
81	using difference_type =
82	util::lazy_conditional_t<std::is_void_v<Difference>,
83	difference_type_iterator_traits_helper<Base>,
84	hpx::type_identity<Difference>>;
85
86	using type = iterator_facade<Derived, value_type, iterator_category,
87	reference_type, difference_type, Pointer>;
88	};
89	} // namespace detail
90
91	// Iterator adaptor
92	//
93	// The idea is that when the user needs to fiddle with the reference type it
94	// is highly likely that the iterator category has to be adjusted as well.
95	// Any of the following four template arguments may be omitted or explicitly
96	// replaced by void.
97	//
98	// Value - if supplied, the value_type of the resulting iterator, unless
99	// const. If const, a conforming compiler strips constness for the
100	// value_type. If not supplied, iterator_traits<Base>::value_type is
101	// used
102	//
103	// Category - the traversal category of the resulting iterator. If not
104	// supplied, iterator_traversal<Base>::type is used.
105	//
106	// Reference - the reference type of the resulting iterator, and in
107	// particular, the result type of operator*(). If not supplied but
108	// Value is supplied, Value& is used. Otherwise,
109	// iterator_traits<Base>::reference is used.
110	//
111	// Difference - the difference_type of the resulting iterator. If not
112	// supplied, iterator_traits<Base>::difference_type is used.
113	//
114	HPX_CXX_EXPORT template <typename Derived, typename Base,
115	typename Value = void, typename Category = void,
116	typename Reference = void, typename Difference = void,
117	typename Pointer = void>
118	class iterator_adaptor
119	: public hpx::util::detail::iterator_adaptor_base<Derived, Base, Value,
120	Category, Reference, Difference, Pointer>::type
121	{
122	protected:
123	using base_adaptor_type =
124	typename hpx::util::detail::iterator_adaptor_base<Derived, Base,
125	Value, Category, Reference, Difference, Pointer>::type;
126
127	friend class hpx::util::iterator_core_access;
128
129	public:
130	// NOLINTBEGIN(bugprone-crtp-constructor-accessibility)
131	HPX_HOST_DEVICE iterator_adaptor() = default;
132
133	HPX_HOST_DEVICE explicit constexpr iterator_adaptor(
134	Base const& iter) noexcept	5✔
135	: iterator_(iter)
136	{
137	}
138	// NOLINTEND(bugprone-crtp-constructor-accessibility)
139
140	using base_type = Base;
141
142	HPX_HOST_DEVICE HPX_FORCEINLINE constexpr Base const& base()
143	const noexcept	1✔
144	{
145	return iterator_;
146	}
147
148	protected:
149	// for convenience in derived classes
150	using iterator_adaptor_ = iterator_adaptor<Derived, Base, Value,
151	Category, Reference, Difference, Pointer>;
152
153	// lvalue access to the Base object for Derived
154	HPX_HOST_DEVICE HPX_FORCEINLINE constexpr Base const& base_reference()
155	const noexcept	10,007✔
156	{
157	return iterator_;
158	}
159
160	HPX_HOST_DEVICE HPX_FORCEINLINE Base& base_reference() noexcept
161	{
162	return iterator_;
163	}
164
165	private:
166	// Core iterator interface for iterator_facade. This is private
167	// to prevent temptation for Derived classes to use it, which
168	// will often result in an error. Derived classes should use
169	// base_reference(), above, to get direct access to m_iterator.
170	HPX_HOST_DEVICE HPX_FORCEINLINE constexpr
171	typename base_adaptor_type::reference
172	dereference() const noexcept(noexcept(*std::declval<Base>()))	20,000✔
173	{
174	return *iterator_;
175	}
176
177	template <typename OtherDerived, typename OtherIterator, typename V,
178	typename C, typename R, typename D, typename P>
179	HPX_HOST_DEVICE HPX_FORCEINLINE constexpr bool equal(
180	iterator_adaptor<OtherDerived, OtherIterator, V, C, R, D, P> const&
181	x) const
182	noexcept(
183	noexcept(std::declval<Base>() == std::declval<OtherIterator>()))
184	{
185	// Maybe re-add with same_distance
186	// static_assert(
187	// (detail::same_category_and_difference<Derived,OtherDerived>::value)	1✔
188	// );
189	return iterator_ == x.base();
190	}
191
192	// prevent this function from being instantiated if not needed
193	template <typename DifferenceType>
194	HPX_HOST_DEVICE HPX_FORCEINLINE void advance(DifferenceType n) noexcept(
195	noexcept(std::advance(
196	std::declval<Base&>(), std::declval<DifferenceType>())))	10,056✔
197	{
198	std::advance(iterator_, n);
199	}
200
201	HPX_HOST_DEVICE HPX_FORCEINLINE void increment() noexcept(
202	noexcept(++std::declval<Base&>()))	10,000✔
203	{
204	++iterator_;
205	}
206
207	// prevent this function from being instantiated if not needed
208	template <typename Iterator = Base,
209	typename Enable =
210	std::enable_if_t<traits::is_bidirectional_iterator_v<Iterator>>>
211	HPX_HOST_DEVICE HPX_FORCEINLINE void decrement() noexcept(
212	noexcept(--std::declval<Base&>()))	×
213	{
214	--iterator_;
215	}
216
217	template <typename OtherDerived, typename OtherIterator, typename V,
218	typename C, typename R, typename D, typename P>
219	HPX_HOST_DEVICE HPX_FORCEINLINE constexpr
220	typename base_adaptor_type::difference_type
221	distance_to(iterator_adaptor<OtherDerived, OtherIterator, V, C, R,
222	D, P> const& y) const
223	noexcept(noexcept(std::distance(
224	std::declval<Base>(), std::declval<OtherIterator>())))
225	{
226	// Maybe re-add with same_distance
227	// static_assert(
228	// (detail::same_category_and_difference<Derived,OtherDerived>::value)	2✔
229	// );
230	return std::distance(iterator_, y.base());
231	}
232
233	private: // data members
234	Base iterator_;
235	};
236	} // namespace hpx::util

STEllAR-GROUP / hpx / #882

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous