passenger 3.0.21 → 3.9.1.beta

data/ext/boost/algorithm/string/detail/case_conv.hpp

@@ -15,6 +15,8 @@
 #include <locale>
 #include <functional>
 
+#include <boost/type_traits/make_unsigned.hpp>
+
 namespace boost {
     namespace algorithm {
         namespace detail {
@@ -37,7 +39,7 @@ namespace boost {
                 CharT operator ()( CharT Ch ) const
                 {
                     #if defined(__BORLANDC__) && (__BORLANDC__ >= 0x560) && (__BORLANDC__ <= 0x564) && !defined(_USE_OLD_RW_STL)
-                        return std::tolower( Ch);
+                        return std::tolower( static_cast<typename boost::make_unsigned <CharT>::type> ( Ch ));
                     #else
                         return std::tolower<CharT>( Ch, *m_Loc );
                     #endif
@@ -57,7 +59,7 @@ namespace boost {
                 CharT operator ()( CharT Ch ) const
                 {
                     #if defined(__BORLANDC__) && (__BORLANDC__ >= 0x560) && (__BORLANDC__ <= 0x564) && !defined(_USE_OLD_RW_STL)
-                        return std::toupper( Ch);
+                        return std::toupper( static_cast<typename boost::make_unsigned <CharT>::type> ( Ch ));
                     #else
                         return std::toupper<CharT>( Ch, *m_Loc );
                     #endif

data/ext/boost/algorithm/string/detail/find_format.hpp

@@ -74,17 +74,17 @@ namespace boost {
                 const InputT& Input,
                 FormatterT Formatter,
                 const FindResultT& FindResult )
-            {       
+            {   
                 if( ::boost::algorithm::detail::check_find_result(Input, FindResult) ) {
-                return ::boost::algorithm::detail::find_format_copy_impl2( 
-                    Output,
-                    Input,
-                    Formatter,
-                    FindResult,
-                    Formatter(FindResult) );
+                    return ::boost::algorithm::detail::find_format_copy_impl2( 
+                        Output,
+                        Input,
+                        Formatter,
+                        FindResult,
+                        Formatter(FindResult) );
                 } else {
                     return std::copy( ::boost::begin(Input), ::boost::end(Input), Output );
-            }
+                }
             }
 
  
@@ -137,14 +137,14 @@ namespace boost {
                 const FindResultT& FindResult)
             {
                 if( ::boost::algorithm::detail::check_find_result(Input, FindResult) ) {
-                return ::boost::algorithm::detail::find_format_copy_impl2(
-                    Input,
-                    Formatter,
-                    FindResult,
-                    Formatter(FindResult) );
+                    return ::boost::algorithm::detail::find_format_copy_impl2(
+                        Input,
+                        Formatter,
+                        FindResult,
+                        Formatter(FindResult) );
                 } else {
                     return Input;
-            }
+                }
             }
 
  // replace implementation ----------------------------------------------------//
@@ -189,12 +189,12 @@ namespace boost {
                 const FindResultT& FindResult)
             {
                 if( ::boost::algorithm::detail::check_find_result(Input, FindResult) ) {
-                ::boost::algorithm::detail::find_format_impl2(
-                    Input,
-                    Formatter,
-                    FindResult,
-                    Formatter(FindResult) );
-            }
+                    ::boost::algorithm::detail::find_format_impl2(
+                        Input,
+                        Formatter,
+                        FindResult,
+                        Formatter(FindResult) );
+                }
             }
 
         } // namespace detail

data/ext/boost/algorithm/string/detail/find_format_all.hpp

@@ -84,18 +84,18 @@ namespace boost {
                 FinderT Finder,
                 FormatterT Formatter,
                 const FindResultT& FindResult )
-            {       
+            {   
                 if( ::boost::algorithm::detail::check_find_result(Input, FindResult) ) {
-                return ::boost::algorithm::detail::find_format_all_copy_impl2( 
-                    Output,
-                    Input,
-                    Finder,
-                    Formatter,
-                    FindResult,
-                    Formatter(FindResult) );
+                    return ::boost::algorithm::detail::find_format_all_copy_impl2( 
+                        Output,
+                        Input,
+                        Finder,
+                        Formatter,
+                        FindResult,
+                        Formatter(FindResult) );
                 } else {
                     return std::copy( ::boost::begin(Input), ::boost::end(Input), Output );
-            }
+                }
             }
 
  // find_format_all_copy implementation ----------------------------------------------//
@@ -161,15 +161,15 @@ namespace boost {
                 const FindResultT& FindResult)
             {
                 if( ::boost::algorithm::detail::check_find_result(Input, FindResult) ) {
-                return ::boost::algorithm::detail::find_format_all_copy_impl2(
-                    Input,
-                    Finder,
-                    Formatter,
-                    FindResult,
-                    Formatter(FindResult) );
+                    return ::boost::algorithm::detail::find_format_all_copy_impl2(
+                        Input,
+                        Finder,
+                        Formatter,
+                        FindResult,
+                        Formatter(FindResult) );
                 } else {
                     return Input;
-            }
+                }
             }
 
  // find_format_all implementation ------------------------------------------------//
@@ -257,13 +257,13 @@ namespace boost {
                 FindResultT FindResult)
             {
                 if( ::boost::algorithm::detail::check_find_result(Input, FindResult) ) {
-                ::boost::algorithm::detail::find_format_all_impl2(
-                    Input,
-                    Finder,
-                    Formatter,
-                    FindResult,
-                    Formatter(FindResult) );
-            }
+                    ::boost::algorithm::detail::find_format_all_impl2(
+                        Input,
+                        Finder,
+                        Formatter,
+                        FindResult,
+                        Formatter(FindResult) );
+                }
             }
 
         } // namespace detail

data/ext/boost/algorithm/string/detail/find_format_store.hpp

@@ -53,7 +53,7 @@ namespace boost {
                 {
                     iterator_range<ForwardIteratorT>::operator=(FindResult);
                     if( !this->empty() ) {
-                    m_FormatResult=m_Formatter(FindResult);
+                        m_FormatResult=m_Formatter(FindResult);
                     }
                     
                     return *this;
@@ -71,7 +71,7 @@ namespace boost {
             };
 
             template<typename InputT, typename FindResultT>
-            bool check_find_result(InputT& Input, FindResultT& FindResult)
+            bool check_find_result(InputT&, FindResultT& FindResult)
             {
                 typedef BOOST_STRING_TYPENAME 
                     range_const_iterator<InputT>::type input_iterator_type; 

data/ext/boost/algorithm/string/detail/formatter.hpp

@@ -87,6 +87,31 @@ namespace boost {
                 }
             };
 
+//  dissect format functor ----------------------------------------------------//
+
+            // dissect format functor
+            template<typename FinderT>
+            struct dissect_formatF
+            {
+            public:
+                // Construction
+                dissect_formatF(FinderT Finder) :
+                  m_Finder(Finder) {}
+
+                  // Operation
+                  template<typename RangeT>
+                  inline iterator_range< 
+                      BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type>
+                  operator()(const RangeT& Replace) const
+                  {
+                      return m_Finder(::boost::begin(Replace), ::boost::end(Replace));
+                  }
+
+            private:
+                FinderT m_Finder;
+            };
+
+
         } // namespace detail
     } // namespace algorithm
 } // namespace boost

