Branch for working on the documentation tools documentation.

[SVN r68640]

include/boost/range.hpp

@@ -15,7 +15,7 @@
 # pragma once
 #endif
 
-#if _MSC_VER == 1300 // experiment
+#if defined(_MSC_VER) && (_MSC_VER == 1300)
 
 #include <boost/range/detail/collection_traits.hpp>
 #include <boost/range/iterator_range.hpp>
@@ -28,6 +28,6 @@
 #include <boost/range/iterator_range.hpp>
 #include <boost/range/sub_range.hpp>
 
-#endif // _MSC_VER == 1300 // experiment
+#endif // _MSC_VER == 1300
 
 #endif

include/boost/range/algorithm_ext/is_sorted.hpp

@@ -1,3 +1,4 @@
+//  Copyright Bryce Lelbach 2010
 //  Copyright Neil Groves 2009. Use, modification and
 //  distribution is subject to the Boost Software License, Version
 //  1.0. (See accompanying file LICENSE_1_0.txt or copy at
@@ -14,45 +15,26 @@
 #include <boost/range/end.hpp>
 #include <boost/range/concepts.hpp>
 #include <boost/range/value_type.hpp>
+#include <boost/detail/is_sorted.hpp>
 #include <algorithm>
 
 namespace boost
 {
-    namespace range_detail
-    {
-        template<class ForwardIterator>
-        inline bool is_sorted(ForwardIterator first, ForwardIterator last)
-        {
-            for (ForwardIterator next = first; first != last && ++next != last; ++first)
-                if (*next < *first)
-                    return false;
-            return true;
-        }
-
-        template<class ForwardIterator, class BinaryPredicate>
-        inline bool is_sorted(ForwardIterator first, ForwardIterator last, BinaryPredicate pred)
-        {
-            for (ForwardIterator next = first; first != last && ++next != last; ++first)
-                if (pred(*next, *first))
-                    return false;
-            return true;
-        }
-    }
-
     namespace range
     {
 
-/// \brief template function count
+/// \brief template function is_sorted
 ///
-/// range-based version of the count std algorithm
+/// range-based version of the is_sorted std algorithm
 ///
 /// \pre SinglePassRange is a model of the SinglePassRangeConcept
 template<class SinglePassRange>
 inline bool is_sorted(const SinglePassRange& rng)
 {
     BOOST_RANGE_CONCEPT_ASSERT((SinglePassRangeConcept<const SinglePassRange>));
-    BOOST_RANGE_CONCEPT_ASSERT((LessThanComparableConcept<BOOST_DEDUCED_TYPENAME range_value<const SinglePassRange>::type>));
-    return range_detail::is_sorted(boost::begin(rng), boost::end(rng));
+    BOOST_RANGE_CONCEPT_ASSERT((LessThanComparableConcept<BOOST_DEDUCED_TYPENAME
+      range_value<const SinglePassRange>::type>));
+    return ::boost::detail::is_sorted(boost::begin(rng), boost::end(rng));
 }
 
 /// \overload
@@ -60,12 +42,16 @@ template<class SinglePassRange, class BinaryPredicate>
 inline bool is_sorted(const SinglePassRange& rng, BinaryPredicate pred)
 {
     BOOST_RANGE_CONCEPT_ASSERT((SinglePassRangeConcept<const SinglePassRange>));
-    BOOST_RANGE_CONCEPT_ASSERT((BinaryPredicateConcept<BinaryPredicate, BOOST_DEDUCED_TYPENAME range_value<const SinglePassRange>::type, BOOST_DEDUCED_TYPENAME range_value<const SinglePassRange>::type>));
-    return range_detail::is_sorted(boost::begin(rng), boost::end(rng), pred);
+    BOOST_RANGE_CONCEPT_ASSERT((BinaryPredicateConcept<BinaryPredicate,
+      BOOST_DEDUCED_TYPENAME range_value<const SinglePassRange>::type,
+      BOOST_DEDUCED_TYPENAME range_value<const SinglePassRange>::type>));
+    return ::boost::detail::is_sorted(boost::begin(rng), boost::end(rng), pred);
 }
 
     } // namespace range
-    using range::is_sorted;
+
+using range::is_sorted;
+
 } // namespace boost
 
 #endif // include guard

include/boost/range/as_literal.hpp

@@ -25,7 +25,7 @@
 #include <boost/detail/workaround.hpp>
 
 #include <cstring>
-#ifndef BOOST_NO_CWCHAR
+#ifndef BOOST_NO_CWCHAR 
 #include <cwchar>
 #endif
 
@@ -38,41 +38,41 @@ namespace boost
             return strlen( s );
         }
 
-#ifndef BOOST_NO_CWCHAR
+#ifndef BOOST_NO_CWCHAR  
         inline std::size_t length( const wchar_t* s )
         {
             return wcslen( s );
         }
