passenger 3.0.21 → 3.9.1.beta

data/ext/boost/range/begin.hpp

@@ -91,6 +91,11 @@ namespace range_detail
 } // namespace 'range_detail'
 #endif
 
+// Use a ADL namespace barrier to avoid ambiguity with other unqualified
+// calls. This is particularly important with C++0x encouraging
+// unqualified calls to begin/end.
+namespace range_adl_barrier
+{
 
 template< class T >
 inline BOOST_DEDUCED_TYPENAME range_iterator<T>::type begin( T& r )
@@ -114,19 +119,25 @@ inline BOOST_DEDUCED_TYPENAME range_iterator<const T>::type begin( const T& r )
     return range_begin( r );
 }
 
+    } // namespace range_adl_barrier
 } // namespace boost
 
 #endif // BOOST_NO_FUNCTION_TEMPLATE_ORDERING
 
 namespace boost
 {
-    template< class T >
-    inline BOOST_DEDUCED_TYPENAME range_iterator<const T>::type
-    const_begin( const T& r )
+    namespace range_adl_barrier
     {
-        return boost::begin( r );
-    }
-}
+        template< class T >
+        inline BOOST_DEDUCED_TYPENAME range_iterator<const T>::type
+        const_begin( const T& r )
+        {
+            return boost::range_adl_barrier::begin( r );
+        }
+    } // namespace range_adl_barrier
+
+    using namespace range_adl_barrier;
+} // namespace boost
 
 #endif
 

data/ext/boost/range/concepts.hpp

@@ -98,8 +98,9 @@ namespace boost {
         // classes:
         //
         // The Range algorithms often do not require that the iterators are
-        // Assignable, but the correct standard conformant iterators
-        // do require the iterators to be a model of the Assignable concept.
+        // Assignable or default constructable, but the correct standard
+        // conformant iterators do require the iterators to be a model of the
+        // Assignable concept.
         // Iterators that contains a functor that is not assignable therefore
         // are not correct models of the standard iterator concepts,
         // despite being adequate for most algorithms. An example of this
@@ -141,6 +142,26 @@ namespace boost {
                     BOOST_DEDUCED_TYPENAME SinglePassIteratorConcept::traversal_category,
                     single_pass_traversal_tag
                 >));
+
+            BOOST_CONCEPT_USAGE(SinglePassIteratorConcept)
+            {
+                Iterator i2(++i);
+                boost::ignore_unused_variable_warning(i2);
+
+                // deliberately we are loose with the postfix version for the single pass
+                // iterator due to the commonly poor adherence to the specification means that
+                // many algorithms would be unusable, whereas actually without the check they
+                // work
+                (void)(i++);
+
+                BOOST_DEDUCED_TYPENAME boost::detail::iterator_traits<Iterator>::reference r1(*i);
+                boost::ignore_unused_variable_warning(r1);
+
+                BOOST_DEDUCED_TYPENAME boost::detail::iterator_traits<Iterator>::reference r2(*(++i));
+                boost::ignore_unused_variable_warning(r2);
+            }
+        private:
+            Iterator i;
 #endif
         };
 
@@ -160,6 +181,20 @@ namespace boost {
                     BOOST_DEDUCED_TYPENAME ForwardIteratorConcept::traversal_category,
                     forward_traversal_tag
                 >));
+
+            BOOST_CONCEPT_USAGE(ForwardIteratorConcept)
+            {
+                // See the above note in the SinglePassIteratorConcept about the handling of the
+                // postfix increment. Since with forward and better iterators there is no need
+                // for a proxy, we can sensibly require that the dereference result
+                // is convertible to reference.
+                Iterator i2(i++);
+                boost::ignore_unused_variable_warning(i2);
+                BOOST_DEDUCED_TYPENAME boost::detail::iterator_traits<Iterator>::reference r(*(i++));
+                boost::ignore_unused_variable_warning(r);
+            }
+        private:
+            Iterator i;
 #endif
          };
 

data/ext/boost/range/detail/safe_bool.hpp