data/ext/boost/algorithm/string/formatter.hpp

@@ -36,7 +36,7 @@ namespace boost {
 
         //! Constant formatter
         /*!
-            Construct the \c const_formatter. Const formatter always returns
+            Constructs a \c const_formatter. Const formatter always returns
             the same value, regardless of the parameter.
 
             \param Format A predefined value used as a result for formating
@@ -55,7 +55,7 @@ namespace boost {
 
         //! Identity formatter
         /*!
-            Construct the \c identity_formatter. Identity formatter always returns
+            Constructs an \c identity_formatter. Identity formatter always returns
             the parameter.
 
             \return An instance of the \c identity_formatter object.
@@ -73,7 +73,7 @@ namespace boost {
 
         //! Empty formatter
         /*!
-            Construct the \c empty_formatter. Empty formatter always returns an empty
+            Constructs an \c empty_formatter. Empty formatter always returns an empty
             sequence. 
 
             \param Input container used to select a correct value_type for the
@@ -89,6 +89,22 @@ namespace boost {
                 BOOST_STRING_TYPENAME range_value<RangeT>::type>();
         }
 
+        //! Empty formatter
+        /*!
+            Constructs a \c dissect_formatter. Dissect formatter uses a specified finder
+            to extract a portion of the formatted sequence. The first finder's match is returned 
+            as a result
+
+            \param Finder a finder used to select a portion of the formated sequence
+            \return An instance of the \c dissect_formatter object.
+        */
+        template<typename FinderT>
+        inline detail::dissect_formatF< FinderT >
+        dissect_formatter(const FinderT& Finder)
+        {
+            return detail::dissect_formatF<FinderT>(Finder);
+        }
+
 
     } // namespace algorithm
 