-#endif
+#endif        
 
         //
         // Remark: the compiler cannot choose between T* and T[sz]
         // overloads, so we must put the T* internal to the
         // unconstrained version.
-        //
+        // 
 
         inline bool is_char_ptr( char* )
         {
             return true;
         }
-
+        
         inline bool is_char_ptr( const char* )
         {
             return true;
         }
 
-#ifndef BOOST_NO_CWCHAR
+#ifndef BOOST_NO_CWCHAR  
         inline bool is_char_ptr( wchar_t* )
         {
             return true;
         }
-
+        
         inline bool is_char_ptr( const wchar_t* )
         {
             return true;
         }
 #endif
-
+        
         template< class T >
         inline long is_char_ptr( T /* r */ )
         {
@@ -80,30 +80,30 @@ namespace boost
         }
 
         template< class T >
-        inline iterator_range<T*>
+        inline iterator_range<T*> 
         make_range( T* const r, bool )
         {
             return iterator_range<T*>( r, r + length(r) );
         }
 
         template< class T >
-        inline iterator_range<BOOST_DEDUCED_TYPENAME range_iterator<T>::type>
+        inline iterator_range<BOOST_DEDUCED_TYPENAME range_iterator<T>::type> 
         make_range( T& r, long )
         {
             return boost::make_iterator_range( r );
         }
 
     }
-
+    
     template< class Range >
-    inline iterator_range<BOOST_DEDUCED_TYPENAME range_iterator<Range>::type>
+    inline iterator_range<BOOST_DEDUCED_TYPENAME range_iterator<Range>::type> 
     as_literal( Range& r )
     {
         return range_detail::make_range( r, range_detail::is_char_ptr(r) );
     }
 
     template< class Range >
