Imported gcc-4.4.3

[msp430-gcc.git] / libstdc++-v3 / include / parallel / iterator.h

diff --git a/libstdc++-v3/include/parallel/iterator.h b/libstdc++-v3/include/parallel/iterator.h
new file mode 100644 (file)
index 0000000..c9bfd5a
--- /dev/null
+++ b/libstdc++-v3/include/parallel/iterator.h
@@ -0,0 +1,200 @@
+// -*- C++ -*-
+
+// Copyright (C) 2007, 2008, 2009 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 iterator_pair : public std::pair<Iterator1, Iterator2>
+    {
+    private:
+      typedef iterator_pair<Iterator1, Iterator2, IteratorCategory> type;
+      typedef std::pair<Iterator1, Iterator2> base_type;
+
+    public:
+      typedef IteratorCategory iterator_category;
+      typedef void value_type;
+
+      typedef std::iterator_traits<Iterator1> traits_type;
+      typedef typename traits_type::difference_type difference_type;
+      typedef type* pointer;
+      typedef type& reference;
+
+      iterator_pair() { }
+
+      iterator_pair(const Iterator1& first, const Iterator2& second) 
+      : base_type(first, second) { }
+
+      // Pre-increment operator.
+      type&
+      operator++()
+      {
+       ++base_type::first;
+       ++base_type::second;
+       return *this;
+      }
+
+      // Post-increment operator.
+      const type
+      operator++(int)
+      { return type(base_type::first++, base_type::second++); }
+
+      // Pre-decrement operator.
+      type&
+      operator--()
+      {
+       --base_type::first;
+       --base_type::second;
+       return *this;
+      }
+
+      // Post-decrement operator.
+      const type
+      operator--(int)
+      { return type(base_type::first--, base_type::second--); }
+
+      // Type conversion.
+      operator Iterator2() const
+      { return base_type::second; }
+
+      type&
+      operator=(const type& other)
+      {
+       base_type::first = other.first;
+       base_type::second = other.second;
+       return *this;
+      }
+
+      type
+      operator+(difference_type delta) const
+      { return type(base_type::first + delta, base_type::second + delta); }
+
+      difference_type
+      operator-(const type& other) const
+      { return base_type::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 iterator_triple
+    {
+    private:
+      typedef iterator_triple<Iterator1, Iterator2, Iterator3,
+                             IteratorCategory> type;
+
+    public:
+      typedef IteratorCategory iterator_category;
+      typedef void value_type;
+      typedef typename std::iterator_traits<Iterator1>::difference_type
+                                                            difference_type;
+      typedef type* pointer;
+      typedef type& reference;
+
+      Iterator1 first;
+      Iterator2 second;
+      Iterator3 third;
+
+      iterator_triple() { }
+
+      iterator_triple(const Iterator1& _first, const Iterator2& _second,
+                     const Iterator3& _third)
+      {
+       first = _first;
+       second = _second;
+       third = _third;
+      }
+
+      // Pre-increment operator.
+      type&
+      operator++()
+      {
+       ++first;
+       ++second;
+       ++third;
+       return *this;
+      }
+
+      // Post-increment operator.
+      const type
+      operator++(int)
+      { return type(first++, second++, third++); }
+
+      // Pre-decrement operator.
+      type&
+      operator--()
+      {
+       --first;
+       --second;
+       --third;
+       return *this;
+      }
+
+      // Post-decrement operator.
+      const type
+      operator--(int)
+      { return type(first--, second--, third--); }
+
+      // Type conversion.
+      operator Iterator3() const
+      { return third; }
+
+      type&
+      operator=(const type& other)
+      {
+       first = other.first;
+       second = other.second;
+       third = other.third;
+       return *this;
+      }
+
+      type
+      operator+(difference_type delta) const
+      { return type(first + delta, second + delta, third + delta); }
+
+      difference_type
+      operator-(const type& other) const
+      { return first - other.first; }
+  };
+}
+
+#endif /* _GLIBCXX_PARALLEL_ITERATOR_H */