@@ -96,6 +112,7 @@ namespace boost {
     using algorithm::const_formatter;
     using algorithm::identity_formatter;
     using algorithm::empty_formatter;
+    using algorithm::dissect_formatter;
 
 } // namespace boost
 

data/ext/boost/assert.hpp

@@ -1,8 +1,11 @@
 //
 //  boost/assert.hpp - BOOST_ASSERT(expr)
+//                     BOOST_ASSERT_MSG(expr, msg)
+//                     BOOST_VERIFY(expr)
 //
 //  Copyright (c) 2001, 2002 Peter Dimov and Multi Media Ltd.
 //  Copyright (c) 2007 Peter Dimov
+//  Copyright (c) Beman Dawes 2011
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
@@ -13,6 +16,16 @@
 //  See http://www.boost.org/libs/utility/assert.html for documentation.
 //
 
+//
+// Stop inspect complaining about use of 'assert':
+//
+// boostinspect:naassert_macro
+//
+
+//--------------------------------------------------------------------------------------//
+//                                     BOOST_ASSERT                                     //
+//--------------------------------------------------------------------------------------//
+
 #undef BOOST_ASSERT
 
 #if defined(BOOST_DISABLE_ASSERTS)
@@ -25,18 +38,86 @@
 
 namespace boost
 {
-
-void assertion_failed(char const * expr, char const * function, char const * file, long line); // user defined
-
+  void assertion_failed(char const * expr,
+                        char const * function, char const * file, long line); // user defined
 } // namespace boost
 
