11.2.0/parallel/iterator.h

// -*- C++ -*-

// Copyright (C) 2007-2021 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library.  This library is free
// software; you can redistribute it and/or modify it under the terms
// of the GNU General Public License as published by the Free Software
// Foundation; either version 3, or (at your option) any later
// version.

// This library is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// General Public License for more details.

// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.

// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
// <http://www.gnu.org/licenses/>.

/** @file parallel/iterator.h
 * @brief Helper iterator classes for the std::transform() functions.
 *  This file is a GNU parallel extension to the Standard C++ Library.
 */

// Written by Johannes Singler.

#ifndef _GLIBCXX_PARALLEL_ITERATOR_H
#define _GLIBCXX_PARALLEL_ITERATOR_H 1

#include <parallel/basic_iterator.h>
#include <bits/stl_pair.h>

namespace __gnu_parallel
{
  /** @brief A pair of iterators. The usual iterator operations are
   *  applied to both child iterators.
   */
  template<typename _Iterator1, typename _Iterator2,
           typename _IteratorCategory>
    class _IteratorPair : public std::pair<_Iterator1, _Iterator2>
    {
    private:
      typedef std::pair<_Iterator1, _Iterator2> _Base;

    public:
      typedef _IteratorCategory iterator_category;
      typedef void value_type;

      typedef std::iterator_traits<_Iterator1> _TraitsType;
      typedef typename _TraitsType::difference_type difference_type;
      typedef _IteratorPair* pointer;
      typedef _IteratorPair& reference;

      _IteratorPair() { }

      _IteratorPair(const _Iterator1& __first, const _Iterator2& __second)
      : _Base(__first, __second) { }

      // Pre-increment operator.
      _IteratorPair&
      operator++()
      {
        ++_Base::first;
        ++_Base::second;
        return *this;
      }

      // Post-increment operator.
      const _IteratorPair
      operator++(int)
      { return _IteratorPair(_Base::first++, _Base::second++); }

      // Pre-decrement operator.
      _IteratorPair&
      operator--()
      {
        --_Base::first;
        --_Base::second;
        return *this;
      }

      // Post-decrement operator.
      const _IteratorPair
      operator--(int)
      { return _IteratorPair(_Base::first--, _Base::second--); }

      // Type conversion.
      operator _Iterator2() const
      { return _Base::second; }

      _IteratorPair&
      operator=(const _IteratorPair& __other)
      {
        _Base::first = __other.first;
        _Base::second = __other.second;
        return *this;
      }

      _IteratorPair
      operator+(difference_type __delta) const
      { return _IteratorPair(_Base::first + __delta, _Base::second + __delta);
        }

      difference_type
      operator-(const _IteratorPair& __other) const
      { return _Base::first - __other.first; }
  };


  /** @brief A triple of iterators. The usual iterator operations are
      applied to all three child iterators.
   */
  template<typename _Iterator1, typename _Iterator2, typename _Iterator3,
           typename _IteratorCategory>
    class _IteratorTriple
    {
    public:
      typedef _IteratorCategory iterator_category;
      typedef void value_type;
      typedef typename std::iterator_traits<_Iterator1>::difference_type
                                                            difference_type;
      typedef _IteratorTriple* pointer;
      typedef _IteratorTriple& reference;

      _Iterator1 _M_first;
      _Iterator2 _M_second;
      _Iterator3 _M_third;

      _IteratorTriple() { }

      _IteratorTriple(const _Iterator1& __first, const _Iterator2& __second,
                      const _Iterator3& __third)
      {
        _M_first = __first;
        _M_second = __second;
        _M_third = __third;
      }

      // Pre-increment operator.
      _IteratorTriple&
      operator++()
      {
        ++_M_first;
        ++_M_second;
        ++_M_third;
        return *this;
      }

      // Post-increment operator.
      const _IteratorTriple
      operator++(int)
      { return _IteratorTriple(_M_first++, _M_second++, _M_third++); }

      // Pre-decrement operator.
      _IteratorTriple&
      operator--()
      {
        --_M_first;
        --_M_second;
        --_M_third;
        return *this;
      }

      // Post-decrement operator.
      const _IteratorTriple
      operator--(int)
      { return _IteratorTriple(_M_first--, _M_second--, _M_third--); }

      // Type conversion.
      operator _Iterator3() const
      { return _M_third; }

      _IteratorTriple&
      operator=(const _IteratorTriple& __other)
      {
        _M_first = __other._M_first;
        _M_second = __other._M_second;
        _M_third = __other._M_third;
        return *this;
      }

      _IteratorTriple
      operator+(difference_type __delta) const
      { return _IteratorTriple(_M_first + __delta, _M_second + __delta,
                               _M_third + __delta); }

      difference_type
      operator-(const _IteratorTriple& __other) const
      { return _M_first - __other._M_first; }
  };
}

