cleanups

[SVN r1061]

include/boost/iterator/filter_iterator.hpp

@@ -24,8 +24,10 @@ namespace boost
     {
       typedef iterator_tag<
           typename return_category<Iterator>::type
-        , minimum_category< forward_traversal_tag
+        , typename minimum_category<
-                            ,typename traversal_category<Iterator>::type >::type 
+              forward_traversal_tag
+            , typename traversal_category<Iterator>::type
+          >::type 
       > iterator_category;
     };
 

include/boost/iterator/indirect_iterator.hpp

@@ -44,29 +44,31 @@ namespace boost
 
     template <class T>
     struct has_element_type
-    {
+        : mpl::bool_<
-      typedef typename mpl::if_<
+              mpl::if_<
                   is_class<T>
-        , aux::has_element_type<T>
+                , ::boost::detail::aux::has_element_type<T>
                 , mpl::false_
-          >::type type;
+              >::type::value
+          >
+    {
     };
 # else
     template <class T>
     struct has_element_type
-        : mpl::false_c {};
+        : mpl::false_ {};
     
     template <class T>
     struct has_element_type<boost::shared_ptr<T> >
-        : mpl::true_c {};
+        : mpl::true_ {};
     
     template <class T>
     struct has_element_type<boost::scoped_ptr<T> >
-        : mpl::true_c {};
+        : mpl::true_ {};
     
     template <class T>
     struct has_element_type<std::auto_ptr<T> >
-        : mpl::true_c {};
+        : mpl::true_ {};
 # endif 
   
     // Metafunction returning the nested element_type typedef
@@ -86,7 +88,10 @@ namespace boost
     template <class Iter>
     struct indirect_defaults
       : mpl::if_<
-            has_element_type<typename iterator_traits<Iter>::value_type>
+            mpl::and_<
+                is_class<typename iterator_traits<Iter>::value_type>
+              , has_element_type<typename iterator_traits<Iter>::value_type>
+            >
           , smart_pointer_traits<typename iterator_traits<Iter>::value_type>
           , iterator_traits<typename iterator_traits<Iter>::value_type>
         >::type

include/boost/iterator/iterator_adaptor.hpp

@@ -110,7 +110,8 @@ namespace boost
 #  else 
           ::boost::is_convertible<From, To>
 #  endif 
-      ,detail::enable_type >::type type;
+        , detail::enable_type
+      >::type type;
 # endif 
   };
 
@@ -121,18 +122,22 @@ namespace boost
   // argument ordering is different from the std::iterator template, so that default 
   // arguments can be used effectivly.
   //
-  template <class Iterator,
+  template <
-            class ValueType        = typename detail::iterator_traits<Iterator>::value_type,
+      class Iterator
-            class Reference        = ValueType&,
+    , class ValueType = typename detail::iterator_traits<Iterator>::value_type
-            class Pointer          = ValueType*,
+    , class Reference = ValueType&
-            class IteratorCategory = typename detail::iterator_traits<Iterator>::iterator_category,
+    , class Pointer = ValueType*
-            class DifferenceType   = typename detail::iterator_traits<Iterator>::difference_type >
+    , class IteratorCategory = typename detail::iterator_traits<Iterator>::iterator_category
+    , class DifferenceType = typename detail::iterator_traits<Iterator>::difference_type
+  >
   struct iterator_traits_adaptor
-    : iterator<IteratorCategory,
+    : iterator<
-               ValueType,
+          IteratorCategory
-               DifferenceType,
+        , ValueType
-               Pointer,
+        , DifferenceType
-               Reference>
+        , Pointer
+        , Reference
+      >
   {
   };
 
@@ -157,13 +162,15 @@ namespace boost
       {
       }
 
-    Iterator base() const { return m_iterator; }
+      Iterator base() const
+        { return m_iterator; }
 
    protected:
       // Core iterator interface for iterator_facade
       // 
 
-    typename Traits::reference dereference() const { return *m_iterator; }
+      typename Traits::reference dereference() const
+        { return *m_iterator; }
 
       template <
           class OtherDerived, class OtherIterator, class OtherTraits

include/boost/iterator/iterator_facade.hpp

@@ -31,12 +31,16 @@ namespace boost
     // enable_if_interoperable falls back to always enabled for compilers
     // that don't support enable_if or is_convertible. 
     //