-#define BOOST_ASSERT(expr) ((expr)? ((void)0): ::boost::assertion_failed(#expr, BOOST_CURRENT_FUNCTION, __FILE__, __LINE__))
+#define BOOST_ASSERT(expr) ((expr) \
+  ? ((void)0) \
+  : ::boost::assertion_failed(#expr, BOOST_CURRENT_FUNCTION, __FILE__, __LINE__))
 
 #else
 # include <assert.h> // .h to support old libraries w/o <cassert> - effect is the same
 # define BOOST_ASSERT(expr) assert(expr)
 #endif
 
+//--------------------------------------------------------------------------------------//
+//                                   BOOST_ASSERT_MSG                                   //
+//--------------------------------------------------------------------------------------//
+
+# undef BOOST_ASSERT_MSG
+
+#if defined(BOOST_DISABLE_ASSERTS) || defined(NDEBUG)
+
+  #define BOOST_ASSERT_MSG(expr, msg) ((void)0)
+
+#elif defined(BOOST_ENABLE_ASSERT_HANDLER)
+
+  #include <boost/current_function.hpp>
+
+  namespace boost
+  {
+    void assertion_failed_msg(char const * expr, char const * msg,
+                              char const * function, char const * file, long line); // user defined
+  } // namespace boost
+
+  #define BOOST_ASSERT_MSG(expr, msg) ((expr) \
+    ? ((void)0) \
+    : ::boost::assertion_failed_msg(#expr, msg, BOOST_CURRENT_FUNCTION, __FILE__, __LINE__))
+
+#else
+  #ifndef BOOST_ASSERT_HPP
+    #define BOOST_ASSERT_HPP
+    #include <cstdlib>
+    #include <iostream>
+    #include <boost/current_function.hpp>
+
+    //  IDE's like Visual Studio perform better if output goes to std::cout or
+    //  some other stream, so allow user to configure output stream:
+    #ifndef BOOST_ASSERT_MSG_OSTREAM
+    # define BOOST_ASSERT_MSG_OSTREAM std::cerr
+    #endif
+
+    namespace boost
+    { 
+      namespace assertion 
+      { 
+        namespace detail
+        {
+          inline void assertion_failed_msg(char const * expr, char const * msg, char const * function,
+            char const * file, long line)
+          {
+            BOOST_ASSERT_MSG_OSTREAM
+              << "***** Internal Program Error - assertion (" << expr << ") failed in "
+              << function << ":\n"
+              << file << '(' << line << "): " << msg << std::endl;
+            std::abort();
+          }
+        } // detail
+      } // assertion
+    } // detail
+  #endif
+
+  #define BOOST_ASSERT_MSG(expr, msg) ((expr) \
+    ? ((void)0) \
+    : ::boost::assertion::detail::assertion_failed_msg(#expr, msg, \
+          BOOST_CURRENT_FUNCTION, __FILE__, __LINE__))
+#endif
+
+//--------------------------------------------------------------------------------------//
+//                                     BOOST_VERIFY                                     //
+//--------------------------------------------------------------------------------------//
+
 #undef BOOST_VERIFY
 
 #if defined(BOOST_DISABLE_ASSERTS) || ( !defined(BOOST_ENABLE_ASSERT_HANDLER) && defined(NDEBUG) )

data/ext/boost/bind/bind.hpp

@@ -1680,7 +1680,7 @@ template< class R, class T > struct add_cref< R (T::*) (), 1 >
     typedef void type;
 };
 
-#if !( defined(__IBMCPP__) && BOOST_WORKAROUND( __IBMCPP__, BOOST_TESTED_AT(600) ) )
+#if !defined(__IBMCPP__) || __IBMCPP_FUNC_CV_TMPL_ARG_DEDUCTION
 
 template< class R, class T > struct add_cref< R (T::*) () const, 1 >
 {

data/ext/boost/concept/detail/backward_compatibility.hpp

@@ -8,7 +8,7 @@ namespace boost
 {
   namespace concepts {}
 
-# if !defined(BOOST_NO_CONCEPTS) && !defined(BOOST_CONCEPT_NO_BACKWARD_KEYWORD)
+# if defined(BOOST_HAS_CONCEPTS) && !defined(BOOST_CONCEPT_NO_BACKWARD_KEYWORD)
   namespace concept = concepts;
 # endif 
 } // namespace boost::concept

data/ext/boost/concept_check.hpp

@@ -1,5 +1,7 @@
 //
 // (C) Copyright Jeremy Siek 2000.
+// Copyright 2002 The Trustees of Indiana University.
+//
 // 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)
@@ -36,14 +38,14 @@ namespace boost
   //
   // Backward compatibility
   //
-  
+
   template <class Model>
   inline void function_requires(Model* = 0)
   {
       BOOST_CONCEPT_ASSERT((Model));
-  }    
+  }
   template <class T> inline void ignore_unused_variable_warning(T const&) {}
-  
+
 #  define BOOST_CLASS_REQUIRE(type_var, ns, concept)    \
     BOOST_CONCEPT_ASSERT((ns::concept<type_var>))
 
@@ -56,20 +58,21 @@ namespace boost
 #  define BOOST_CLASS_REQUIRE4(tv1, tv2, tv3, tv4, ns, concept) \
     BOOST_CONCEPT_ASSERT((ns::concept<tv1,tv2,tv3,tv4>))
 
