passenger 3.0.21 → 3.9.1.beta

data/ext/boost/mpl/vector/aux_/vector0.hpp

@@ -0,0 +1,52 @@
+
+#ifndef BOOST_MPL_VECTOR_AUX_VECTOR0_HPP_INCLUDED
+#define BOOST_MPL_VECTOR_AUX_VECTOR0_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2000-2004
+//
+// 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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id: vector0.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
+
+#include <boost/mpl/long.hpp>
+#include <boost/mpl/void.hpp>
+#include <boost/mpl/aux_/na.hpp>
+#include <boost/mpl/aux_/type_wrapper.hpp>
+
+#include <boost/mpl/vector/aux_/iterator.hpp>
+#include <boost/mpl/vector/aux_/tag.hpp>
+#include <boost/mpl/aux_/config/typeof.hpp>
+
+namespace boost { namespace mpl {
+
+template< typename Dummy = na > struct vector0;
+
+template<> struct vector0<na>
+{
+#if defined(BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES)
+    typedef aux::vector_tag tag;
+    typedef vector0         type;
+    typedef long_<32768>    lower_bound_;
+    typedef lower_bound_    upper_bound_;
+    typedef long_<0>        size;
+
+    static aux::type_wrapper<void_> item_(...);
+#else
+    typedef aux::vector_tag<0> tag;
+    typedef vector0 type;
+    typedef void_ item0;
+    
+    typedef v_iter<vector0<>,0> begin;
+    typedef v_iter<vector0<>,0> end;
+#endif
+};
+
+}}
+
+#endif // BOOST_MPL_VECTOR_AUX_VECTOR0_HPP_INCLUDED

data/ext/boost/mpl/vector/vector0.hpp

@@ -0,0 +1,34 @@
+
+#ifndef BOOST_MPL_VECTOR_VECTOR0_HPP_INCLUDED
+#define BOOST_MPL_VECTOR_VECTOR0_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2000-2004
+//
+// 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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id: vector0.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
+
+#include <boost/mpl/vector/aux_/at.hpp>
+#include <boost/mpl/vector/aux_/front.hpp>
+#include <boost/mpl/vector/aux_/push_front.hpp>
+#include <boost/mpl/vector/aux_/pop_front.hpp>
+#include <boost/mpl/vector/aux_/push_back.hpp>
+#include <boost/mpl/vector/aux_/pop_back.hpp>
+#include <boost/mpl/vector/aux_/back.hpp>
+#include <boost/mpl/vector/aux_/clear.hpp>
+#include <boost/mpl/vector/aux_/O1_size.hpp>
+#include <boost/mpl/vector/aux_/size.hpp>
+#include <boost/mpl/vector/aux_/empty.hpp>
+#include <boost/mpl/vector/aux_/item.hpp>
+#include <boost/mpl/vector/aux_/iterator.hpp>
+#include <boost/mpl/vector/aux_/vector0.hpp>
+#include <boost/mpl/vector/aux_/begin_end.hpp>
+#include <boost/mpl/vector/aux_/tag.hpp>
+
+#endif // BOOST_MPL_VECTOR_VECTOR0_HPP_INCLUDED

data/ext/boost/mpl/vector/vector10.hpp

@@ -0,0 +1,45 @@
+
+#ifndef BOOST_MPL_VECTOR_VECTOR10_HPP_INCLUDED
+#define BOOST_MPL_VECTOR_VECTOR10_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2000-2004
+//
+// 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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id: vector10.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
+
+#if !defined(BOOST_MPL_PREPROCESSING_MODE)
+#   include <boost/mpl/vector/vector0.hpp>
+#endif
+
+#include <boost/mpl/aux_/config/use_preprocessed.hpp>
+
+#if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \
+    && !defined(BOOST_MPL_PREPROCESSING_MODE)
+
+#   define BOOST_MPL_PREPROCESSED_HEADER vector10.hpp
+#   include <boost/mpl/vector/aux_/include_preprocessed.hpp>
+
+#else
+
+#   include <boost/mpl/aux_/config/typeof.hpp>
+#   include <boost/mpl/aux_/config/ctps.hpp>
+#   include <boost/preprocessor/iterate.hpp>
+
+namespace boost { namespace mpl {
+
+#   define BOOST_PP_ITERATION_PARAMS_1 \
+    (3,(0, 10, <boost/mpl/vector/aux_/numbered.hpp>))
+#   include BOOST_PP_ITERATE()
+
+}}
+
+#endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS
+
+#endif // BOOST_MPL_VECTOR_VECTOR10_HPP_INCLUDED

data/ext/boost/mpl/vector/vector20.hpp