@@ -0,0 +1,72 @@
+//  This header intentionally has no include guards.
+//
+//  Copyright (c) 2010 Neil Groves
+//  Distributed under the Boost Software License, Version 1.0.
+//  See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt
+//
+// This code utilises the experience gained during the evolution of
+// <boost/smart_ptr/operator_bool.hpp>
+#ifndef BOOST_RANGE_SAFE_BOOL_INCLUDED_HPP
+#define BOOST_RANGE_SAFE_BOOL_INCLUDED_HPP
+
+#include <boost/config.hpp>
+#include <boost/range/config.hpp>
+
+namespace boost
+{
+    namespace range_detail
+    {
+
+template<class DataMemberPtr>
+class safe_bool
+{
+public:
+    typedef safe_bool this_type;
+
+#if (defined(__SUNPRO_CC) && BOOST_WORKAROUND(__SUNPRO_CC, < 0x570)) || defined(__CINT_)
+    typedef bool unspecified_bool_type;
+    static unspecified_bool_type to_unspecified_bool(const bool x, DataMemberPtr)
+    {
+        return x;
+    }
+#elif defined(_MANAGED)
+    static void unspecified_bool(this_type***)
+    {
+    }
+    typedef void(*unspecified_bool_type)(this_type***);
+    static unspecified_bool_type to_unspecified_bool(const bool x, DataMemberPtr)
+    {
+        return x ? unspecified_bool : 0;
+    }
+#elif \
+    ( defined(__MWERKS__) && BOOST_WORKAROUND(__MWERKS__, < 0x3200) ) || \
+    ( defined(__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__ < 304) ) || \
+    ( defined(__SUNPRO_CC) && BOOST_WORKAROUND(__SUNPRO_CC, <= 0x590) )
+
+    typedef bool (this_type::*unspecified_bool_type)() const;
+
+    static unspecified_bool_type to_unspecified_bool(const bool x, DataMemberPtr)
+    {
+        return x ? &this_type::detail_safe_bool_member_fn : 0;
+    }
+private:
+    bool detail_safe_bool_member_fn() const { return false; }
+#else
+    typedef DataMemberPtr unspecified_bool_type;
+    static unspecified_bool_type to_unspecified_bool(const bool x, DataMemberPtr p)
+    {
+        return x ? p : 0;
+    }
+#endif
+private:
+    safe_bool();
+    safe_bool(const safe_bool&);
+    void operator=(const safe_bool&);
+    ~safe_bool();
+};
+
+    } // namespace range_detail
+} // namespace boost
+
+#endif // include guard

data/ext/boost/range/end.hpp

@@ -88,6 +88,9 @@ namespace range_detail
 } // namespace 'range_detail'
 #endif
 
+namespace range_adl_barrier
+{
+
 template< class T >
 inline BOOST_DEDUCED_TYPENAME range_iterator<T>::type end( T& r )
 {
@@ -110,22 +113,24 @@ inline BOOST_DEDUCED_TYPENAME range_iterator<const T>::type end( const T& r )
     return range_end( r );
 }
 
+    } // namespace range_adl_barrier
 } // namespace 'boost'
 
-
-
 #endif // BOOST_NO_FUNCTION_TEMPLATE_ORDERING
 
-
 namespace boost
 {
-    template< class T >
-    inline BOOST_DEDUCED_TYPENAME range_iterator<const T>::type
-    const_end( const T& r )
+    namespace range_adl_barrier
     {
-        return boost::end( r );
-    }
-}
+        template< class T >
+        inline BOOST_DEDUCED_TYPENAME range_iterator<const T>::type
+        const_end( const T& r )
+        {
+            return boost::range_adl_barrier::end( r );
+        }
+    } // namespace range_adl_barrier
+    using namespace range_adl_barrier;
+} // namespace boost
 
 #endif
 

data/ext/boost/range/iterator_range_core.hpp

@@ -27,6 +27,7 @@
 #include <boost/range/iterator.hpp>
 #include <boost/range/difference_type.hpp>
 #include <boost/range/algorithm/equal.hpp>