-  
+
   //
   // Begin concept definitions
   //
   BOOST_concept(Integer, (T))
   {
       BOOST_CONCEPT_USAGE(Integer)
-        { 
+        {
             x.error_type_must_be_an_integer_type();
         }
    private:
       T x;
   };
 
+  template <> struct Integer<char> {};
   template <> struct Integer<signed char> {};
   template <> struct Integer<unsigned char> {};
   template <> struct Integer<short> {};
@@ -87,7 +90,7 @@ namespace boost
 # endif
 
   BOOST_concept(SignedInteger,(T)) {
-    BOOST_CONCEPT_USAGE(SignedInteger) { 
+    BOOST_CONCEPT_USAGE(SignedInteger) {
       x.error_type_must_be_a_signed_integer_type();
     }
    private:
@@ -101,16 +104,16 @@ namespace boost
   template <> struct SignedInteger< ::boost::long_long_type> {};
 # elif defined(BOOST_HAS_MS_INT64)
   template <> struct SignedInteger<__int64> {};
-# endif      
+# endif
 
   BOOST_concept(UnsignedInteger,(T)) {
-    BOOST_CONCEPT_USAGE(UnsignedInteger) { 
+    BOOST_CONCEPT_USAGE(UnsignedInteger) {
       x.error_type_must_be_an_unsigned_integer_type();
     }
    private:
     T x;
   };
-  
+
   template <> struct UnsignedInteger<unsigned char> {};
   template <> struct UnsignedInteger<unsigned short> {};
   template <> struct UnsignedInteger<unsigned int> {};
@@ -136,23 +139,24 @@ namespace boost
   {
     BOOST_CONCEPT_USAGE(Assignable) {
 #if !defined(_ITERATOR_) // back_insert_iterator broken for VC++ STL
-      a = a;             // require assignment operator
+      a = b;             // require assignment operator
 #endif
-      const_constraints(a);
+      const_constraints(b);
     }
    private:
-    void const_constraints(const TT& b) {
+    void const_constraints(const TT& x) {
 #if !defined(_ITERATOR_) // back_insert_iterator broken for VC++ STL
-      a = b;              // const required for argument to assignment
+      a = x;              // const required for argument to assignment
 #else
-      ignore_unused_variable_warning(b);
+      ignore_unused_variable_warning(x);
 #endif
     }
    private:
     TT a;
+    TT b;
   };
 
-  
+
   BOOST_concept(CopyConstructible,(TT))
   {
     BOOST_CONCEPT_USAGE(CopyConstructible) {
@@ -180,22 +184,23 @@ namespace boost
   BOOST_concept(SGIAssignable,(TT))
   {
     BOOST_CONCEPT_USAGE(SGIAssignable) {
-      TT b(a);
+      TT c(a);
 #if !defined(_ITERATOR_) // back_insert_iterator broken for VC++ STL
-      a = a;              // require assignment operator
+      a = b;              // require assignment operator
 #endif
-      const_constraints(a);
-      ignore_unused_variable_warning(b);
+      const_constraints(b);
+      ignore_unused_variable_warning(c);
     }
    private:
-    void const_constraints(const TT& b) {
-      TT c(b);
+    void const_constraints(const TT& x) {
+      TT c(x);
 #if !defined(_ITERATOR_) // back_insert_iterator broken for VC++ STL
-      a = b;              // const required for argument to assignment
+      a = x;              // const required for argument to assignment
 #endif
       ignore_unused_variable_warning(c);
     }
     TT a;
+    TT b;
   };
 #if (defined _MSC_VER)
 # pragma warning( pop )
@@ -297,7 +302,7 @@ namespace boost
   BOOST_concept(Generator,(Func)(Return))
   {
       BOOST_CONCEPT_USAGE(Generator) { test(is_void<Return>()); }
-      
+
    private:
       void test(boost::mpl::false_)
       {
@@ -310,22 +315,22 @@ namespace boost
       {
           f();
       }
-      
+
       Func f;
   };
 
   BOOST_concept(UnaryFunction,(Func)(Return)(Arg))
   {
       BOOST_CONCEPT_USAGE(UnaryFunction) { test(is_void<Return>()); }
-      
+
    private:
       void test(boost::mpl::false_)
       {
           f(arg);               // "priming the pump" this way keeps msvc6 happy (ICE)
           Return r = f(arg);
-          ignore_unused_variable_warning(r); 
+          ignore_unused_variable_warning(r);
       }
-      
+
       void test(boost::mpl::true_)
       {
           f(arg);
@@ -354,12 +359,21 @@ namespace boost
           Return r = f(first, second); // require operator()
           (void)r;
       }
-      
+
       void test(boost::mpl::true_)
       {
           f(first,second);
       }
-      
+
+#if (BOOST_WORKAROUND(__GNUC__, BOOST_TESTED_AT(4) \
+                      && BOOST_WORKAROUND(__GNUC__, > 3)))
+      // Declare a dummy constructor to make gcc happy.
+      // It seems the compiler can not generate a sensible constructor when this is instantiated with a refence type.
+      // (warning: non-static reference "const double& boost::BinaryFunction<YourClassHere>::arg"
+      // in class without a constructor [-Wuninitialized])
+      BinaryFunction();
+#endif
+
       Func f;
       First first;
       Second second;
@@ -371,6 +385,15 @@ namespace boost
       require_boolean_expr(f(arg)); // require operator() returning bool
     }
    private:
+#if (BOOST_WORKAROUND(__GNUC__, BOOST_TESTED_AT(4) \
+                      && BOOST_WORKAROUND(__GNUC__, > 3)))
+      // Declare a dummy constructor to make gcc happy.
+      // It seems the compiler can not generate a sensible constructor when this is instantiated with a refence type.
+      // (warning: non-static reference "const double& boost::UnaryPredicate<YourClassHere>::arg"
+      // in class without a constructor [-Wuninitialized])
+      UnaryPredicate();
+#endif
+
     Func f;
     Arg arg;
   };
@@ -381,6 +404,14 @@ namespace boost
       require_boolean_expr(f(a, b)); // require operator() returning bool
     }
    private:
+#if (BOOST_WORKAROUND(__GNUC__, BOOST_TESTED_AT(4) \
+                      && BOOST_WORKAROUND(__GNUC__, > 3)))
+      // Declare a dummy constructor to make gcc happy.
+      // It seems the compiler can not generate a sensible constructor when this is instantiated with a refence type.
+      // (warning: non-static reference "const double& boost::BinaryPredicate<YourClassHere>::arg"
+      // in class without a constructor [-Wuninitialized])
+      BinaryPredicate();
+#endif
     Func f;
     First a;
     Second b;
@@ -390,7 +421,7 @@ namespace boost
   BOOST_concept(Const_BinaryPredicate,(Func)(First)(Second))
     : BinaryPredicate<Func, First, Second>
   {
-    BOOST_CONCEPT_USAGE(Const_BinaryPredicate) { 
+    BOOST_CONCEPT_USAGE(Const_BinaryPredicate) {
       const_constraints(f);
     }
    private:
@@ -398,6 +429,15 @@ namespace boost
       // operator() must be a const member function
       require_boolean_expr(fun(a, b));
     }
+#if (BOOST_WORKAROUND(__GNUC__, BOOST_TESTED_AT(4) \
+                      && BOOST_WORKAROUND(__GNUC__, > 3)))
+      // Declare a dummy constructor to make gcc happy.
+      // It seems the compiler can not generate a sensible constructor when this is instantiated with a refence type.
+      // (warning: non-static reference "const double& boost::Const_BinaryPredicate<YourClassHere>::arg"
+      // in class without a constructor [-Wuninitialized])
+      Const_BinaryPredicate();
+#endif
+
     Func f;
     First a;
     Second b;