@@ -0,0 +1,45 @@
+
+#ifndef BOOST_MPL_VECTOR_VECTOR20_HPP_INCLUDED
+#define BOOST_MPL_VECTOR_VECTOR20_HPP_INCLUDED
+
+// Copyright Aleksey Gurtovoy 2000-2004
+//
+// 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)
+//
+// See http://www.boost.org/libs/mpl for documentation.
+
+// $Id: vector20.hpp 49267 2008-10-11 06:19:02Z agurtovoy $
+// $Date: 2008-10-11 02:19:02 -0400 (Sat, 11 Oct 2008) $
+// $Revision: 49267 $
+
+#if !defined(BOOST_MPL_PREPROCESSING_MODE)
+#   include <boost/mpl/vector/vector10.hpp>
+#endif
+
+#include <boost/mpl/aux_/config/use_preprocessed.hpp>
+
+#if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \
+    && !defined(BOOST_MPL_PREPROCESSING_MODE)
+
+#   define BOOST_MPL_PREPROCESSED_HEADER vector20.hpp
+#   include <boost/mpl/vector/aux_/include_preprocessed.hpp>
+
+#else
+
+#   include <boost/mpl/aux_/config/typeof.hpp>
+#   include <boost/mpl/aux_/config/ctps.hpp>
+#   include <boost/preprocessor/iterate.hpp>
+
+namespace boost { namespace mpl {
+
+#   define BOOST_PP_ITERATION_PARAMS_1 \
+    (3,(11, 20, <boost/mpl/vector/aux_/numbered.hpp>))
+#   include BOOST_PP_ITERATE()
+
+}}
+
+#endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS
+
+#endif // BOOST_MPL_VECTOR_VECTOR20_HPP_INCLUDED

data/ext/boost/none.hpp

@@ -20,7 +20,7 @@
 
 namespace boost {
 
-none_t const none = ((none_t)0) ;
+none_t const none = (static_cast<none_t>(0)) ;
 
 } // namespace boost
 

data/ext/boost/numeric/conversion/bounds.hpp

@@ -0,0 +1,24 @@
+//  (c) Copyright Fernando Luis Cacciola Carballal 2000-2004
+//  Use, modification, and distribution is subject to 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)
+
+//  See library home page at http://www.boost.org/libs/numeric/conversion
+//
+// Contact the author at: fernando_cacciola@hotmail.com
+// 
+#ifndef BOOST_NUMERIC_CONVERSION_BOUNDS_12NOV2002_HPP
+#define BOOST_NUMERIC_CONVERSION_BOUNDS_12NOV2002_HPP
+
+#include "boost/numeric/conversion/detail/bounds.hpp"
+
+namespace boost { namespace numeric 
+{
+
+template<class N>
+struct bounds : boundsdetail::get_impl<N>::type
+{} ;
+
+} } // namespace boost::numeric
+
+#endif

data/ext/boost/numeric/conversion/cast.hpp

@@ -0,0 +1,61 @@
+//  (c) Copyright Fernando Luis Cacciola Carballal 2000-2004
+//  Use, modification, and distribution is subject to 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)
+
+//  See library home page at http://www.boost.org/libs/numeric/conversion
+//
+// Contact the author at: fernando_cacciola@hotmail.com
+//
+//
+//  Revision History
+//
+//    19 Nov 2001 Syntatic changes as suggested by Darin Adler (Fernando Cacciola)
+//    08 Nov 2001 Fixes to accommodate MSVC (Fernando Cacciola)
+//    04 Nov 2001 Fixes to accommodate gcc2.92 (Fernando Cacciola)
+//    30 Oct 2001 Some fixes suggested by Daryle Walker (Fernando Cacciola)
+//    25 Oct 2001 Initial boostification (Fernando Cacciola)
+//    23 Jan 2004 Inital add to cvs (post review)s
+//    22 Jun 2011 Added support for specializing cast policies via numeric_cast_traits (Brandon Kohn).
+//
+#ifndef BOOST_NUMERIC_CONVERSION_CAST_25OCT2001_HPP
+#define BOOST_NUMERIC_CONVERSION_CAST_25OCT2001_HPP
+
+#include <boost/detail/workaround.hpp>
+
+#if BOOST_WORKAROUND(BOOST_MSVC, < 1300) || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x582))
+
+#  include<boost/numeric/conversion/detail/old_numeric_cast.hpp>
+
+#else
+
+#include <boost/type.hpp>
+#include <boost/numeric/conversion/converter.hpp>
+#include <boost/numeric/conversion/numeric_cast_traits.hpp>
+
+namespace boost
+{
+    template <typename Target, typename Source> 
+    inline Target numeric_cast( Source arg )
+    {
+        typedef numeric::conversion_traits<Target, Source>   conv_traits;
+        typedef numeric::numeric_cast_traits<Target, Source> cast_traits;
+        typedef boost::numeric::converter
+            <
+                Target,
+                Source, 
+                conv_traits,
+                typename cast_traits::overflow_policy, 
+                typename cast_traits::rounding_policy, 
+                boost::numeric::raw_converter< conv_traits >,
+                typename cast_traits::range_checking_policy
+            > converter;
+        return converter::convert(arg);
+    }
+    
+    using numeric::bad_numeric_cast;
+} // namespace boost
+
+#endif
+
+#endif