#endif /* _GLIBCXX_PARALLEL_ITERATOR_H */
Revision:	1166
Committed:	Tue Oct 26 14:22:36 2021 UTC (4 years ago) by rossy
Content type:	text/x-chdr
File size:	5678 byte(s)
Log Message:	Daodan: Replace MinGW build env with an up-to-date MSYS2 env
#	Content
1	// -- C++ --
2
3	// Copyright (C) 2007-2021 Free Software Foundation, Inc.
4	//
5	// This file is part of the GNU ISO C++ Library. This library is free
6	// software; you can redistribute it and/or modify it under the terms
7	// of the GNU General Public License as published by the Free Software
8	// Foundation; either version 3, or (at your option) any later
9	// version.
10
11	// This library is distributed in the hope that it will be useful, but
12	// WITHOUT ANY WARRANTY; without even the implied warranty of
13	// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14	// General Public License for more details.
15
16	// Under Section 7 of GPL version 3, you are granted additional
17	// permissions described in the GCC Runtime Library Exception, version
18	// 3.1, as published by the Free Software Foundation.
19
20	// You should have received a copy of the GNU General Public License and
21	// a copy of the GCC Runtime Library Exception along with this program;
22	// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
23	// <http://www.gnu.org/licenses/>.
24
25	/** @file parallel/iterator.h
26	* @brief Helper iterator classes for the std::transform() functions.
27	* This file is a GNU parallel extension to the Standard C++ Library.
28	*/
29
30	// Written by Johannes Singler.
31
32	#ifndef _GLIBCXX_PARALLEL_ITERATOR_H
33	#define _GLIBCXX_PARALLEL_ITERATOR_H 1
34
35	#include <parallel/basic_iterator.h>
36	#include <bits/stl_pair.h>
37
38	namespace __gnu_parallel
39	{
40	/** @brief A pair of iterators. The usual iterator operations are
41	* applied to both child iterators.
42	*/
43	template<typename _Iterator1, typename _Iterator2,
44	typename _IteratorCategory>
45	class _IteratorPair : public std::pair<_Iterator1, _Iterator2>
46	{
47	private:
48	typedef std::pair<_Iterator1, _Iterator2> _Base;
49
50	public:
51	typedef _IteratorCategory iterator_category;
52	typedef void value_type;
53
54	typedef std::iterator_traits<_Iterator1> _TraitsType;
55	typedef typename _TraitsType::difference_type difference_type;
56	typedef _IteratorPair* pointer;
57	typedef _IteratorPair& reference;
58
59	_IteratorPair() { }
60
61	_IteratorPair(const _Iterator1& __first, const _Iterator2& __second)
62	: _Base(__first, __second) { }
63
64	// Pre-increment operator.
65	_IteratorPair&
66	operator++()
67	{
68	++_Base::first;
69	++_Base::second;
70	return *this;
71	}
72
73	// Post-increment operator.
74	const _IteratorPair
75	operator++(int)
76	{ return _IteratorPair(_Base::first++, _Base::second++); }
77
78	// Pre-decrement operator.
79	_IteratorPair&
80	operator--()
81	{
82	--_Base::first;
83	--_Base::second;
84	return *this;
85	}
86
87	// Post-decrement operator.
88	const _IteratorPair
89	operator--(int)
90	{ return _IteratorPair(_Base::first--, _Base::second--); }
91
92	// Type conversion.
93	operator _Iterator2() const
94	{ return _Base::second; }
95
96	_IteratorPair&
97	operator=(const _IteratorPair& __other)
98	{
99	_Base::first = __other.first;
100	_Base::second = __other.second;
101	return *this;
102	}
103
104	_IteratorPair
105	operator+(difference_type __delta) const
106	{ return _IteratorPair(_Base::first + __delta, _Base::second + __delta);
107	}
108
109	difference_type
110	operator-(const _IteratorPair& __other) const
111	{ return _Base::first - __other.first; }
112	};
113
114
115	/** @brief A triple of iterators. The usual iterator operations are
116	applied to all three child iterators.
117	*/
118	template<typename _Iterator1, typename _Iterator2, typename _Iterator3,
119	typename _IteratorCategory>
120	class _IteratorTriple
121	{
122	public:
123	typedef _IteratorCategory iterator_category;
124	typedef void value_type;
125	typedef typename std::iterator_traits<_Iterator1>::difference_type
126	difference_type;
127	typedef _IteratorTriple* pointer;
128	typedef _IteratorTriple& reference;
129
130	_Iterator1 _M_first;
131	_Iterator2 _M_second;
132	_Iterator3 _M_third;
133
134	_IteratorTriple() { }
135
136	_IteratorTriple(const _Iterator1& __first, const _Iterator2& __second,
137	const _Iterator3& __third)
138	{
139	_M_first = __first;
140	_M_second = __second;
141	_M_third = __third;
142	}
143
144	// Pre-increment operator.
145	_IteratorTriple&
146	operator++()
147	{
148	++_M_first;
149	++_M_second;
150	++_M_third;
151	return *this;
152	}
153
154	// Post-increment operator.
155	const _IteratorTriple
156	operator++(int)
157	{ return _IteratorTriple(_M_first++, _M_second++, _M_third++); }
158
159	// Pre-decrement operator.
160	_IteratorTriple&
161	operator--()
162	{
163	--_M_first;
164	--_M_second;
165	--_M_third;
166	return *this;
167	}
168
169	// Post-decrement operator.
170	const _IteratorTriple
171	operator--(int)
172	{ return _IteratorTriple(_M_first--, _M_second--, _M_third--); }
173
174	// Type conversion.
175	operator _Iterator3() const
176	{ return _M_third; }
177
178	_IteratorTriple&
179	operator=(const _IteratorTriple& __other)
180	{
181	_M_first = __other._M_first;
182	_M_second = __other._M_second;
183	_M_third = __other._M_third;
184	return *this;
185	}
186
187	_IteratorTriple
188	operator+(difference_type __delta) const
189	{ return _IteratorTriple(_M_first + __delta, _M_second + __delta,
190	_M_third + __delta); }
191
192	difference_type
193	operator-(const _IteratorTriple& __other) const
194	{ return _M_first - __other._M_first; }
195	};
196	}
197
198	#endif /* _GLIBCXX_PARALLEL_ITERATOR_H */