This commit was manufactured by cvs2svn to create tag

'Version_1_20_2'.

[SVN r9073]

development/boost/iterator_concepts.hpp

@@ -0,0 +1,282 @@
+#ifndef BOOST_ITERATOR_CONCEPTS_HPP
+#define BOOST_ITERATOR_CONCEPTS_HPP
+
+#include <boost/concept_check.hpp>
+#include <boost/iterator_traits.hpp>
+
+namespace boost_concepts {
+  // Used a different namespace here (instead of "boost") so that the
+  // concept descriptions do not take for granted the names in
+  // namespace boost.
+
+
+  //===========================================================================
+
+  template <typename Iterator>
+  class ReadableIteratorConcept {
+  public:
+    typedef typename boost::iterator_traits<Iterator>::value_type value_type;
+    typedef typename boost::iterator_traits<Iterator>::reference reference;
+    typedef typename boost::iterator_traits<Iterator>::return_category 
+      return_category;
+
+    void constraints() {
+      boost::function_requires< boost::SGIAssignableConcept<Iterator> >();
+      boost::function_requires< boost::EqualityComparableConcept<Iterator> >();
+      boost::function_requires< boost::DefaultConstructibleConcept<Iterator> >();
+      
+      boost::function_requires< 
+        boost::ConvertibleConcept<return_category, boost::readable_iterator_tag> >();
+
+      reference r = *i; // or perhaps read(x)
+      value_type v(r);
+      boost::ignore_unused_variable_warning(v);
+    }
+    Iterator i;
+  };
+  
+  template <typename Iterator, typename ValueType>
+  class WritableIteratorConcept {
+  public:
+    typedef typename boost::iterator_traits<Iterator>::return_category 
+      return_category;
+
+    void constraints() {
+      boost::function_requires< boost::SGIAssignableConcept<Iterator> >();
+      boost::function_requires< boost::EqualityComparableConcept<Iterator> >();
+      boost::function_requires< boost::DefaultConstructibleConcept<Iterator> >();
+      
+      boost::function_requires< 
+        boost::ConvertibleConcept<return_category, boost::writable_iterator_tag> >();
+
+      *i = v; // an alternative could be something like write(x, v)
+    }
+    ValueType v;
+    Iterator i;
+  };
+  
+  template <typename Iterator>
+  class ConstantLvalueIteratorConcept {
+  public:
+    typedef typename boost::iterator_traits<Iterator>::value_type value_type;
+    typedef typename boost::iterator_traits<Iterator>::reference reference;
+    typedef typename boost::iterator_traits<Iterator>::return_category 
+      return_category;
+
+    void constraints() {
+      boost::function_requires< ReadableIteratorConcept<Iterator> >();
+      
+      boost::function_requires< 
+        boost::ConvertibleConcept<return_category, 
+          boost::constant_lvalue_iterator_tag> >();
+
+      typedef typename boost::require_same<reference, const value_type&>::type req;
+
+      reference v = *i;
+      boost::ignore_unused_variable_warning(v);
+    }
+    Iterator i;
+  };
+
+  template <typename Iterator>
+  class MutableLvalueIteratorConcept {
+  public:
+    typedef typename boost::iterator_traits<Iterator>::value_type value_type;
+    typedef typename boost::iterator_traits<Iterator>::reference reference;
+    typedef typename boost::iterator_traits<Iterator>::return_category 
+      return_category;
+
+    void constraints() {
+      boost::function_requires< ReadableIteratorConcept<Iterator> >();
+      boost::function_requires< WritableIteratorConcept<Iterator, value_type> >();
+      
+      boost::function_requires< 
+        boost::ConvertibleConcept<return_category, 
+          boost::constant_lvalue_iterator_tag> >();
+
+      typedef typename boost::require_same<reference, value_type&>::type req;
+
+      reference v = *i;
+      boost::ignore_unused_variable_warning(v);
+    }
+    Iterator i;
+  };
+  
+  //===========================================================================
+
+  template <typename Iterator>
+  class SinglePassIteratorConcept {
+  public:
+    typedef typename boost::iterator_traits<Iterator>::motion_category 
+      motion_category;
+    typedef typename boost::iterator_traits<Iterator>::difference_type
+      difference_type;
+
+    void constraints() {
+      boost::function_requires< boost::SGIAssignableConcept<Iterator> >();
+      boost::function_requires< boost::EqualityComparableConcept<Iterator> >();
+      boost::function_requires< boost::DefaultConstructibleConcept<Iterator> >();
+
+      boost::function_requires< 
+        boost::ConvertibleConcept<motion_category, 
+          boost::single_pass_iterator_tag> >();
+      
+      // difference_type must be a signed integral type
+
+      ++i;
+      (void)i++;
+    }
+    
+    Iterator i;
+  };
+  
+  template <typename Iterator>
+  class ForwardIteratorConcept {
+  public:
+    typedef typename boost::iterator_traits<Iterator>::motion_category 
+      motion_category;
+
+    void constraints() {
+      boost::function_requires< SinglePassIteratorConcept<Iterator> >();
+
+      boost::function_requires< 
+        boost::ConvertibleConcept<motion_category, 
+          boost::forward_iterator_tag> >();
+    }
+  };
+  
+  template <typename Iterator>
+  class BidirectionalIteratorConcept {
+  public:
+    typedef typename boost::iterator_traits<Iterator>::motion_category 
+      motion_category;
+
+    void constraints() {
+      boost::function_requires< ForwardIteratorConcept<Iterator> >();
+      
+      boost::function_requires< 
+        boost::ConvertibleConcept<motion_category, 
+          boost::bidirectional_iterator_tag> >();
+
+      --i;
+      (void)i--;
+    }
+    Iterator i;
+  };
+
+  template <typename Iterator>
+  class RandomAccessIteratorConcept {
+  public:
+    typedef typename boost::iterator_traits<Iterator>::motion_category 
+      motion_category;
+    typedef typename boost::iterator_traits<Iterator>::difference_type
+      difference_type;
+
+    void constraints() {
+      boost::function_requires< BidirectionalIteratorConcept<Iterator> >();
+
+      boost::function_requires< 
+        boost::ConvertibleConcept<motion_category, 
+          boost::random_access_iterator_tag> >();
+
+      i += n;
+      i = i + n;
+      i = n + i;
+      i -= n;
+      i = i - n;
+      n = i - j;
+    }
+    difference_type n;
+    Iterator i, j;
+  };
+
+  //===========================================================================
+
+  template <typename Iterator>
+  class ReadableRandomAccessIteratorConcept {
+  public:
+    typedef typename boost::iterator_traits<Iterator>::value_type value_type;
+    typedef typename boost::iterator_traits<Iterator>::reference reference;
+    typedef typename boost::iterator_traits<Iterator>::difference_type
+      difference_type;
+
+    void constraints() {
+      boost::function_requires< RandomAccessIteratorConcept<Iterator> >();
+      boost::function_requires< ReadableIteratorConcept<Iterator> >();
+      
+      reference r = i[n];
+      value_type v(r);
+      boost::ignore_unused_variable_warning(v);
+    }
+    difference_type n;
+    Iterator i;
+  };
+
+  template <typename Iterator>
+  class WritableRandomAccessIteratorConcept {
+  public:
+    typedef typename boost::iterator_traits<Iterator>::value_type value_type;
+    typedef typename boost::iterator_traits<Iterator>::difference_type
+      difference_type;
+
+    void constraints() {
+      boost::function_requires< RandomAccessIteratorConcept<Iterator> >();
+      boost::function_requires< WritableIteratorConcept<Iterator, value_type> >();
+
+      i[n] = v;
+      boost::ignore_unused_variable_warning(v);
+    }
+    difference_type n;
+    value_type v;
+    Iterator i;
+  };
+
+  template <typename Iterator>
+  class ConstantLvalueRandomAccessIteratorConcept {
+  public:
+    typedef typename boost::iterator_traits<Iterator>::value_type value_type;
+    typedef typename boost::iterator_traits<Iterator>::reference reference;
+    typedef typename boost::iterator_traits<Iterator>::difference_type
+      difference_type;
+
+    void constraints() {
+      boost::function_requires< RandomAccessIteratorConcept<Iterator> >();
+      boost::function_requires< ReadableIteratorConcept<Iterator> >();
+
+      typedef typename boost::require_same<reference, const value_type&>::type req;
+
+      reference v = i[n];
+      boost::ignore_unused_variable_warning(v);
+    }
+    difference_type n;
+    value_type v;
+    Iterator i;
+  };
+  
+  template <typename Iterator>
+  class MutableLvalueRandomAccessIteratorConcept {
+  public:
+    typedef typename boost::iterator_traits<Iterator>::value_type value_type;
+    typedef typename boost::iterator_traits<Iterator>::reference reference;
+    typedef typename boost::iterator_traits<Iterator>::difference_type
+      difference_type;
+
+    void constraints() {
+      boost::function_requires< RandomAccessIteratorConcept<Iterator> >();
+      boost::function_requires< WritableIteratorConcept<Iterator, value_type> >();
+      boost::function_requires< ReadableIteratorConcept<Iterator> >();
+
+      typedef typename boost::require_same<reference, value_type&>::type req;
+
+      reference v = i[n];
+      boost::ignore_unused_variable_warning(v);
+    }
+    difference_type n;
+    value_type v;
+    Iterator i;
+  };
+  
+} // namespace boost_concepts
+
+
+#endif // BOOST_ITERATOR_CONCEPTS_HPP

