This commit was manufactured by cvs2svn to create tag

'Version_1_21_0'.

[SVN r9525]

include/boost/counting_iterator.hpp

@@ -28,6 +28,14 @@
 //     Incrementable.
 // 
 // Revision History
+// 14 Feb 2001  Removed unnecessary typedefs from counting_iterator_traits
+//              (Jeremy Siek)
+// 11 Feb 2001  Use BOOST_STATIC_CONSTANT (Dave Abrahams)
+// 11 Feb 2001  Clean up after John Maddocks's (finally effective!) Borland
+//              fixes (David Abrahams).
+// 10 Feb 2001  Use new iterator_adaptor<> interface (David Abrahams)
+// 10 Feb 2001  Rolled in supposed Borland fixes from John Maddock, but not
+//              seeing any improvement yet (David Abrahams)
 // 09 Feb 2001  Factored out is_numeric computation. Borland still
 //              unhappy :( (David Abrahams)
 // 08 Feb 2001  Beginning of a failed attempt to appease Borland
@@ -126,15 +134,16 @@ namespace detail {
   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
-    };
+# ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
+    BOOST_STATIC_CONSTANT(bool, value = std::numeric_limits<T>::is_specialized);
+# else
+#  if !defined(__BORLANDC__)
+    BOOST_STATIC_CONSTANT(bool, value = (
+        boost::is_convertible<int,T>::value && boost::is_convertible<T,int>::value));
+#  else
+    BOOST_STATIC_CONSTANT(bool, value = ::boost::is_arithmetic<T>::value);
+#  endif
+# endif
   };
 
   // Compute the distance over arbitrary numeric and/or iterator types
@@ -152,14 +161,11 @@ 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;
+    typedef ::boost::detail::counting_iterator_traits_select<(
+        ::boost::detail::is_numeric<Incrementable>::value
+        )> binder;
+    typedef typename binder::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;
 };
@@ -182,9 +188,16 @@ struct counting_iterator_policies : public default_iterator_policies
 template <class Incrementable>
 struct counting_iterator_generator
 {
+    typedef counting_iterator_traits<Incrementable> traits;
+    
     typedef iterator_adaptor<Incrementable,
         counting_iterator_policies<Incrementable>,
-        counting_iterator_traits<Incrementable> > type;
+        Incrementable,
+        const Incrementable&,
+        const Incrementable*,
+        typename traits::iterator_category,
+        typename traits::difference_type
+    > type;
 };
 
 // Manufacture a counting iterator for an arbitrary incrementable type
@@ -192,9 +205,8 @@ 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);
+  typedef typename counting_iterator_generator<Incrementable>::type result_t;
+  return result_t(x);
 }
 
 

include/boost/function_output_iterator.hpp

@@ -0,0 +1,55 @@
+// (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,8 +5,10 @@
 // for any purpose.
 //
 // Revision History:
-// 04 Feb 2001  Support for user-defined iterator categories (David Abrahams)
-// 30 Jan 2001  Initial Checkin (David Abrahams)
+// 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)
 
 #ifndef BOOST_HALF_OPEN_RANGE_HPP_
 # define BOOST_HALF_OPEN_RANGE_HPP_
@@ -75,7 +77,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);
       }
   };
@@ -85,16 +87,18 @@ namespace detail {
 template <class Incrementable>
 struct half_open_range
 {
-    typedef iterator_adaptor<Incrementable,
-      counting_iterator_policies<Incrementable>,
-      counting_iterator_traits<Incrementable> > iterator;
+    typedef typename counting_iterator_generator<Incrementable>::type 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 boost::detail::iterator_traits<iterator>::iterator_category category;
+    typedef typename iter_t::iterator_category category;
+    typedef half_open_range<Incrementable> self;
 
  public:
-    typedef iterator const_iterator;
+    typedef iter_t 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;
@@ -130,7 +134,14 @@ 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/pending/iterator_tests.hpp

@@ -15,12 +15,14 @@
 # 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; }