-    inline iterator_range<BOOST_DEDUCED_TYPENAME range_iterator<const Range>::type>
+    inline iterator_range<BOOST_DEDUCED_TYPENAME range_iterator<const Range>::type> 
     as_literal( const Range& r )
     {
         return range_detail::make_range( r, range_detail::is_char_ptr(r) );
@@ -112,9 +112,9 @@ namespace boost
     template< class Char, std::size_t sz >
     inline iterator_range<Char*> as_literal( Char (&arr)[sz] )
     {
-        return range_detail::make_range( arr, range_detail::is_char_ptr(arr) );
+        return range_detail::make_range( arr, range_detail::is_char_ptr(arr) );        
     }
-
+    
     template< class Char, std::size_t sz >
     inline iterator_range<const Char*> as_literal( const Char (&arr)[sz] )
     {

include/boost/range/detail/implementation_help.hpp

@@ -21,13 +21,13 @@
 #include <wchar.h>
 #endif
 
-namespace boost
+namespace boost 
 {
     namespace range_detail
     {
         template <typename T>
         inline void boost_range_silence_warning( const T& ) { }
-
+        
         /////////////////////////////////////////////////////////////////////
         // end() help
         /////////////////////////////////////////////////////////////////////
@@ -36,7 +36,7 @@ namespace boost
         {
             return s + strlen( s );
         }
-
+        
 #ifndef BOOST_NO_CWCHAR
         inline const wchar_t* str_end( const wchar_t* s, const wchar_t* )
         {
@@ -51,7 +51,7 @@ namespace boost
                 ;
             return s;
         }
-#endif
+#endif         
 
         template< class Char >
         inline Char* str_end( Char* s )
@@ -64,7 +64,7 @@ namespace boost
         {
             return boost_range_array + sz;
         }
-
+        
         template< class T, std::size_t sz >
         inline const T* array_end( const T BOOST_RANGE_ARRAY_REF()[sz] )
         {
@@ -74,7 +74,7 @@ namespace boost
         /////////////////////////////////////////////////////////////////////
         // size() help
         /////////////////////////////////////////////////////////////////////
-
+        
         template< class Char >
         inline std::size_t str_size( const Char* const& s )
         {
@@ -96,7 +96,7 @@ namespace boost
         }
 
     } // namespace 'range_detail'
-
+    
 } // namespace 'boost'
 
 

include/boost/range/iterator.hpp

@@ -25,46 +25,46 @@
 namespace boost
 {
 
-#if BOOST_WORKAROUND(BOOST_MSVC, == 1310)
+#if BOOST_WORKAROUND(BOOST_MSVC, == 1310)  
 
-    namespace range_detail_vc7_1
-    {
-       template< typename C, typename Sig = void(C) >
-       struct range_iterator
-       {
-           typedef BOOST_RANGE_DEDUCED_TYPENAME
-               mpl::eval_if_c< is_const<C>::value,
-                               range_const_iterator< typename remove_const<C>::type >,
-                               range_mutable_iterator<C> >::type type;
-       };
-
-       template< typename C, typename T >
-       struct range_iterator< C, void(T[]) >
-       {
-           typedef T* type;
-       };
-    }
-
-#endif
+    namespace range_detail_vc7_1  
+    {  
+       template< typename C, typename Sig = void(C) >  
+       struct range_iterator  
+       {  
+           typedef BOOST_RANGE_DEDUCED_TYPENAME   
+               mpl::eval_if_c< is_const<C>::value,   
+                               range_const_iterator< typename remove_const<C>::type >,  
+                               range_mutable_iterator<C> >::type type;  
+       };  
+    
+       template< typename C, typename T >  
+       struct range_iterator< C, void(T[]) >  
+       {  
+           typedef T* type;  
+       };       
+    }  
+    
+#endif  
 
     template< typename C >
     struct range_iterator
     {
 #if BOOST_WORKAROUND(BOOST_MSVC, == 1310)
+  
+        typedef BOOST_RANGE_DEDUCED_TYPENAME  
+               range_detail_vc7_1::range_iterator<C>::type type;  
+           
+#else  
 
-        typedef BOOST_RANGE_DEDUCED_TYPENAME
-               range_detail_vc7_1::range_iterator<C>::type type;
-
-#else
-
-        typedef BOOST_RANGE_DEDUCED_TYPENAME
-            mpl::eval_if_c< is_const<C>::value,
+        typedef BOOST_RANGE_DEDUCED_TYPENAME 
+            mpl::eval_if_c< is_const<C>::value, 
                             range_const_iterator< typename remove_const<C>::type >,
                             range_mutable_iterator<C> >::type type;
-
-#endif
+        
+#endif         
     };
-
+    
 } // namespace boost
 
 //#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION

include/boost/range/sub_range.hpp

@@ -12,7 +12,7 @@
 #ifndef BOOST_RANGE_SUB_RANGE_HPP
 #define BOOST_RANGE_SUB_RANGE_HPP
 
-#if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1500))
+#if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1500)) 
     #pragma warning( push )
     #pragma warning( disable : 4996 )
 #endif
@@ -30,9 +30,9 @@
 
 namespace boost
 {
-
-    template< class ForwardRange >
-    class sub_range : public iterator_range< BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type >
+    
+    template< class ForwardRange > 
+    class sub_range : public iterator_range< BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type > 
     {
         typedef BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type iterator_t;
         typedef iterator_range< iterator_t  > base;
@@ -53,40 +53,40 @@ namespace boost
                                  reference >::type const_reference;
 
     public:
-        sub_range() : base()
-        { }
-
-#if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1500) )
-        sub_range( const sub_range& r )
-            : base( static_cast<const base&>( r ) )
+        sub_range() : base() 
         { }
+        
+#if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1500) ) 
+        sub_range( const sub_range& r ) 
+            : base( static_cast<const base&>( r ) )  
+        { }  
 #endif
 
         template< class ForwardRange2 >
-        sub_range( ForwardRange2& r ) :
+        sub_range( ForwardRange2& r ) : 
+            
+#if BOOST_WORKAROUND(BOOST_INTEL_CXX_VERSION, <= 800 )
+            base( impl::adl_begin( r ), impl::adl_end( r ) )
+#else
+            base( r )
+#endif        
+        { }
+        
+        template< class ForwardRange2 >
+        sub_range( const ForwardRange2& r ) : 
 
 #if BOOST_WORKAROUND(BOOST_INTEL_CXX_VERSION, <= 800 )
             base( impl::adl_begin( r ), impl::adl_end( r ) )
 #else
             base( r )
-#endif
-        { }
-
-        template< class ForwardRange2 >
-        sub_range( const ForwardRange2& r ) :
-
-#if BOOST_WORKAROUND(BOOST_INTEL_CXX_VERSION, <= 800 )
-            base( impl::adl_begin( r ), impl::adl_end( r ) )
-#else
-            base( r )
-#endif
+#endif                
         { }
 
         template< class Iter >
         sub_range( Iter first, Iter last ) :
             base( first, last )
         { }
-
+        
         template< class ForwardRange2 >
         sub_range& operator=( ForwardRange2& r )
         {
@@ -99,23 +99,23 @@ namespace boost
         {
             base::operator=( r );
             return *this;
-        }
+        }   
 
         sub_range& operator=( const sub_range& r )
         {
             base::operator=( static_cast<const base&>(r) );
-            return *this;
+            return *this;            
         }
-
+        
     public:
-
+        
         iterator        begin()          { return base::begin(); }
         const_iterator  begin() const    { return base::begin(); }
         iterator        end()            { return base::end();   }
         const_iterator  end() const      { return base::end();   }
-        difference_type size() const     { return base::size();  }
-
+        difference_type size() const     { return base::size();  }   
 
+        
     public: // convenience
         reference front()
         {
@@ -173,7 +173,7 @@ namespace boost
 
 } // namespace 'boost'
 
-#if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1500))
+#if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1500)) 
     #pragma warning( pop )
 #endif