development/boost/iterator_traits.hpp

@@ -0,0 +1,60 @@
+#ifndef BOOST_ITERATOR_TRAITS_HPP
+#define BOOST_ITERATOR_TRAITS_HPP
+
+#include <boost/config.hpp>
+#include <boost/type_traits.hpp>
+
+namespace boost {
+  
+  template <typename Iterator>
+  struct iterator_traits {
+    typedef typename Iterator::value_type value_type;
+    typedef typename Iterator::reference reference;
+    typedef typename Iterator::pointer pointer;
+    typedef typename Iterator::difference_type difference_type;
+    typedef typename Iterator::return_category return_category;
+    typedef typename Iterator::motion_category motion_category;
+  };
+
+  // Motion Categories
+  struct single_pass_iterator_tag { };
+  struct forward_iterator_tag : public single_pass_iterator_tag { };
+  struct bidirectional_iterator_tag : public forward_iterator_tag { };
+  struct random_access_iterator_tag : public bidirectional_iterator_tag { };
+  
+  // Return Type Categories
+  struct readable_iterator_tag { };
+  struct writable_iterator_tag { };
+  struct mutable_lvalue_iterator_tag : virtual public writable_iterator_tag,
+    virtual public readable_iterator_tag { };
+  struct constant_lvalue_iterator_tag : public readable_iterator_tag { };
+  
+#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+
+  namespace detail {
+    template <bool IsConst>
+    struct pointer_return_category {
+      typedef constant_lvalue_iterator_tag type;
+    };
+    template <>
+    struct pointer_return_category<false> {
+      typedef mutable_lvalue_iterator_tag type;
+    };
+  } // namespace detail
+
+  template <typename T>
+  struct iterator_traits<T*> {
+    typedef T value_type;
+    typedef T& reference;
+    typedef T* pointer;
+    typedef std::ptrdiff_t difference_type;
+    typedef typename detail::pointer_return_category<is_const<T>::value>::type
+      return_category;
+    typedef random_access_iterator_tag motion_category;
+  };
+
+#endif
+
+} // namespace boost
+
+#endif // BOOST_ITERATOR_TRAITS_HPP