data/ext/boost/numeric/conversion/conversion_traits.hpp

@@ -0,0 +1,39 @@
+//  (c) Copyright Fernando Luis Cacciola Carballal 2000-2004
+//  Use, modification, and distribution is subject to 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)
+
+//  See library home page at http://www.boost.org/libs/numeric/conversion
+//
+// Contact the author at: fernando_cacciola@hotmail.com
+// 
+#ifndef BOOST_NUMERIC_CONVERSION_CONVERSION_TRAITS_FLC_12NOV2002_HPP
+#define BOOST_NUMERIC_CONVERSION_CONVERSION_TRAITS_FLC_12NOV2002_HPP
+
+#include "boost/numeric/conversion/detail/conversion_traits.hpp"
+#include "boost/detail/workaround.hpp"
+#include "boost/config.hpp"
+
+namespace boost { namespace numeric
+{
+
+template<class T, class S>
+struct conversion_traits 
+    : convdetail::get_conversion_traits<T,S>::type 
+{
+#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
+    typedef typename convdetail::get_conversion_traits<T,S>::type base_;
+    typedef typename base_::target_type     target_type;
+    typedef typename base_::source_type     source_type;
+    typedef typename base_::result_type     result_type;
+    typedef typename base_::argument_type   argument_type;
+#endif
+} ;
+
+} } // namespace boost::numeric
+
+#endif
+//
+///////////////////////////////////////////////////////////////////////////////////////////////
+
+

data/ext/boost/numeric/conversion/converter.hpp

@@ -0,0 +1,68 @@
+//  (c) Copyright Fernando Luis Cacciola Carballal 2000-2004
+//  Use, modification, and distribution is subject to 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)
+
+//  See library home page at http://www.boost.org/libs/numeric/conversion
+//
+// Contact the author at: fernando_cacciola@hotmail.com
+// 
+#ifndef BOOST_NUMERIC_CONVERSION_CONVERTER_FLC_12NOV2002_HPP
+#define BOOST_NUMERIC_CONVERSION_CONVERTER_FLC_12NOV2002_HPP
+
+#include "boost/numeric/conversion/conversion_traits.hpp"
+#include "boost/numeric/conversion/converter_policies.hpp"
+
+#include "boost/numeric/conversion/detail/converter.hpp"
+
+namespace boost { namespace numeric 
+{
+
+template<class T,
+         class S,
+         class Traits           = conversion_traits<T,S>,
+         class OverflowHandler  = def_overflow_handler,
+         class Float2IntRounder = Trunc< BOOST_DEDUCED_TYPENAME Traits::source_type>  ,
+         class RawConverter     = raw_converter<Traits>,
+         class UserRangeChecker = UseInternalRangeChecker
+        >
+struct converter : convdetail::get_converter_impl<Traits,
+                                                  OverflowHandler,
+                                                  Float2IntRounder,
+                                                  RawConverter,
+                                                  UserRangeChecker
+                                                 >::type
+{
+  typedef Traits traits ;
+
+  typedef typename Traits::argument_type argument_type ;
+  typedef typename Traits::result_type   result_type   ;
+
+  result_type operator() ( argument_type s ) const { return this->convert(s) ; }
+} ;
+
+
+
+template<class S,
+         class OverflowHandler  = def_overflow_handler,
+         class Float2IntRounder = Trunc<S>  ,
+         class UserRangeChecker = UseInternalRangeChecker
+        >
+struct make_converter_from
+{
+  template<class T,
+           class Traits       = conversion_traits<T,S>,
+           class RawConverter = raw_converter<Traits>
+          > 
+  struct to
+  {
+    typedef converter<T,S,Traits,OverflowHandler,Float2IntRounder,RawConverter,UserRangeChecker> type ;
+  } ;
+
+} ;
+
+} } // namespace boost::numeric
+
+#endif
+
+

data/ext/boost/numeric/conversion/converter_policies.hpp