@@ -407,7 +447,7 @@ namespace boost
     : Generator<Func, typename Func::result_type>
   {
       typedef typename Func::result_type result_type;
-      
+
       BOOST_CONCEPT_USAGE(AdaptableGenerator)
       {
           BOOST_CONCEPT_ASSERT((Convertible<result_type, Return>));
@@ -438,7 +478,7 @@ namespace boost
       typedef typename Func::first_argument_type first_argument_type;
       typedef typename Func::second_argument_type second_argument_type;
       typedef typename Func::result_type result_type;
-      
+
       ~AdaptableBinaryFunction()
       {
           BOOST_CONCEPT_ASSERT((Convertible<result_type, Return>));
@@ -476,7 +516,7 @@ namespace boost
       {
         BOOST_CONCEPT_ASSERT((SignedInteger<difference_type>));
         BOOST_CONCEPT_ASSERT((Convertible<iterator_category, std::input_iterator_tag>));
-        
+
         TT j(i);
         (void)*i;           // require dereference operator
         ++j;                // require preincrement operator
@@ -490,7 +530,7 @@ namespace boost
     : Assignable<TT>
   {
     BOOST_CONCEPT_USAGE(OutputIterator) {
-      
+
       ++i;                // require preincrement operator
       i++;                // require postincrement operator
       *i++ = t;           // require postincrement and assignment
@@ -509,11 +549,11 @@ namespace boost
               BOOST_DEDUCED_TYPENAME ForwardIterator::iterator_category
             , std::forward_iterator_tag
           >));
-          
+
           typename InputIterator<TT>::reference r = *i;
           ignore_unused_variable_warning(r);
       }
-      
+
    private:
       TT i;
   };
@@ -575,7 +615,7 @@ namespace boost
           n = i - j;                  // require difference operator
           (void)i[n];                 // require element access operator
       }
-      
+
    private:
     TT a, b;
     TT i, j;
@@ -613,7 +653,7 @@ namespace boost
           BOOST_CONCEPT_ASSERT((InputIterator<const_iterator>));
           const_constraints(c);
       }