+#include <boost/range/detail/safe_bool.hpp>
 #include <boost/utility/enable_if.hpp>
 #include <iterator>
 #include <algorithm>
@@ -52,13 +53,13 @@ namespace boost
             template< class ForwardRange >
             static IteratorT adl_begin( ForwardRange& r )
             {
-                return IteratorT( boost::begin( r ) );
+                return static_cast<IteratorT>( boost::begin( r ) );
             }
 
             template< class ForwardRange >
             static IteratorT adl_end( ForwardRange& r )
             {
-                return IteratorT( boost::end( r ) );
+                return static_cast<IteratorT>( boost::end( r ) );
             }
         };
 
@@ -70,6 +71,24 @@ namespace boost
                                                  boost::begin(r),
                                                  boost::end(r) );
         }
+        
+        template< class Left, class Right >
+        inline bool greater_than( const Left& l, const Right& r )
+        {
+            return less_than(r,l);
+        }
+        
+        template< class Left, class Right >
+        inline bool less_or_equal_than( const Left& l, const Right& r )
+        {
+            return !iterator_range_detail::less_than(r,l);
+        }
+        
+        template< class Left, class Right >
+        inline bool greater_or_equal_than( const Left& l, const Right& r )
+        {
+            return !iterator_range_detail::less_than(l,r);
+        }
 
         // This version is maintained since it is used in other boost libraries
         // such as Boost.Assign
@@ -81,7 +100,6 @@ namespace boost
 
         struct range_tag { };
         struct const_range_tag { };
-
     }
 
 //  iterator range template class -----------------------------------------//
@@ -106,13 +124,14 @@ namespace boost
         template<class IteratorT>
         class iterator_range
         {
+            typedef range_detail::safe_bool< IteratorT iterator_range<IteratorT>::* > safe_bool_t;
         protected: // Used by sub_range
             //! implementation class
             typedef iterator_range_detail::iterator_range_impl<IteratorT> impl;
         public:
-
             //! this type
             typedef iterator_range<IteratorT> type;
+            typedef BOOST_DEDUCED_TYPENAME safe_bool_t::unspecified_bool_type unspecified_bool_type;
             //BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION(value_type);
 
             //! Encapsulated value type
@@ -238,18 +257,15 @@ namespace boost
                 return m_Begin == m_End;
             }
 
-#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
-            operator bool() const
+            operator unspecified_bool_type() const
             {
-                return !empty();
+                return safe_bool_t::to_unspecified_bool(m_Begin != m_End, &iterator_range::m_Begin);
             }
-#else
-            typedef iterator (iterator_range::*unspecified_bool_type) () const;
-            operator unspecified_bool_type() const
+
+            bool operator!() const
             {
-                return empty() ? 0: &iterator_range::end;
+                return empty();
             }
-#endif
 
             bool equal( const iterator_range& r ) const
             {
@@ -273,6 +289,21 @@ namespace boost
            {
                return iterator_range_detail::less_than( *this, r );
            }
+           
+           bool operator>( const iterator_range& r ) const
+           {
+               return iterator_range_detail::greater_than( *this, r );
+           }
+           
+           bool operator<=( const iterator_range& r ) const
+           {
+               return iterator_range_detail::less_or_equal_than( *this, r );
+           }
+           
+           bool operator>=( const iterator_range& r ) const
+           {
+               return iterator_range_detail::greater_or_equal_than( *this, r );
+           }
 
 #endif
 
@@ -290,6 +321,20 @@ namespace boost
                return *--last;
            }
 