development/libs/iterator/concept_tests.cpp

@@ -0,0 +1,13 @@
+#include <boost/iterator_concepts.hpp>
+
+int
+main()
+{
+  boost::function_requires< 
+    boost_concepts::MutableLvalueRandomAccessIteratorConcept<int*> >();
+
+  boost::function_requires< 
+    boost_concepts::ConstantLvalueRandomAccessIteratorConcept<const int*> >();
+
+  return 0;
+}

include/boost/counting_iterator.hpp

@@ -0,0 +1,203 @@
+// (C) Copyright David Abrahams and Jeremy Siek 2000-2001. Permission to copy,
+// use, modify, sell and distribute this software is granted provided this
+// copyright notice appears in all copies. This software is provided "as is"
+// without express or implied warranty, and with no claim as to its suitability
+// for any purpose.
+//
+// See http://www.boost.org for most recent version including documentation.
+//
+// Supplies:
+//
+//   template <class Incrementable> class counting_iterator_traits;
+//   template <class Incrementable> class counting_iterator_policies;
+//
+//     Iterator traits and policies for adapted iterators whose dereferenced
+//     value progresses through consecutive values of Incrementable when the
+//     iterator is derferenced.
+//
+//   template <class Incrementable> struct counting_iterator_generator;
+//
+//     A "type generator" whose nested type "type" is a counting iterator as
+//     described above.
+//
+//   template <class Incrementable>
+//     typename counting_iterator_generator<Incrementable>::type
+//     make_counting_iterator(Incrementable);
+//
+//     A function which produces an adapted counting iterator over values of
+//     Incrementable.
+// 
+// Revision History
+// 09 Feb 2001  Factored out is_numeric computation. Borland still
+//              unhappy :( (David Abrahams)
+// 08 Feb 2001  Beginning of a failed attempt to appease Borland
+//              (David Abrahams)
+// 07 Feb 2001  rename counting_iterator() -> make_counting_iterator()
+//              (David Abrahams)        
+// 04 Feb 2001  Added counting_iterator_generator; updated comments
+//              (David Abrahams)
+// 24 Jan 2001  initial revision, based on Jeremy Siek's
+//              boost/pending/integer_range.hpp (David Abrahams)
+
+#ifndef BOOST_COUNTING_ITERATOR_HPP_DWA20000119
+# define BOOST_COUNTING_ITERATOR_HPP_DWA20000119
+
+# include <boost/config.hpp>
+# include <boost/detail/iterator.hpp>
+# include <boost/iterator_adaptors.hpp>
+# include <boost/type_traits.hpp>
+# include <boost/detail/numeric_traits.hpp>
+# include <boost/static_assert.hpp>
+# ifndef BOOST_NO_LIMITS
+#  include <limits>
+# endif
+
+namespace boost {
+
+namespace detail {
+
+  // Template class counting_iterator_traits_select -- choose an
+  // iterator_category and difference_type for a counting_iterator at
+  // compile-time based on whether or not it wraps an integer or an iterator,
+  // using "poor man's partial specialization".
+  template <bool is_integer> struct counting_iterator_traits_select;
+
+  // Incrementable is an iterator type
+  template <>
+  struct counting_iterator_traits_select<false>
+  {
+      template <class Incrementable>
+      struct traits
+      {
+       private:
+          typedef boost::detail::iterator_traits<Incrementable> x;
+       public:
+          typedef typename x::iterator_category iterator_category;
+          typedef typename x::difference_type difference_type;
+      };
+  };
+
+  // Incrementable is a numeric type
+  template <>
+  struct counting_iterator_traits_select<true>
+  {
+      template <class Incrementable>
+      struct traits
+      {
+          typedef typename
+            boost::detail::numeric_traits<Incrementable>::difference_type
+          difference_type;
+          typedef std::random_access_iterator_tag iterator_category;
+      };
+  };
+
+  // Template class distance_policy_select -- choose a policy for computing the
+  // distance between counting_iterators at compile-time based on whether or not
+  // the iterator wraps an integer or an iterator, using "poor man's partial
+  // specialization".
+
+  template <bool is_integer> struct distance_policy_select;
+
+  // A policy for wrapped iterators
+  template <>
+  struct distance_policy_select<false>
+  {
+      template <class Distance, class Incrementable>
+      struct policy {
+          static Distance distance(Incrementable x, Incrementable y)
+              { return boost::detail::distance(x, y); }
+      };
+  };
+
+  // A policy for wrapped numbers
+  template <>
+  struct distance_policy_select<true>
+  {
+      template <class Distance, class Incrementable>
+      struct policy {
+          static Distance distance(Incrementable x, Incrementable y)
+              { return numeric_distance(x, y); }
+      };
+  };
+
+  // Try to detect numeric types at compile time in ways compatible with the
+  // limitations of the compiler and library.
+  template <class T>
+  struct is_numeric {
+    // For a while, this wasn't true, but we rely on it below. This is a regression assert.
+    BOOST_STATIC_ASSERT(::boost::is_integral<char>::value);
+    enum { value = 
+#ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
+        std::numeric_limits<T>::is_specialized
+#elif defined(__BORLANDC__)
+        ::boost::is_integral<T>::value
+#else
+        boost::is_convertible<int,T>::value && boost::is_convertible<T,int>::value
+#endif
+    };
+  };
+
+  // Compute the distance over arbitrary numeric and/or iterator types
+  template <class Distance, class Incrementable>
+  Distance any_distance(Incrementable start, Incrementable finish, Distance* = 0)
+  {
+    
+      return distance_policy_select<(
+          is_numeric<Incrementable>::value)>::template
+          policy<Distance, Incrementable>::distance(start, finish);
+  }
+  
+} // namespace detail
+
+template <class Incrementable>
+struct counting_iterator_traits {
+ private:
+    enum {numeric = detail::is_numeric<Incrementable>::value };
+    typedef typename detail::counting_iterator_traits_select<(
+        numeric
+        )>::template traits<Incrementable> traits;
+ public:
+    typedef Incrementable value_type;
+    typedef const Incrementable& reference;
+    typedef const value_type* pointer;
+    typedef typename traits::difference_type difference_type;
+    typedef typename traits::iterator_category iterator_category;
+};
+
+template <class Incrementable>
+struct counting_iterator_policies : public default_iterator_policies
+{
+    const Incrementable& dereference(type<const Incrementable&>, const Incrementable& i) const
+        { return i; }
+
+    template <class Difference, class Iterator1, class Iterator2>
+    Difference distance(type<Difference>, const Iterator1& x,
+                        const Iterator2& y) const
+    {
+        return boost::detail::any_distance<Difference>(x, y);//,(Difference*)());
+    }
+};
+
+// A type generator for counting iterators
+template <class Incrementable>
+struct counting_iterator_generator
+{
+    typedef iterator_adaptor<Incrementable,
+        counting_iterator_policies<Incrementable>,
+        counting_iterator_traits<Incrementable> > type;
+};
+
+// Manufacture a counting iterator for an arbitrary incrementable type
+template <class Incrementable>
+inline typename counting_iterator_generator<Incrementable>::type
+make_counting_iterator(Incrementable x)
+{
+    return iterator_adaptor<Incrementable,
+        counting_iterator_policies<Incrementable>,
+        counting_iterator_traits<Incrementable> >(x);
+}
+
+
+} // namespace boost
+
+#endif // BOOST_COUNTING_ITERATOR_HPP_DWA20000119

