iterator_archetypes.hpp, iterator_concepts.hpp -

incrementable_iterator_tag -> incrementable_traversal_tag
   single_pass_iterator_tag -> single_pass_traversal_tag

iterator_categories.hpp -

   added writability stripping to new_category_to_access for iterator

   adaptors based on iterators with new-style tags

   ReturnTag->AccessTag / returns->access

   Fixed a bug which would rule out user-defined access/traversal tags
   - we weren't accounting for tag convertibility without public
   inheritance.

iterator_facade.hpp -

   Workaround for a Borland const-dropping bug.

detail/categories.hpp -

   fixed is_tag so it doesn't rely on inheritance for detection

concept_tests.cpp -

   added new tests, use static_assert_same for better feedback on failure

iterator_adaptor_test.cpp

   workarounds for CWPro7, use static_assert_same for better feedback on failure
   wiped out #if 0 section

unit_tests.cpp -

   factored static_assert_same into a separate file


[SVN r1296]

test/concept_tests.cpp

@@ -7,6 +7,8 @@
 #include <boost/iterator/iterator_concepts.hpp>
 #include <boost/operators.hpp>
 #include <boost/static_assert.hpp> // remove
+#include <boost/detail/workaround.hpp>
+#include "static_assert_same.hpp" // remove
 
 struct new_iterator
   : public boost::iterator< boost::iterator_tag<
@@ -50,13 +52,26 @@ struct old_iterator
 };
 old_iterator operator+(std::ptrdiff_t, old_iterator x) { return x; }
 
+struct my_writable_lvalue_iterator_tag
+{
+    operator boost::writable_lvalue_iterator_tag() const;
+};
+
+struct my_single_pass_traversal_tag
+{
+    operator boost::single_pass_traversal_tag() const;
+};
+
 void test_tag_convertibility()
 {
-#ifndef BOOST_NO_IS_CONVERTIBLE
+    // This set of tests is by no means complete.
+
+    // Test that this is an input/output iterator
+#if !BOOST_WORKAROUND(__MWERKS__, <= 0x2407)
     {
         typedef boost::iterator_tag<
             boost::writable_lvalue_iterator_tag
-          , boost::single_pass_iterator_tag
+          , boost::single_pass_traversal_tag
         > tag;
         
         BOOST_STATIC_ASSERT((
@@ -69,10 +84,33 @@ void test_tag_convertibility()
             !boost::is_convertible<tag, std::forward_iterator_tag>::value
         ));
     }
+
+    // Test that it's possible to build new sub-tags without
+    // derivation.  Convertibility should be enough
+    {
+        typedef boost::iterator_tag<
+            my_writable_lvalue_iterator_tag
+          , my_single_pass_traversal_tag
+        > tag;
+        
+        BOOST_STATIC_ASSERT((
+            boost::is_convertible<tag, std::output_iterator_tag>::value
+        ));
+        BOOST_STATIC_ASSERT((
+            boost::is_convertible<tag, std::input_iterator_tag>::value
+        ));
+        BOOST_STATIC_ASSERT((
+            !boost::is_convertible<tag, std::forward_iterator_tag>::value
+        ));
+    }
+
+    // Test that a single-pass readable lvalue iterator is only an
+    // input iterator.  Requires special case handling in
+    // categories.hpp
     {
         typedef boost::iterator_tag<
             boost::readable_lvalue_iterator_tag
-          , boost::single_pass_iterator_tag
+          , boost::single_pass_traversal_tag
         > tag;
         BOOST_STATIC_ASSERT((
             boost::is_convertible<tag, std::input_iterator_tag>::value
@@ -95,12 +133,12 @@ main()
   typedef boost::iterator_tag< boost::writable_lvalue_iterator_tag, boost::random_access_traversal_tag > tag;
 
   // BOOST_STATIC_ASSERT((boost::detail::is_random_access_iterator<tag>::value));
-  BOOST_STATIC_ASSERT((boost::is_same<tag::returns, boost::writable_lvalue_iterator_tag>::value));
-  BOOST_STATIC_ASSERT((boost::is_same<tag::traversal, boost::random_access_traversal_tag>::value));
+  int test = static_assert_same<tag::access, boost::writable_lvalue_iterator_tag>::value;
+  test = static_assert_same<tag::traversal, boost::random_access_traversal_tag>::value;
 
   // BOOST_STATIC_ASSERT((boost::detail::is_random_access_iterator<new_iterator::iterator_category>::value));
-  BOOST_STATIC_ASSERT((boost::is_same<new_iterator::iterator_category::returns, boost::writable_lvalue_iterator_tag>::value));
-  BOOST_STATIC_ASSERT((boost::is_same<new_iterator::iterator_category::traversal, boost::random_access_traversal_tag>::value));
+  test = static_assert_same<new_iterator::iterator_category::access, boost::writable_lvalue_iterator_tag>::value;
+  test = static_assert_same<new_iterator::iterator_category::traversal, boost::random_access_traversal_tag>::value;
 
   typedef boost::traversal_category<new_iterator>::type traversal_category;
 
@@ -108,8 +146,8 @@ main()
   BOOST_STATIC_ASSERT(boost::detail::is_new_iterator_tag<new_iterator::iterator_category>::value);
 
 
-  BOOST_STATIC_ASSERT((boost::is_same<traversal_category, boost::random_access_traversal_tag>::value));
-
+  test = static_assert_same<traversal_category, boost::random_access_traversal_tag>::value;
+  (void)test;
 
 #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
   boost::function_requires<