contrib/gcc-4.4/libstdc++-v3/include/parallel/iterator.h

   1 // -*- C++ -*-
   2
   3 // Copyright (C) 2007, 2008, 2009 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, typename IteratorCategory>
  44     class iterator_pair : public std::pair<Iterator1, Iterator2>
  45     {
  46     private:
  47       typedef iterator_pair<Iterator1, Iterator2, IteratorCategory> type;
  48       typedef std::pair<Iterator1, Iterator2> base_type;
  49
  50     public:
  51       typedef IteratorCategory iterator_category;
  52       typedef void value_type;
  53
  54       typedef std::iterator_traits<Iterator1> traits_type;
  55       typedef typename traits_type::difference_type difference_type;
  56       typedef type* pointer;
  57       typedef type& reference;
  58
  59       iterator_pair() { }
  60
  61       iterator_pair(const Iterator1& first, const Iterator2& second)
  62       : base_type(first, second) { }
  63
  64       // Pre-increment operator.
  65       type&
  66       operator++()
  67       {
  68         ++base_type::first;
  69         ++base_type::second;
  70         return *this;
  71       }
  72
  73       // Post-increment operator.
  74       const type
  75       operator++(int)
  76       { return type(base_type::first++, base_type::second++); }
  77
  78       // Pre-decrement operator.
  79       type&
  80       operator--()
  81       {
  82         --base_type::first;
  83         --base_type::second;
  84         return *this;
  85       }
  86
  87       // Post-decrement operator.
  88       const type
  89       operator--(int)
  90       { return type(base_type::first--, base_type::second--); }
  91
  92       // Type conversion.
  93       operator Iterator2() const
  94       { return base_type::second; }
  95
  96       type&
  97       operator=(const type& other)
  98       {
  99         base_type::first = other.first;
 100         base_type::second = other.second;
 101         return *this;
 102       }
 103
 104       type
 105       operator+(difference_type delta) const
 106       { return type(base_type::first + delta, base_type::second + delta); }
 107
 108       difference_type
 109       operator-(const type& other) const
 110       { return base_type::first - other.first; }
 111   };
 112
 113
 114   /** @brief A triple of iterators. The usual iterator operations are
 115       applied to all three child iterators.
 116    */
 117   template<typename Iterator1, typename Iterator2, typename Iterator3,
 118            typename IteratorCategory>
 119     class iterator_triple
 120     {
 121     private:
 122       typedef iterator_triple<Iterator1, Iterator2, Iterator3,
 123                               IteratorCategory> type;
 124
 125     public:
 126       typedef IteratorCategory iterator_category;
 127       typedef void value_type;
 128       typedef typename std::iterator_traits<Iterator1>::difference_type
 129                                                             difference_type;
 130       typedef type* pointer;
 131       typedef type& reference;
 132
 133       Iterator1 first;
 134       Iterator2 second;
 135       Iterator3 third;
 136
 137       iterator_triple() { }
 138
 139       iterator_triple(const Iterator1& _first, const Iterator2& _second,
 140                       const Iterator3& _third)
 141       {
 142         first = _first;
 143         second = _second;
 144         third = _third;
 145       }
 146
 147       // Pre-increment operator.
 148       type&
 149       operator++()
 150       {
 151         ++first;
 152         ++second;
 153         ++third;
 154         return *this;
 155       }
 156
 157       // Post-increment operator.
 158       const type
 159       operator++(int)
 160       { return type(first++, second++, third++); }
 161
 162       // Pre-decrement operator.
 163       type&
 164       operator--()
 165       {
 166         --first;
 167         --second;
 168         --third;
 169         return *this;
 170       }
 171
 172       // Post-decrement operator.
 173       const type
 174       operator--(int)
 175       { return type(first--, second--, third--); }
 176
 177       // Type conversion.
 178       operator Iterator3() const
 179       { return third; }
 180
 181       type&
 182       operator=(const type& other)
 183       {
 184         first = other.first;
 185         second = other.second;
 186         third = other.third;
 187         return *this;
 188       }
 189
 190       type
 191       operator+(difference_type delta) const
 192       { return type(first + delta, second + delta, third + delta); }
 193
 194       difference_type
 195       operator-(const type& other) const
 196       { return first - other.first; }
 197   };
 198 }
 199
 200 #endif /* _GLIBCXX_PARALLEL_ITERATOR_H */