include/boost/function_output_iterator.hpp

@@ -1,55 +0,0 @@
-// (C) Copyright Jeremy Siek 2001. Permission to copy, use, modify,
-// sell and distribute this software is granted provided this
-// copyright notice appears in all copies. This software is provided
-// "as is" without express or implied warranty, and with no claim as
-// to its suitability for any purpose.
-
-// Revision History:
-
-// 27 Feb 2001   Jeremy Siek
-//      Initial checkin.
-
-#ifndef BOOST_FUNCTION_OUTPUT_ITERATOR_HPP
-#define BOOST_FUNCTION_OUTPUT_ITERATOR_HPP
-
-#include <iterator>
-
-namespace boost {
-
-  template <class UnaryFunction>
-  class function_output_iterator {
-    typedef function_output_iterator self;
-  public:
-    typedef std::output_iterator_tag iterator_category;
-    typedef void                value_type;
-    typedef void                difference_type;
-    typedef void                pointer;
-    typedef void                reference;
-
-    explicit function_output_iterator(const UnaryFunction& f = UnaryFunction())
-      : m_f(f) {}
-
-    struct output_proxy {
-      output_proxy(UnaryFunction& f) : m_f(f) { }
-      template <class T> output_proxy& operator=(const T& value) {
-        m_f(value); 
-        return *this; 
-      }
-      UnaryFunction& m_f;
-    };
-    output_proxy operator*() { return output_proxy(m_f); }
-    self& operator++() { return *this; } 
-    self& operator++(int) { return *this; }
-  private:
-    UnaryFunction m_f;
-  };
-
-  template <class UnaryFunction>
-  inline function_output_iterator<UnaryFunction>
-  make_function_output_iterator(const UnaryFunction& f = UnaryFunction()) {
-    return function_output_iterator<UnaryFunction>(f);
-  }
-
-} // namespace boost
-
-#endif // BOOST_FUNCTION_OUTPUT_ITERATOR_HPP