+           // pop_front() - added to model the SinglePassRangePrimitiveConcept
+           void pop_front()
+           {
+               BOOST_ASSERT( !empty() );
+               ++m_Begin;
+           }
+
+           // pop_back() - added to model the BidirectionalRangePrimitiveConcept
+           void pop_back()
+           {
+               BOOST_ASSERT( !empty() );
+               --m_End;
+           }
+
            reference operator[]( difference_type at ) const
            {
                BOOST_ASSERT( at >= 0 && at < size() );
@@ -358,6 +403,27 @@ namespace boost
         {
             return iterator_range_detail::less_than( l, r );
         }
+        
+        template< class IteratorT, class ForwardRange >
+        inline bool operator<=( const ForwardRange& l,
+                                const iterator_range<IteratorT>& r )
+        {
+            return iterator_range_detail::less_or_equal_than( l, r );
+        }
+        
+        template< class IteratorT, class ForwardRange >
+        inline bool operator>( const ForwardRange& l,
+                               const iterator_range<IteratorT>& r )
+        {
+            return iterator_range_detail::greater_than( l, r );
+        }
+        
+        template< class IteratorT, class ForwardRange >
+        inline bool operator>=( const ForwardRange& l,
+                                const iterator_range<IteratorT>& r )
+        {
+            return iterator_range_detail::greater_or_equal_than( l, r );
+        }
 
 #ifdef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
 #else
@@ -404,6 +470,48 @@ namespace boost
         {
             return iterator_range_detail::less_than( l, r );
         }
+        
+        template< class Iterator1T, class Iterator2T >
+        inline bool operator<=( const iterator_range<Iterator1T>& l,
+                                const iterator_range<Iterator2T>& r )
+        {
+            return iterator_range_detail::less_or_equal_than( l, r );
+        }
+        
+        template< class IteratorT, class ForwardRange >
+        inline bool operator<=( const iterator_range<IteratorT>& l,
+                                const ForwardRange& r )
+        {
+            return iterator_range_detail::less_or_equal_than( l, r );
+        }
+        
+        template< class Iterator1T, class Iterator2T >
+        inline bool operator>( const iterator_range<Iterator1T>& l,
+                               const iterator_range<Iterator2T>& r )
+        {
+            return iterator_range_detail::greater_than( l, r );
+        }
+        
+        template< class IteratorT, class ForwardRange >
+        inline bool operator>( const iterator_range<IteratorT>& l,
+                               const ForwardRange& r )
+        {
+            return iterator_range_detail::greater_than( l, r );
+        }
+        
+        template< class Iterator1T, class Iterator2T >
+        inline bool operator>=( const iterator_range<Iterator1T>& l,
+                                const iterator_range<Iterator2T>& r )
+        {
+            return iterator_range_detail::greater_or_equal_than( l, r );
+        }
+        
+        template< class IteratorT, class ForwardRange >
+        inline bool operator>=( const iterator_range<IteratorT>& l,
+                                const ForwardRange& r )
+        {
+            return iterator_range_detail::greater_or_equal_than( l, r );
+        }
 
 #endif // BOOST_NO_FUNCTION_TEMPLATE_ORDERING
 

data/ext/boost/range/size.hpp

@@ -15,6 +15,7 @@
 # pragma once
 #endif
 
+#include <boost/range/config.hpp>
 #include <boost/range/begin.hpp>
 #include <boost/range/end.hpp>
 #include <boost/range/difference_type.hpp>
@@ -22,13 +23,28 @@
 
 namespace boost
 {
+    namespace range_detail
+    {
+        template<class SinglePassRange>
+        inline BOOST_DEDUCED_TYPENAME range_difference<SinglePassRange>::type
+        range_calculate_size(const SinglePassRange& rng)
+        {
+            BOOST_ASSERT( (boost::end(rng) - boost::begin(rng)) >= 0 &&
+                          "reachability invariant broken!" );
+            return boost::end(rng) - boost::begin(rng);
+        }
+    }
 
-    template< class T >
-    inline BOOST_DEDUCED_TYPENAME range_difference<T>::type size( const T& r )
+    template<class SinglePassRange>
+    inline BOOST_DEDUCED_TYPENAME range_difference<SinglePassRange>::type
+    size(const SinglePassRange& rng)
     {
-        BOOST_ASSERT( (boost::end( r ) - boost::begin( r )) >= 0 &&
-                      "reachability invariant broken!" );
-        return boost::end( r ) - boost::begin( r );
+#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) && \
+    !BOOST_WORKAROUND(__GNUC__, < 3) \
+    /**/
+        using namespace range_detail;
+#endif
+        return range_calculate_size(rng);
     }
 
 } // namespace 'boost'