@@ -0,0 +1,186 @@
+//  (c) Copyright Fernando Luis Cacciola Carballal 2000-2004
+//  Use, modification, and distribution is subject to 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)
+
+//  See library home page at http://www.boost.org/libs/numeric/conversion
+//
+// Contact the author at: fernando_cacciola@hotmail.com
+//
+#ifndef BOOST_NUMERIC_CONVERSION_CONVERTER_POLICIES_FLC_12NOV2002_HPP
+#define BOOST_NUMERIC_CONVERSION_CONVERTER_POLICIES_FLC_12NOV2002_HPP
+
+#include <typeinfo> // for std::bad_cast
+
+#include <boost/config/no_tr1/cmath.hpp> // for std::floor and std::ceil
+
+#include <functional>
+
+#include "boost/type_traits/is_arithmetic.hpp"
+
+#include "boost/mpl/if.hpp"
+#include "boost/mpl/integral_c.hpp"
+
+namespace boost { namespace numeric
+{
+
+template<class S>
+struct Trunc
+{
+  typedef S source_type ;
+
+  typedef typename mpl::if_< is_arithmetic<S>,S,S const&>::type argument_type ;
+
+  static source_type nearbyint ( argument_type s )
+  {
+#if !defined(BOOST_NO_STDC_NAMESPACE)
+    using std::floor ;
+    using std::ceil  ;
+#endif
+
+    return s < static_cast<S>(0) ? ceil(s) : floor(s) ;
+  }
+
+  typedef mpl::integral_c< std::float_round_style, std::round_toward_zero> round_style ;
+} ;
+
+
+
+template<class S>
+struct Floor
+{
+  typedef S source_type ;
+
+  typedef typename mpl::if_< is_arithmetic<S>,S,S const&>::type argument_type ;
+
+  static source_type nearbyint ( argument_type s )
+  {
+#if !defined(BOOST_NO_STDC_NAMESPACE)
+    using std::floor ;
+#endif
+
+    return floor(s) ;
+  }
+
+  typedef mpl::integral_c< std::float_round_style, std::round_toward_neg_infinity> round_style ;
+} ;
+
+template<class S>
+struct Ceil
+{
+  typedef S source_type ;
+
+  typedef typename mpl::if_< is_arithmetic<S>,S,S const&>::type argument_type ;
+
+  static source_type nearbyint ( argument_type s )
+  {
+#if !defined(BOOST_NO_STDC_NAMESPACE)
+    using std::ceil ;
+#endif
+
+    return ceil(s) ;
+  }
+
+  typedef mpl::integral_c< std::float_round_style, std::round_toward_infinity> round_style ;
+} ;
+
+template<class S>
+struct RoundEven
+{
+  typedef S source_type ;
+
+  typedef typename mpl::if_< is_arithmetic<S>,S,S const&>::type argument_type ;
+
+  static source_type nearbyint ( argument_type s )
+  {
+    // Algorithm contributed by Guillaume Melquiond
+
+#if !defined(BOOST_NO_STDC_NAMESPACE)
+    using std::floor ;
+    using std::ceil  ;
+#endif
+
+    // only works inside the range not at the boundaries
+    S prev = floor(s);
+    S next = ceil(s);
+
+    S rt = (s - prev) - (next - s); // remainder type
+
+    S const zero(0.0);
+    S const two(2.0);
+
+    if ( rt < zero )
+      return prev;
+    else if ( rt > zero )
+      return next;
+    else
+    {
+      bool is_prev_even = two * floor(prev / two) == prev ;
+      return ( is_prev_even ? prev : next ) ;
+    }
+  }
+
+  typedef mpl::integral_c< std::float_round_style, std::round_to_nearest> round_style ;
+} ;
+
+
+enum range_check_result
+{
+  cInRange     = 0 ,
+  cNegOverflow = 1 ,
+  cPosOverflow = 2
+} ;
+
+class bad_numeric_cast : public std::bad_cast
+{
+  public:
+
+    virtual const char * what() const throw()
+      {  return "bad numeric conversion: overflow"; }
+};
+
+class negative_overflow : public bad_numeric_cast
+{
+  public:
+
+    virtual const char * what() const throw()
+      {  return "bad numeric conversion: negative overflow"; }
+};
+class positive_overflow : public bad_numeric_cast
+{
+  public:
+
+    virtual const char * what() const throw()
+      { return "bad numeric conversion: positive overflow"; }
+};
+
+struct def_overflow_handler
+{
+  void operator() ( range_check_result r ) // throw(negative_overflow,positive_overflow)
+  {
+    if ( r == cNegOverflow )
+      throw negative_overflow() ;
+    else if ( r == cPosOverflow )
+           throw positive_overflow() ;
+  }
+} ;
+
+struct silent_overflow_handler
+{
+  void operator() ( range_check_result ) {} // throw()
+} ;
+
+template<class Traits>
+struct raw_converter
+{
+  typedef typename Traits::result_type   result_type   ;
+  typedef typename Traits::argument_type argument_type ;
+
+  static result_type low_level_convert ( argument_type s ) { return static_cast<result_type>(s) ; }
+} ;
+
+struct UseInternalRangeChecker {} ;
+
+} } // namespace boost::numeric
+
+#endif