-    template <class Facade1,
+    template <
-              class Facade2,
+        class Facade1
-              class Return>
+      , class Facade2
-    struct enable_if_interoperable :
+      , class Return
-      ::boost::detail::enable_if< is_convertible< Facade1, Facade2 >
+    >
-                                  , Return >
+    struct enable_if_interoperable
+      : ::boost::detail::enable_if<
+           is_convertible<Facade1, Facade2>
+         , Return
+        >
     {
 # if BOOST_WORKAROUND(BOOST_MSVC, <= 1200)
         typedef Return type;
@@ -285,154 +289,72 @@ namespace boost
   // a == b;
   // ----------------
   //
-  template <class Derived1,
-            class Traits1,
-            class Derived2,
-            class Traits2>
-  inline
-  typename detail::enable_if_interoperable<Derived1,
-                                           Derived2,
-                                           bool>::type
-  operator==(iterator_facade<Derived1, Traits1> const& lhs,
-             iterator_facade<Derived2, Traits2> const& rhs)
-  {
-    // For those compilers that do not support enable_if
-    BOOST_STATIC_ASSERT((is_interoperable< Derived1, Derived2 >::value));
 
-    return iterator_core_access::equal(lhs.derived(),
+# define BOOST_ITERATOR_FACADE_INTEROP(op, result_type, condition, return_prefix, base_op)  \
-                                       rhs.derived());
+  template <class Derived1, class Traits1, class Derived2, class Traits2>                   \
+  inline typename detail::enable_if_interoperable<                                          \
+      Derived1, Derived2, result_type                                                       \
+  >::type                                                                                   \
+  operator op(                                                                              \
+      iterator_facade<Derived1, Traits1> const& lhs                                         \
+    , iterator_facade<Derived2, Traits2> const& rhs)                                        \
+  {                                                                                         \
+      /* For those compilers that do not support enable_if */                               \
+      BOOST_STATIC_ASSERT((                                                                 \
+          is_interoperable< Derived1, Derived2 >::value                                     \
+          && condition                                                                      \
+      ));                                                                                   \
+      return_prefix iterator_core_access::base_op(                                          \
+          rhs.derived(), lhs.derived());                                                    \
   }
 
-  template <class Derived1,
+# define BOOST_ITERATOR_FACADE_RELATION(op, test, base_op)  \
-            class Traits1,
+  BOOST_ITERATOR_FACADE_INTEROP(                            \
-            class Derived2,
+      op                                                    \
-            class Traits2>
+    , bool                                                  \
-  inline
+    , true                                                  \
-  typename detail::enable_if_interoperable<Derived1,
+    , return test                                           \
-                                           Derived2,
+    , base_op                                               \
-                                           bool>::type
+  )
-  operator!=(iterator_facade<Derived1, Traits1> const& lhs,
-             iterator_facade<Derived2, Traits2> const& rhs)
-  {
-    // For those compilers that do not support enable_if
-    BOOST_STATIC_ASSERT((is_interoperable< Derived1, Derived2 >::value));
 
-    return !iterator_core_access::equal(lhs.derived(),
+  BOOST_ITERATOR_FACADE_RELATION(==, (bool), equal)
-                                        rhs.derived());
+  BOOST_ITERATOR_FACADE_RELATION(!=, !, equal)
+
+  BOOST_ITERATOR_FACADE_RELATION(<, 0>, distance_to)
+  BOOST_ITERATOR_FACADE_RELATION(>, 0<, distance_to)
+  BOOST_ITERATOR_FACADE_RELATION(<=, 0>=, distance_to)
+  BOOST_ITERATOR_FACADE_RELATION(>=, 0<=, distance_to)
+# undef BOOST_ITERATOR_FACADE_RELATION
+
+  BOOST_ITERATOR_FACADE_INTEROP(
+      -
+    , typename Traits1::difference_type
+    , (is_same<
+           BOOST_ARG_DEP_TYPENAME Traits1::difference_type
+         , BOOST_ARG_DEP_TYPENAME Traits2::difference_type
+       >::value)
+    , return
+    , distance_to )
+# undef BOOST_ITERATOR_FACADE_INTEROP
+
+# define BOOST_ITERATOR_FACADE_PLUS(args)   \
+  template <class Derived, class Traits>    \
+  inline Derived operator+ args             \
+  {                                         \
+      Derived tmp(i.derived());             \
+      return tmp += n;                      \
   }
 
-  template <class Derived1,
+BOOST_ITERATOR_FACADE_PLUS((
-            class Traits1,
+    iterator_facade<Derived, Traits> const& i
-            class Derived2,
+  , typename Traits::difference_type n
-            class Traits2>
+))
-  inline
-  typename detail::enable_if_interoperable<Derived1,
-                                           Derived2,
-                                           bool>::type
-  operator<(iterator_facade<Derived1, Traits1> const& lhs,
-             iterator_facade<Derived2, Traits2> const& rhs)
-  {
-    // For those compilers that do not support enable_if
-    BOOST_STATIC_ASSERT((is_interoperable< Derived1, Derived2 >::value));
 
-    return iterator_core_access::distance_to(lhs.derived(),
+BOOST_ITERATOR_FACADE_PLUS((
-                                             rhs.derived()) > 0;
+    typename Traits::difference_type n
-  }
+  , iterator_facade<Derived, Traits> const& i
-
+))
-  template <class Derived1,
+# undef BOOST_ITERATOR_FACADE_PLUS
-            class Traits1,
-            class Derived2,
-            class Traits2>
-  inline
-  typename detail::enable_if_interoperable<Derived1,
-                                           Derived2,
-                                           bool>::type
-  operator>(iterator_facade<Derived1, Traits1> const& lhs,
-             iterator_facade<Derived2, Traits2> const& rhs)
-  {
-    // For those compilers that do not support enable_if
-    BOOST_STATIC_ASSERT((is_interoperable< Derived1, Derived2 >::value));
-
-    return iterator_core_access::distance_to(lhs.derived(),
-                                             rhs.derived()) < 0;
-  }
-
-  template <class Derived1,
-            class Traits1,
-            class Derived2,
-            class Traits2>
-  inline
-  typename detail::enable_if_interoperable<Derived1,
-                                           Derived2,
-                                           bool>::type
-  operator<=(iterator_facade<Derived1, Traits1> const& lhs,
-             iterator_facade<Derived2, Traits2> const& rhs)
-  {
-    // For those compilers that do not support enable_if
-    BOOST_STATIC_ASSERT((is_interoperable< Derived1, Derived2 >::value));
-
-    return iterator_core_access::distance_to(lhs.derived(),
-                                             rhs.derived()) >= 0;
-  }
-
-  template <class Derived1,
-            class Traits1,
-            class Derived2,
-            class Traits2>
-  inline
-  typename detail::enable_if_interoperable<Derived1,
-                                           Derived2,
-                                           bool>::type
-  operator>=(iterator_facade<Derived1, Traits1> const& lhs,
-             iterator_facade<Derived2, Traits2> const& rhs)
-  {
-    // For those compilers that do not support enable_if
-    BOOST_STATIC_ASSERT((is_interoperable< Derived1, Derived2 >::value));
-
-    return iterator_core_access::distance_to(lhs.derived(),
-                                             rhs.derived()) <= 0;
-  }
-
-  template <class Derived,
-            class Traits>
-  inline
-  Derived operator+(iterator_facade<Derived, Traits> const& i,
-                    typename Traits::difference_type n)
-  {
-    Derived tmp(i.derived());
-    return tmp += n;
-  }
-
-  template <class Derived,
-            class Traits>
-  inline
-  Derived operator+(typename Traits::difference_type n,
-                    iterator_facade<Derived, Traits> const& i)
-  {
-    Derived tmp(i.derived());
-    return tmp += n;
-  }
-
-  template <class Derived1,
-            class Traits1,
-            class Derived2,
-            class Traits2>
-  inline
-  typename detail::enable_if_interoperable<Derived1,
-                                           Derived2,
-                                           typename Traits1::difference_type>::type
-  operator-(iterator_facade<Derived1, Traits1> const& lhs,
-            iterator_facade<Derived2, Traits2> const& rhs)
-  {
-    // For those compilers that do not support enable_if
-    BOOST_STATIC_ASSERT((is_interoperable< Derived1, Derived2 >::value));
-
-    BOOST_STATIC_ASSERT((is_same<BOOST_ARG_DEP_TYPENAME Traits1::difference_type,
-                                 BOOST_ARG_DEP_TYPENAME Traits2::difference_type>::value));
-
-    return iterator_core_access::distance_to(rhs.derived(),
-                                             lhs.derived());
-  }
     
 } // namespace boost