include/boost/half_open_range.hpp

@@ -5,10 +5,8 @@
 // for any purpose.
 //
 // Revision History:
-// 11 Feb 2001  Use new iterator_adaptor interface, Fixes for Borland.
-//              (Dave Abrahams)
-// 04 Feb 2001  Support for user-defined iterator categories (Dave Abrahams)
-// 30 Jan 2001  Initial Checkin (Dave Abrahams)
+// 04 Feb 2001  Support for user-defined iterator categories (David Abrahams)
+// 30 Jan 2001  Initial Checkin (David Abrahams)
 
 #ifndef BOOST_HALF_OPEN_RANGE_HPP_
 # define BOOST_HALF_OPEN_RANGE_HPP_
@@ -77,7 +75,7 @@ namespace detail {
       static const Incrementable choose(const Incrementable& start, const Incrementable& finish)
       {
           return finish_chooser<(
-              ::boost::is_convertible<Category*,std::random_access_iterator_tag*>::value
+              boost::is_convertible<Category,std::random_access_iterator_tag>::value
               )>::template rebind<Incrementable>::choose(start, finish);
       }
   };
@@ -87,29 +85,27 @@ namespace detail {
 template <class Incrementable>
 struct half_open_range
 {
-    typedef typename counting_iterator_generator<Incrementable>::type iterator;
+    typedef iterator_adaptor<Incrementable,
+      counting_iterator_policies<Incrementable>,
+      counting_iterator_traits<Incrementable> > iterator;
 
  private: // utility type definitions
-    // Using iter_t prevents compiler confusion with boost::iterator
-    typedef typename counting_iterator_generator<Incrementable>::type iter_t;
-
     typedef std::less<Incrementable> less_value;
-    typedef typename iter_t::iterator_category category;
-    typedef half_open_range<Incrementable> self;
+    typedef typename boost::detail::iterator_traits<iterator>::iterator_category category;
 
  public:
-    typedef iter_t const_iterator;
-    typedef typename iterator::value_type value_type;
-    typedef typename iterator::difference_type difference_type;
-    typedef typename iterator::reference reference;
-    typedef typename iterator::reference const_reference;
-    typedef typename iterator::pointer pointer;
-    typedef typename iterator::pointer const_pointer;
+    typedef iterator const_iterator;
+    typedef typename counting_iterator_traits<Incrementable>::value_type value_type;
+    typedef typename counting_iterator_traits<Incrementable>::difference_type difference_type;
+    typedef typename counting_iterator_traits<Incrementable>::reference reference;
+    typedef typename counting_iterator_traits<Incrementable>::reference const_reference;
+    typedef typename counting_iterator_traits<Incrementable>::pointer pointer;
+    typedef typename counting_iterator_traits<Incrementable>::pointer const_pointer;
     
     // It would be nice to select an unsigned type, but this is appropriate
     // since the library makes an attempt to select a difference_type which can
     // hold the difference between any two iterators.
-    typedef typename iterator::difference_type size_type;
+    typedef typename counting_iterator_traits<Incrementable>::difference_type size_type;
 
     half_open_range(Incrementable start, Incrementable finish)
         : m_start(start),
@@ -134,14 +130,7 @@ struct half_open_range
 #endif
               )
         {}
-
-    half_open_range& operator=(const self& x)
-    {
-        m_start = x.m_start;
-        m_finish = x.m_finish;
-        return *this;
-    }
-    
+        
     half_open_range& operator=(const std::pair<Incrementable,Incrementable>& x)
     {
         m_start = x.first;

include/boost/iterator.hpp

@@ -5,7 +5,7 @@
 //  in all copies. This software is provided "as is" without express or implied
 //  warranty, and with no claim as to its suitability for any purpose.
 
-//  See http://www.boost.org/libs/utility for documentation.
+//  See http://www.boost.org for most recent version including documentation.
 
 //  Revision History
 //  12 Jan 01 added <cstddef> for std::ptrdiff_t (Jens Maurer)
@@ -21,7 +21,7 @@
 
 namespace boost
 {
-# if defined(BOOST_NO_STD_ITERATOR) && !defined(BOOST_MSVC_STD_ITERATOR)
+# ifdef BOOST_NO_STD_ITERATOR
   template <class Category, class T,
     class Distance = std::ptrdiff_t,
     class Pointer = T*, class Reference = T&>

include/boost/pending/iterator_tests.hpp

@@ -5,10 +5,6 @@
 // test suite for STL concepts such as iterators and containers.
 //
 // Revision History:
-// 28 Apr 2002  Fixed input iterator requirements.
-//              For a == b a++ == b++ is no longer required.
-//              See 24.1.1/3 for details.
-//              (Thomas Witt)
 // 08 Feb 2001  Fixed bidirectional iterator test so that
 //              --i is no longer a precondition.
 //              (Jeremy Siek)
@@ -19,14 +15,12 @@
 # include <assert.h>
 # include <boost/type_traits.hpp>
 # include <boost/static_assert.hpp>
-# include <boost/concept_archetype.hpp> // for detail::dummy_constructor
 
 namespace boost {
 
   // use this for the value type
 struct dummyT { 
   dummyT() { }
-  dummyT(detail::dummy_constructor) { }
   dummyT(int x) : m_x(x) { }
   int foo() const { return m_x; } 
   bool operator==(const dummyT& d) const { return m_x == d.m_x; }
@@ -78,40 +72,22 @@ void mutable_trivial_iterator_test(const Iterator i, const Iterator j, T val)
 template <class Iterator, class T>
 void input_iterator_test(Iterator i, T v1, T v2) 
 {
-  Iterator i1(i);
+  Iterator i1 = i, i2 = i;
 
-  assert(i == i1);
-  assert(!(i != i1));
+  assert(i == i1++);
+  assert(i != ++i2);
 
-  // I can see no generic way to create an input iterator
-  // that is in the domain of== of i and != i.
-  // The following works for istream_iterator but is not
-  // guaranteed to work for arbitrary input iterators.
-  //
-  //   Iterator i2;
-  //
-  //   assert(i != i2);
-  //   assert(!(i == i2));
+  trivial_iterator_test(i, i1, v1);
+  trivial_iterator_test(i, i2, v1);
 
-  assert(*i1 == v1);
-  assert(*i  == v1);
-
-  // we cannot test for equivalence of (void)++i & (void)i++
-  // as i is only guaranteed to be single pass.
-  assert(*i++ == v1);
-
-  i1 = i;
-
-  assert(i == i1);
-  assert(!(i != i1));
-
-  assert(*i1 == v2);
-  assert(*i  == v2);
-
-  // i is dereferencable, so it must be incrementable.
   ++i;
+  assert(i == i1);
+  assert(i == i2);
+  ++i1;
+  ++i2;
 
-  // how to test for operator-> ?
+  trivial_iterator_test(i, i1, v2);
+  trivial_iterator_test(i, i2, v2);
 }
 
 // how to test output iterator?
@@ -146,23 +122,6 @@ void forward_iterator_test(Iterator i, T v1, T v2)
 {
   input_iterator_test(i, v1, v2);
 
-  Iterator i1 = i, i2 = i;
-
-  assert(i == i1++);
-  assert(i != ++i2);
-
-  trivial_iterator_test(i, i1, v1);
-  trivial_iterator_test(i, i2, v1);
-
-  ++i;
-  assert(i == i1);
-  assert(i == i2);
-  ++i1;
-  ++i2;
-
-  trivial_iterator_test(i, i1, v2);
-  trivial_iterator_test(i, i2, v2);
-
  // borland doesn't allow non-type template parameters
 # if !defined(__BORLANDC__) || (__BORLANDC__ > 0x551)
   lvalue_test<(boost::is_pointer<Iterator>::value)>::check(i);

include/boost/shared_container_iterator.hpp

@@ -1,59 +0,0 @@
-// (C) Copyright Ronald Garcia 2002. Permission to copy, use, modify, sell and
-// distribute this software is granted provided this copyright notice appears
-// in all copies. This software is provided "as is" without express or implied
-// warranty, and with no claim as to its suitability for any purpose.
-
-// See http://www.boost.org/libs/utility/shared_container_iterator.html for documentation.
-
-#ifndef SHARED_CONTAINER_ITERATOR_RG08102002_HPP
-#define SHARED_CONTAINER_ITERATOR_RG08102002_HPP
-
-#include "boost/iterator_adaptors.hpp"
-#include "boost/shared_ptr.hpp"
-#include <utility>
-
-namespace boost {
-
-template <typename Container>
-struct shared_container_iterator_policies :
-  public boost::default_iterator_policies {
-  typedef boost::shared_ptr<Container> container_ref_t;
-  container_ref_t container_ref;
-  shared_container_iterator_policies(container_ref_t const& c) :
-    container_ref(c) { }
-  shared_container_iterator_policies() { }
-};
-
-
-template <typename Container>
-class shared_container_iterator_generator {
-  typedef typename Container::iterator iterator;
-  typedef shared_container_iterator_policies<Container> policy;
-public:
-  typedef boost::iterator_adaptor<iterator,policy> type;
-};
-
-template <typename Container>
-typename shared_container_iterator_generator<Container>::type
-make_shared_container_iterator(typename Container::iterator iter,
-			       boost::shared_ptr<Container> const& container) {
-  typedef typename shared_container_iterator_generator<Container>::type
-    iterator;
-  typedef shared_container_iterator_policies<Container> policy;
-  return iterator(iter,policy(container));
-}
-
-template <typename Container>
-std::pair<
-  typename shared_container_iterator_generator<Container>::type,
-  typename shared_container_iterator_generator<Container>::type>
-make_shared_container_range(boost::shared_ptr<Container> const& container) {
-  return
-    std::make_pair(
-      make_shared_container_iterator(container->begin(),container),
-      make_shared_container_iterator(container->end(),container));
-}
-
-
-} // namespace boost
-#endif  // SHARED_CONTAINER_ITERATOR_RG08102002_HPP