moved into this branch from developement directory

[SVN r10461]

include/boost/iterator_concepts.hpp

@@ -0,0 +1,172 @@
+#ifndef BOOST_ITERATOR_CONCEPTS_HPP
+#define BOOST_ITERATOR_CONCEPTS_HPP
+
+#include <boost/concept_check.hpp>
+#include <boost/iterator_categories.hpp>
+#include <boost/type_traits/conversion_traits.hpp>
+#include <boost/static_assert.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.
+
+
+  //===========================================================================
+  // Iterator Access Concepts
+
+  template <typename Iterator>
+  class ReadableIteratorConcept {
+  public:
+    typedef typename std::iterator_traits<Iterator>::value_type value_type;
+    typedef typename std::iterator_traits<Iterator>::reference reference;
+    typedef typename boost::return_category<Iterator>::type return_category;
+
+    void constraints() {
+      boost::function_requires< boost::SGIAssignableConcept<Iterator> >();
+      boost::function_requires< boost::EqualityComparableConcept<Iterator> >();
+      boost::function_requires< 
+        boost::DefaultConstructibleConcept<Iterator> >();
+      
+      BOOST_STATIC_ASSERT((boost::is_convertible<return_category*,
+                           boost::readable_iterator_tag*>::value));
+                          
+      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::return_category<Iterator>::type return_category;
+
+    void constraints() {
+      boost::function_requires< boost::SGIAssignableConcept<Iterator> >();
+      boost::function_requires< boost::EqualityComparableConcept<Iterator> >();
+      boost::function_requires< 
+        boost::DefaultConstructibleConcept<Iterator> >();
+      
+      BOOST_STATIC_ASSERT((boost::is_convertible<return_category*,
+                           boost::writable_iterator_tag*>::value));
+
+      *i = v; // a good alternative could be something like write(x, v)
+    }
+    ValueType v;
+    Iterator i;
+  };
+  
+  template <typename Iterator>
+  class ConstantLvalueIteratorConcept {
+  public:
+    typedef typename std::iterator_traits<Iterator>::value_type value_type;
+    typedef typename std::iterator_traits<Iterator>::reference reference;
+    typedef typename boost::return_category<Iterator>::type return_category;
+
+    void constraints() {
+      boost::function_requires< ReadableIteratorConcept<Iterator> >();
+
+      BOOST_STATIC_ASSERT((boost::is_convertible<return_category*, 
+                           boost::constant_lvalue_iterator_tag*>::value));
+
+      BOOST_STATIC_ASSERT((boost::is_same<reference, 
+                           const value_type&>::value));
+
+      reference v = *i;
+      boost::ignore_unused_variable_warning(v);
+    }
+    Iterator i;
+  };
+
+  template <typename Iterator>
+  class MutableLvalueIteratorConcept {
+  public:
+    typedef typename std::iterator_traits<Iterator>::value_type value_type;
+    typedef typename std::iterator_traits<Iterator>::reference reference;
+    typedef typename boost::return_category<Iterator>::type return_category;
+
+    void constraints() {
+      boost::function_requires< ReadableIteratorConcept<Iterator> >();
+      boost::function_requires< 
+        WritableIteratorConcept<Iterator, value_type> >();
+      
+      BOOST_STATIC_ASSERT((boost::is_convertible<return_category*, 
+                           boost::mutable_lvalue_iterator_tag*>::value));
+
+      BOOST_STATIC_ASSERT((boost::is_same<reference, value_type&>::value));
+
+      reference v = *i;
+      boost::ignore_unused_variable_warning(v);
+    }
+    Iterator i;
+  };
+  
+  //===========================================================================
+  // Iterator Traversal Concepts
+
+  template <typename Iterator>
+  class ForwardIteratorConcept {
+  public:
+    typedef typename boost::traversal_category<Iterator>::type traversal_category;
+
+    void constraints() {
+      boost::function_requires< boost::SGIAssignableConcept<Iterator> >();
+      boost::function_requires< boost::EqualityComparableConcept<Iterator> >();
+      boost::function_requires< 
+        boost::DefaultConstructibleConcept<Iterator> >();
+
+      BOOST_STATIC_ASSERT((boost::is_convertible<traversal_category*, 
+                           boost::forward_traversal_tag*>::value));
+      ++i;
+      (void)i++;
+    }
+    Iterator i;
+  };
+  
+  template <typename Iterator>
+  class BidirectionalIteratorConcept {
+  public:
+    typedef typename boost::traversal_category<Iterator>::type traversal_category;
+
+    void constraints() {
+      boost::function_requires< ForwardIteratorConcept<Iterator> >();
+      
+      BOOST_STATIC_ASSERT((boost::is_convertible<traversal_category*, 
+                           boost::bidirectional_traversal_tag*>::value));
+
+      --i;
+      (void)i--;
+    }
+    Iterator i;
+  };
+
+  template <typename Iterator>
+  class RandomAccessIteratorConcept {
+  public:
+    typedef typename boost::traversal_category<Iterator>::type traversal_category;
+    typedef typename std::iterator_traits<Iterator>::difference_type
+      difference_type;
+
+    void constraints() {
+      boost::function_requires< BidirectionalIteratorConcept<Iterator> >();
+
+      BOOST_STATIC_ASSERT((boost::is_convertible<traversal_category*, 
+                           boost::random_access_traversal_tag*>::value));
+      
+      i += n;
+      i = i + n;
+      i = n + i;
+      i -= n;
+      i = i - n;
+      n = i - j;
+    }
+    difference_type n;
+    Iterator i, j;
+  };
+
+} // namespace boost_concepts
+
+
+#endif // BOOST_ITERATOR_CONCEPTS_HPP