-      
+
    private:
       void const_constraints(const C& cc) {
           i = cc.begin();
@@ -634,19 +674,19 @@ namespace boost
       typedef typename C::reference reference;
       typedef typename C::iterator iterator;
       typedef typename C::pointer pointer;
-    
+
       BOOST_CONCEPT_USAGE(Mutable_Container)
       {
           BOOST_CONCEPT_ASSERT((
                Assignable<typename Mutable_Container::value_type>));
-          
+
           BOOST_CONCEPT_ASSERT((InputIterator<iterator>));
-          
+
           i = c.begin();
           i = c.end();
           c.swap(c2);
       }
-      
+
    private:
       iterator i;
       C c, c2;
@@ -662,7 +702,7 @@ namespace boost
                     typename ForwardContainer::const_iterator
                >));
       }
-  };  
+  };
 
   BOOST_concept(Mutable_ForwardContainer,(C))
     : ForwardContainer<C>
@@ -675,7 +715,7 @@ namespace boost
                    typename Mutable_ForwardContainer::iterator
                >));
       }
-  };  
+  };
 
   BOOST_concept(ReversibleContainer,(C))
     : ForwardContainer<C>
@@ -689,9 +729,9 @@ namespace boost
           BOOST_CONCEPT_ASSERT((
               BidirectionalIterator<
                   typename ReversibleContainer::const_iterator>));
-          
+
           BOOST_CONCEPT_ASSERT((BidirectionalIterator<const_reverse_iterator>));
-          
+
           const_constraints(c);
       }
    private:
@@ -708,17 +748,17 @@ namespace boost
     , ReversibleContainer<C>
   {
       typedef typename C::reverse_iterator reverse_iterator;
-      
+
       BOOST_CONCEPT_USAGE(Mutable_ReversibleContainer)
       {
           typedef typename Mutable_ForwardContainer<C>::iterator iterator;
           BOOST_CONCEPT_ASSERT((Mutable_BidirectionalIterator<iterator>));
           BOOST_CONCEPT_ASSERT((Mutable_BidirectionalIterator<reverse_iterator>));
-          
+
           reverse_iterator i = c.rbegin();
           i = c.rend();
       }
-   private:  
+   private:
       C c;
   };
 
@@ -734,7 +774,7 @@ namespace boost
               RandomAccessIterator<
                   typename RandomAccessContainer::const_iterator
               >));
-          
+
           const_constraints(c);
       }
    private:
@@ -743,7 +783,7 @@ namespace boost
           const_reference r = cc[n];
           ignore_unused_variable_warning(r);
       }
-    
+
       C c;
       size_type n;
   };
