Change UnaryFunction -> UnaryFunc to get out of the way of the concept checking class for VC6.

[SVN r33898]

include/boost/iterator/transform_iterator.hpp

@@ -37,10 +37,10 @@ namespace boost
   namespace detail 
   {
 
-    template <class UnaryFunction>
+    template <class UnaryFunc>
     struct function_object_result
     {
-      typedef typename UnaryFunction::result_type type;
+      typedef typename UnaryFunc::result_type type;
     };
 
 #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
@@ -52,7 +52,7 @@ namespace boost
 #endif
 
     // Compute the iterator_adaptor instantiation to be used for transform_iterator
-    template <class UnaryFunction, class Iterator, class Reference, class Value>
+    template <class UnaryFunc, class Iterator, class Reference, class Value>
     struct transform_iterator_base
     {
      private:
@@ -62,7 +62,7 @@ namespace boost
         // proposal (e.g. using Doug's result_of)?
         typedef typename ia_dflt_help<
             Reference
-          , function_object_result<UnaryFunction>
+          , function_object_result<UnaryFunc>
         >::type reference;
 
         // To get the default for Value: remove any reference on the
@@ -77,7 +77,7 @@ namespace boost
 
      public:
         typedef iterator_adaptor<
-            transform_iterator<UnaryFunction, Iterator, Reference, Value>
+            transform_iterator<UnaryFunc, Iterator, Reference, Value>
           , Iterator
           , cv_value_type
           , use_default    // Leave the traversal category alone
@@ -86,12 +86,12 @@ namespace boost
     };
   }
 
-  template <class UnaryFunction, class Iterator, class Reference, class Value>
+  template <class UnaryFunc, class Iterator, class Reference, class Value>
   class transform_iterator
-    : public detail::transform_iterator_base<UnaryFunction, Iterator, Reference, Value>::type
+    : public detail::transform_iterator_base<UnaryFunc, Iterator, Reference, Value>::type
   {
     typedef typename
-    detail::transform_iterator_base<UnaryFunction, Iterator, Reference, Value>::type
+    detail::transform_iterator_base<UnaryFunc, Iterator, Reference, Value>::type
     super_t;
 
     friend class iterator_core_access;
@@ -99,7 +99,7 @@ namespace boost
   public:
     transform_iterator() { }
 
-    transform_iterator(Iterator const& x, UnaryFunction f)
+    transform_iterator(Iterator const& x, UnaryFunc f)
       : super_t(x), m_f(f) { }
 
     explicit transform_iterator(Iterator const& x)
@@ -108,9 +108,9 @@ namespace boost
         // Pro8 is a little too aggressive about instantiating the
         // body of this function.
 #if !BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3003))
-        // don't provide this constructor if UnaryFunction is a
+        // don't provide this constructor if UnaryFunc is a
         // function pointer type, since it will be 0.  Too dangerous.
-        BOOST_STATIC_ASSERT(is_class<UnaryFunction>::value);
+        BOOST_STATIC_ASSERT(is_class<UnaryFunc>::value);
 #endif 
     }
 
@@ -123,13 +123,13 @@ namespace boost
          transform_iterator<OtherUnaryFunction, OtherIterator, OtherReference, OtherValue> const& t
        , typename enable_if_convertible<OtherIterator, Iterator>::type* = 0
 #if !BOOST_WORKAROUND(BOOST_MSVC, == 1310)
-       , typename enable_if_convertible<OtherUnaryFunction, UnaryFunction>::type* = 0
+       , typename enable_if_convertible<OtherUnaryFunction, UnaryFunc>::type* = 0
 #endif 
     )
       : super_t(t.base()), m_f(t.functor())
    {}
 
-    UnaryFunction functor() const
+    UnaryFunc functor() const
       { return m_f; }
 
   private:
@@ -138,38 +138,38 @@ namespace boost
 
     // Probably should be the initial base class so it can be
     // optimized away via EBO if it is an empty class.
-    UnaryFunction m_f;
+    UnaryFunc m_f;
   };
 
-  template <class UnaryFunction, class Iterator>
+  template <class UnaryFunc, class Iterator>
-  transform_iterator<UnaryFunction, Iterator>
+  transform_iterator<UnaryFunc, Iterator>
-  make_transform_iterator(Iterator it, UnaryFunction fun)
+  make_transform_iterator(Iterator it, UnaryFunc fun)
   {
-      return transform_iterator<UnaryFunction, Iterator>(it, fun);
+      return transform_iterator<UnaryFunc, Iterator>(it, fun);
   }
 
-  // Version which allows explicit specification of the UnaryFunction
+  // Version which allows explicit specification of the UnaryFunc
   // type.
   //
-  // This generator is not provided if UnaryFunction is a function
+  // This generator is not provided if UnaryFunc is a function
   // pointer type, because it's too dangerous: the default-constructed
   // function pointer in the iterator be 0, leading to a runtime
   // crash.
-  template <class UnaryFunction, class Iterator>
+  template <class UnaryFunc, class Iterator>
 #if BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
   typename mpl::if_<
 #else 
   typename iterators::enable_if<
 #endif 
-      is_class<UnaryFunction>   // We should probably find a cheaper test than is_class<>
+      is_class<UnaryFunc>   // We should probably find a cheaper test than is_class<>
-    , transform_iterator<UnaryFunction, Iterator>
+    , transform_iterator<UnaryFunc, Iterator>
 #if BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
     , int[3]
 #endif 
   >::type
   make_transform_iterator(Iterator it)
   {
-      return transform_iterator<UnaryFunction, Iterator>(it, UnaryFunction());
+      return transform_iterator<UnaryFunc, Iterator>(it, UnaryFunc());
   }
 
 #if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION ) && !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)