@@ -759,11 +799,11 @@ namespace boost
       {
           BOOST_CONCEPT_ASSERT((Mutable_RandomAccessIterator<typename self::iterator>));
           BOOST_CONCEPT_ASSERT((Mutable_RandomAccessIterator<typename self::reverse_iterator>));
-          
+
           typename self::reference r = c[i];
           ignore_unused_variable_warning(r);
       }
-      
+
    private:
       typename Mutable_ReversibleContainer<C>::size_type i;
       C c;
@@ -779,7 +819,7 @@ namespace boost
   {
       BOOST_CONCEPT_USAGE(Sequence)
       {
-          S 
+          S
               c(n),
               c2(n, t),
               c3(first, last);
@@ -804,7 +844,7 @@ namespace boost
           typename Sequence::const_reference r = c.front();
           ignore_unused_variable_warning(r);
       }
-    
+
       typename S::value_type t;
       typename S::size_type n;
       typename S::value_type* first, *last;
@@ -863,11 +903,11 @@ namespace boost
           c.erase(r.first, r.second);
           const_constraints(c);
           BOOST_CONCEPT_ASSERT((BinaryPredicate<key_compare,key_type,key_type>));
-          
+
           typedef typename AssociativeContainer::value_type value_type_;
           BOOST_CONCEPT_ASSERT((BinaryPredicate<value_compare,value_type_,value_type_>));
       }
-      
+
       // Redundant with the base concept, but it helps below.
       typedef typename C::const_iterator const_iterator;
    private:
@@ -893,7 +933,7 @@ namespace boost
       BOOST_CONCEPT_USAGE(UniqueAssociativeContainer)
       {
           C c(first, last);
-      
+
           pos_flag = c.insert(t);
           c.insert(first, last);
 
@@ -911,7 +951,7 @@ namespace boost
       BOOST_CONCEPT_USAGE(MultipleAssociativeContainer)
       {
           C c(first, last);
-      
+
           pos = c.insert(t);
           c.insert(first, last);
 
@@ -954,7 +994,7 @@ namespace boost
   {
       BOOST_CONCEPT_USAGE(SortedAssociativeContainer)
       {
-          C 
+          C
               c(kc),
               c2(first, last),
               c3(first, last, kc);
@@ -962,15 +1002,15 @@ namespace boost
           p = c.upper_bound(k);
           p = c.lower_bound(k);
           r = c.equal_range(k);
-      
+
           c.insert(p, t);
-      
+
           ignore_unused_variable_warning(c);
           ignore_unused_variable_warning(c2);
           ignore_unused_variable_warning(c3);
           const_constraints(c);
       }
-      
+
       void const_constraints(const C& c)
       {
           kc = c.key_comp();
@@ -980,7 +1020,7 @@ namespace boost
           cp = c.lower_bound(k);
           cr = c.equal_range(k);
       }
-      
+
    private:
       typename C::key_compare kc;
       typename C::value_compare vc;
@@ -999,6 +1039,42 @@ namespace boost
 
   // HashedAssociativeContainer
 
+  BOOST_concept(Collection,(C))
+  {
+      BOOST_CONCEPT_USAGE(Collection)
+      {
+        boost::function_requires<boost::InputIteratorConcept<iterator> >();
+        boost::function_requires<boost::InputIteratorConcept<const_iterator> >();
+        boost::function_requires<boost::CopyConstructibleConcept<value_type> >();
+        const_constraints(c);
+        i = c.begin();
+        i = c.end();
+        c.swap(c);
+      }
+
+      void const_constraints(const C& c) {
+        ci = c.begin();
+        ci = c.end();
+        n = c.size();
+        b = c.empty();
+      }
+
+    private:
+      typedef typename C::value_type value_type;
+      typedef typename C::iterator iterator;
+      typedef typename C::const_iterator const_iterator;
+      typedef typename C::reference reference;
+      typedef typename C::const_reference const_reference;
+      // typedef typename C::pointer pointer;
+      typedef typename C::difference_type difference_type;
+      typedef typename C::size_type size_type;
+
+      C c;
+      bool b;
+      iterator i;
+      const_iterator ci;
+      size_type n;
+  };
 } // namespace boost
 
 # include <boost/concept/detail/concept_undef.hpp>