[boost] Updated to 1.52

3party/boost/boost/accumulators/framework/depends_on.hpp

@@ -11,6 +11,8 @@
 #include <boost/version.hpp>
 #include <boost/mpl/end.hpp>
 #include <boost/mpl/map.hpp>
+#include <boost/mpl/set.hpp>
+#include <boost/mpl/copy.hpp>
 #include <boost/mpl/fold.hpp>
 #include <boost/mpl/size.hpp>
 #include <boost/mpl/sort.hpp>
@@ -26,6 +28,7 @@
 #include <boost/mpl/is_sequence.hpp>
 #include <boost/mpl/placeholders.hpp>
 #include <boost/mpl/insert_range.hpp>
+#include <boost/mpl/back_inserter.hpp>
 #include <boost/mpl/transform_view.hpp>
 #include <boost/mpl/inherit_linearly.hpp>
 #include <boost/type_traits/is_base_and_derived.hpp>
@@ -94,15 +97,49 @@ namespace boost { namespace accumulators
         template<typename A, typename B>
         struct is_dependent_on
           : is_base_and_derived<
-                typename undroppable<B>::type
+                typename feature_of<typename undroppable<B>::type>::type
               , typename undroppable<A>::type
             >
         {};
 
+        template<typename Feature>
+        struct dependencies_of
+        {
+            typedef typename Feature::dependencies type;
+        };
+
+        // Should use mpl::insert_range, but doesn't seem to work with mpl sets
+        template<typename Set, typename Range>
+        struct set_insert_range
+          : mpl::fold<
+                Range
+              , Set
+              , mpl::insert<mpl::_1, mpl::_2>
+            >
+        {};
+
+        template<typename Features>
+        struct collect_abstract_features
+          : mpl::fold<
+                Features
+              , mpl::set0<>
+              , set_insert_range<
+                    mpl::insert<mpl::_1, feature_of<mpl::_2> >
+                  , collect_abstract_features<dependencies_of<mpl::_2> >
+                >
+            >
+        {};
+
         template<typename Features>
         struct depends_on_base
           : mpl::inherit_linearly<
-                typename mpl::sort<Features, is_dependent_on<mpl::_1, mpl::_2> >::type
+                typename mpl::sort<
+                    typename mpl::copy<
+                        typename collect_abstract_features<Features>::type
+                      , mpl::back_inserter<mpl::vector0<> >
+                    >::type
+                  , is_dependent_on<mpl::_1, mpl::_2>
+                >::type
                 // Don't inherit multiply from a feature
               , mpl::if_<
                     is_dependent_on<mpl::_1, mpl::_2>

3party/boost/boost/accumulators/statistics/density.hpp

@@ -95,7 +95,7 @@ namespace impl
             }
 
             // Once cache_size samples have been accumulated, create num_bins bins of same size between
-            // the minimum and maximum of the cached samples as well as an under- and and an overflow bin.
+            // the minimum and maximum of the cached samples as well as under and overflow bins.
             // Store their lower bounds (bin_positions) and fill the bins with the cached samples (samples_in_bin).
             if (cnt == this->cache_size)
             {

3party/boost/boost/algorithm/cxx11/copy_if.hpp

@@ -39,7 +39,7 @@ OutputIterator copy_if ( InputIterator first, InputIterator last, OutputIterator
 {
     for ( ; first != last; ++first )
         if (p(*first))
-            *result++ = first;
+            *result++ = *first;
     return result;
 }
 #endif
@@ -75,7 +75,7 @@ OutputIterator copy_while ( InputIterator first, InputIterator last,
                                 OutputIterator result, Predicate p )
 {
     for ( ; first != last && p(*first); ++first )
-        *result++ = first;
+        *result++ = *first;
     return result;
 }
 
@@ -109,7 +109,7 @@ template<typename InputIterator, typename OutputIterator, typename Predicate>
 OutputIterator copy_until ( InputIterator first, InputIterator last, OutputIterator result, Predicate p )
 {
     for ( ; first != last && !p(*first); ++first )
-        *result++ = first;
+        *result++ = *first;
     return result;
 }
 

3party/boost/boost/algorithm/cxx11/is_permutation.hpp

@@ -46,7 +46,7 @@ namespace detail {
 
 
 /// \fn is_permutation ( ForwardIterator1 first, ForwardIterator1 last, ForwardIterator2 first2, BinaryPredicate p )
-/// \brief Tests to see if a the sequence [first,last) is a permutation of the sequence starting at first2
+/// \brief Tests to see if the sequence [first,last) is a permutation of the sequence starting at first2
 ///
 /// \param first    The start of the input sequence
 /// \param last     One past the end of the input sequence
@@ -88,7 +88,7 @@ bool is_permutation ( ForwardIterator1 first1, ForwardIterator1 last1,
 }
 
 /// \fn is_permutation ( ForwardIterator1 first, ForwardIterator1 last, ForwardIterator2 first2 )
-/// \brief Tests to see if a the sequence [first,last) is a permutation of the sequence starting at first2
+/// \brief Tests to see if the sequence [first,last) is a permutation of the sequence starting at first2
 ///
 /// \param first    The start of the input sequence
 /// \param last     One past the end of the input sequence
@@ -108,7 +108,7 @@ bool is_permutation ( ForwardIterator1 first, ForwardIterator1 last, ForwardIter
 #endif
 
 /// \fn is_permutation ( const Range &r, ForwardIterator first2 )
-/// \brief Tests to see if a the sequence [first,last) is a permutation of the sequence starting at first2
+/// \brief Tests to see if the sequence [first,last) is a permutation of the sequence starting at first2
 ///
 /// \param r        The input range
 /// \param first2   The start of the second sequence
@@ -119,7 +119,7 @@ bool is_permutation ( const Range &r, ForwardIterator first2 )
 }
 
 /// \fn is_permutation ( const Range &r, ForwardIterator first2, BinaryPredicate pred )
-/// \brief Tests to see if a the sequence [first,last) is a permutation of the sequence starting at first2
+/// \brief Tests to see if the sequence [first,last) is a permutation of the sequence starting at first2
 ///
 /// \param r        The input range
 /// \param first2   The start of the second sequence

3party/boost/boost/algorithm/hex.hpp

@@ -69,14 +69,18 @@ namespace detail {
         return std::copy ( res, res + num_hex_digits, out );
         }
 
+// this needs to be in an un-named namespace because it is not a template
+// and might get included in several compilation units. This could cause
+// multiple definition errors at link time.
+    namespace {
     unsigned hex_char_to_int ( char c ) {
         if ( c >= '0' && c <= '9' ) return c - '0';
         if ( c >= 'A' && c <= 'F' ) return c - 'A' + 10;
         if ( c >= 'a' && c <= 'f' ) return c - 'a' + 10;
         BOOST_THROW_EXCEPTION (non_hex_input() << bad_char (c));
-        return 0;   // keep dumb compilers happy
+        return 0;     // keep dumb compilers happy
         }
-    
+    }    
 
 //  My own iterator_traits class.
 //  It is here so that I can "reach inside" some kinds of output iterators
@@ -105,17 +109,17 @@ namespace detail {
 //  The first one is the output type, the second one is the character type of
 //  the underlying stream, the third is the character traits.
 //      We only care about the first one.
-  template<typename T, typename charType, typename traits>
-  struct hex_iterator_traits< std::ostream_iterator<T, charType, traits> > {
-      typedef T value_type;
-  };
+    template<typename T, typename charType, typename traits>
+    struct hex_iterator_traits< std::ostream_iterator<T, charType, traits> > {
+        typedef T value_type;
+    };
 
-	template <typename Iterator> 
-	bool iter_end ( Iterator current, Iterator last ) { return current == last; }
-	
-	template <typename T>
-	bool ptr_end ( const T* ptr, const T* /*end*/ ) { return *ptr == '\0'; }
-	
+    template <typename Iterator> 
+    bool iter_end ( Iterator current, Iterator last ) { return current == last; }
+  
+    template <typename T>
+    bool ptr_end ( const T* ptr, const T* /*end*/ ) { return *ptr == '\0'; }
+  
 //  What can we assume here about the inputs?
 //      is std::iterator_traits<InputIterator>::value_type always 'char' ?
 //  Could it be wchar_t, say? Does it matter?

3party/boost/boost/algorithm/searching/boyer_moore_horspool.hpp

@@ -14,6 +14,11 @@
 
 #include <boost/assert.hpp>
 #include <boost/static_assert.hpp>
+
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+
+#include <boost/utility/enable_if.hpp>
 #include <boost/type_traits/is_same.hpp>
 
 #include <boost/algorithm/searching/detail/bm_traits.hpp>

3party/boost/boost/algorithm/searching/knuth_morris_pratt.hpp

@@ -15,6 +15,11 @@
 
 #include <boost/assert.hpp>
 #include <boost/static_assert.hpp>
+
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+
+#include <boost/utility/enable_if.hpp>
 #include <boost/type_traits/is_same.hpp>
 
 #include <boost/algorithm/searching/detail/debugging.hpp>

3party/boost/boost/bimap/bimap.hpp

@@ -382,7 +382,7 @@ class bimap
     friend class boost::serialization::access;
 
     template<class Archive>
-    void serialize(Archive & ar, const unsigned int version)
+    void serialize(Archive & ar, const unsigned int)
     {
         ar & serialization::make_nvp("mi_core",core);
     }

3party/boost/boost/bimap/detail/map_view_base.hpp

@@ -355,7 +355,7 @@ class non_mutable_data_unique_map_view_access
     }
 
     template< class CompatibleKey >
-    data_type_ & operator[](const CompatibleKey& k)
+    data_type_ & operator[](const CompatibleKey&)
     {
         BOOST_BIMAP_STATIC_ERROR( OPERATOR_BRACKET_IS_NOT_SUPPORTED, (Derived));
     }

3party/boost/boost/bimap/detail/map_view_iterator.hpp

@@ -97,13 +97,13 @@ struct map_view_iterator : public map_view_iterator_base<Tag,Relation,CoreIterat
     friend class ::boost::serialization::access;
 
     template< class Archive >
-    void save(Archive & ar, const unsigned int version) const
+    void save(Archive & ar, const unsigned int) const
     {
         ar << ::boost::serialization::make_nvp("mi_iterator",this->base());
     }
 
     template< class Archive >
-    void load(Archive & ar, const unsigned int version)
+    void load(Archive & ar, const unsigned int)
     {
         CoreIterator iter;
         ar >> ::boost::serialization::make_nvp("mi_iterator",iter);
@@ -178,13 +178,13 @@ struct const_map_view_iterator :
     friend class ::boost::serialization::access;
 
     template< class Archive >
-    void save(Archive & ar, const unsigned int version) const
+    void save(Archive & ar, const unsigned int) const
     {
         ar << ::boost::serialization::make_nvp("mi_iterator",this->base());
     }
 
     template< class Archive >
-    void load(Archive & ar, const unsigned int version)
+    void load(Archive & ar, const unsigned int)
     {
         CoreIterator iter;
         ar >> ::boost::serialization::make_nvp("mi_iterator",iter);

3party/boost/boost/bimap/detail/set_view_iterator.hpp

@@ -95,13 +95,13 @@ struct set_view_iterator : public set_view_iterator_base<CoreIterator>::type
     friend class ::boost::serialization::access;
 
     template< class Archive >
-    void save(Archive & ar, const unsigned int version) const
+    void save(Archive & ar, const unsigned int) const
     {
         ar << ::boost::serialization::make_nvp("mi_iterator",this->base());
     }
 
     template< class Archive >
-    void load(Archive & ar, const unsigned int version)
+    void load(Archive & ar, const unsigned int)
     {
         CoreIterator iter;
         ar >> ::boost::serialization::make_nvp("mi_iterator",iter);
@@ -171,13 +171,13 @@ struct const_set_view_iterator : public const_set_view_iterator_base<CoreIterato
     friend class ::boost::serialization::access;
 
     template< class Archive >
-    void save(Archive & ar, const unsigned int version) const
+    void save(Archive & ar, const unsigned int) const
     {
         ar << ::boost::serialization::make_nvp("mi_iterator",this->base());
     }
 
     template< class Archive >
-    void load(Archive & ar, const unsigned int version)
+    void load(Archive & ar, const unsigned int)
     {
         CoreIterator iter;
         ar >> ::boost::serialization::make_nvp("mi_iterator",iter);

3party/boost/boost/bimap/relation/mutant_relation.hpp

@@ -142,7 +142,7 @@ class relation_info_hook : public
 
     #ifndef BOOST_BIMAP_DISABLE_SERIALIZATION
     template< class Archive >
-    void serialize(Archive & ar, const unsigned int version)
+    void serialize(Archive & ar, const unsigned int)
     {
         ar & ::boost::serialization::make_nvp("left" , base_::left );
         ar & ::boost::serialization::make_nvp("right", base_::right);
@@ -188,7 +188,7 @@ class relation_info_hook<TA,TB,::boost::mpl::na,force_mutable> :
 
     #ifndef BOOST_BIMAP_DISABLE_SERIALIZATION
     template< class Archive >
-    void serialize(Archive & ar, const unsigned int version)
+    void serialize(Archive & ar, const unsigned int)
     {
         ar & ::boost::serialization::make_nvp("left" , base_::left );
         ar & ::boost::serialization::make_nvp("right", base_::right);

3party/boost/boost/chrono/chrono_io.hpp

@@ -14,6 +14,21 @@
 #define BOOST_CHRONO_CHRONO_IO_HPP
 
 #include <boost/chrono/config.hpp>
+
+//#if BOOST_CHRONO_VERSION == 2
+//#include <boost/chrono/io/time_point_io.hpp>
+//#include <boost/chrono/io/duration_io.hpp>
+//#elif BOOST_CHRONO_VERSION == 1
+//#include <boost/chrono/io_v1/chrono_io.hpp>
+//#endif
+
+#if defined BOOST_CHRONO_DONT_PROVIDES_DEPRECATED_IO_SINCE_V2_0_0
+#include <boost/chrono/io/time_point_io.hpp>
+#include <boost/chrono/io/duration_io.hpp>
+#else
 #include <boost/chrono/io_v1/chrono_io.hpp>
+#endif
+
+#include <boost/chrono/io/utility/to_string.hpp>
 
 #endif  // BOOST_CHRONO_CHRONO_IO_HPP

3party/boost/boost/chrono/config.hpp

@@ -25,6 +25,13 @@
 #define BOOST_USE_WINDOWS_H
 #endif
 
+#if ! defined BOOST_CHRONO_PROVIDES_DATE_IO_FOR_SYSTEM_CLOCK_TIME_POINT \
+    && ! defined BOOST_CHRONO_DONT_PROVIDE_DATE_IO_FOR_SYSTEM_CLOCK_TIME_POINT
+
+# define BOOST_CHRONO_DONT_PROVIDE_DATE_IO_FOR_SYSTEM_CLOCK_TIME_POINT
+
+#endif
+
 //  BOOST_CHRONO_POSIX_API, BOOST_CHRONO_MAC_API, or BOOST_CHRONO_WINDOWS_API
 //  can be defined by the user to specify which API should be used
 
@@ -100,20 +107,59 @@
 
 // unicode support  ------------------------------//
 
-#if defined(BOOST_NO_UNICODE_LITERALS) || defined(BOOST_NO_CHAR16_T) || defined(BOOST_NO_CHAR32_T)
+#if defined(BOOST_NO_CXX11_UNICODE_LITERALS) || defined(BOOST_NO_CXX11_CHAR16_T) || defined(BOOST_NO_CXX11_CHAR32_T)
 //~ #define BOOST_CHRONO_HAS_UNICODE_SUPPORT
 #else
 #define BOOST_CHRONO_HAS_UNICODE_SUPPORT 1
 #endif
 
 #if ! defined BOOST_NOEXCEPT
-#if defined(BOOST_NO_NOEXCEPT)
+#if defined(BOOST_NO_CXX11_NOEXCEPT)
 #define BOOST_NOEXCEPT
 #else
 #define BOOST_NOEXCEPT noexcept
 #endif
 #endif
 
+#if defined( BOOST_NO_CXX11_NUMERIC_LIMITS )
+#define BOOST_CHRONO_LIB_CONSTEXPR
+#else
+#define BOOST_CHRONO_LIB_CONSTEXPR BOOST_CONSTEXPR
+#endif
+
+#if defined( BOOST_NO_CXX11_NUMERIC_LIMITS )
+#  define BOOST_CHRONO_LIB_NOEXCEPT_OR_THROW throw()
+#else
+#ifdef BOOST_NO_NOEXCEPT
+#  define BOOST_CHRONO_LIB_NOEXCEPT_OR_THROW throw()
+#else
+#  define BOOST_CHRONO_LIB_NOEXCEPT_OR_THROW noexcept
+#endif
+#endif
+
+
+#if defined BOOST_CHRONO_PROVIDE_HYBRID_ERROR_HANDLING \
+ && defined BOOST_CHRONO_DONT_PROVIDE_HYBRID_ERROR_HANDLING
+#error "BOOST_CHRONO_PROVIDE_HYBRID_ERROR_HANDLING && BOOST_CHRONO_PROVIDE_HYBRID_ERROR_HANDLING defined"
+#endif
+
+#if defined BOOST_CHRONO_PROVIDES_DEPRECATED_IO_SINCE_V2_0_0 \
+ && defined BOOST_CHRONO_DONT_PROVIDES_DEPRECATED_IO_SINCE_V2_0_0
+#error "BOOST_CHRONO_PROVIDES_DEPRECATED_IO_SINCE_V2_0_0 && BOOST_CHRONO_DONT_PROVIDES_DEPRECATED_IO_SINCE_V2_0_0 defined"
+#endif
+
+#if ! defined BOOST_CHRONO_PROVIDE_HYBRID_ERROR_HANDLING \
+ && ! defined BOOST_CHRONO_DONT_PROVIDE_HYBRID_ERROR_HANDLING
+#define BOOST_CHRONO_PROVIDE_HYBRID_ERROR_HANDLING
+#endif
+
+#if (BOOST_CHRONO_VERSION == 2)
+#if ! defined BOOST_CHRONO_PROVIDES_DEPRECATED_IO_SINCE_V2_0_0 \
+ && ! defined BOOST_CHRONO_DONT_PROVIDES_DEPRECATED_IO_SINCE_V2_0_0
+#define BOOST_CHRONO_DONT_PROVIDES_DEPRECATED_IO_SINCE_V2_0_0
+#endif
+#endif
+
 #ifdef BOOST_CHRONO_HEADER_ONLY
 #define BOOST_CHRONO_INLINE inline
 #define BOOST_CHRONO_STATIC inline
@@ -143,7 +189,7 @@
 #define BOOST_CHRONO_DECL
 #endif
 
-//#define  BOOST_CHRONO_DONT_PROVIDE_HYBRID_ERROR_HANDLING
+
 
 //  enable automatic library variant selection  ------------------------------//
 
@@ -166,3 +212,4 @@
 #endif  // auto-linking disabled
 #endif // BOOST_CHRONO_HEADER_ONLY
 #endif // BOOST_CHRONO_CONFIG_HPP
+

3party/boost/boost/chrono/detail/static_assert.hpp

@@ -11,7 +11,7 @@
 
 #include <boost/chrono/config.hpp>
 
-#ifndef BOOST_NO_STATIC_ASSERT
+#ifndef BOOST_NO_CXX11_STATIC_ASSERT
 #define BOOST_CHRONO_STATIC_ASSERT(CND, MSG, TYPES) static_assert(CND,MSG)
 #elif defined(BOOST_CHRONO_USES_STATIC_ASSERT)
 #include <boost/static_assert.hpp>

3party/boost/boost/chrono/duration.hpp

@@ -51,7 +51,7 @@ time2_demo contained this comment:
 #include <boost/detail/workaround.hpp>
 #include <boost/integer_traits.hpp>
 
-#if !defined(BOOST_NO_STATIC_ASSERT) || !defined(BOOST_CHRONO_USES_MPL_ASSERT)
+#if !defined(BOOST_NO_CXX11_STATIC_ASSERT) || !defined(BOOST_CHRONO_USES_MPL_ASSERT)
 #define BOOST_CHRONO_A_DURATION_REPRESENTATION_CAN_NOT_BE_A_DURATION        "A duration representation can not be a duration"
 #define BOOST_CHRONO_SECOND_TEMPLATE_PARAMETER_OF_DURATION_MUST_BE_A_STD_RATIO "Second template parameter of duration must be a boost::ratio"
 #define BOOST_CHRONO_DURATION_PERIOD_MUST_BE_POSITIVE "duration period must be positive"
@@ -340,17 +340,17 @@ namespace detail
 namespace detail {
     template <class T, bool = is_arithmetic<T>::value>
     struct chrono_numeric_limits {
-        static T lowest() throw() {return (std::numeric_limits<T>::min)  ();}
+        static BOOST_CHRONO_LIB_CONSTEXPR T lowest() BOOST_CHRONO_LIB_NOEXCEPT_OR_THROW {return (std::numeric_limits<T>::min)  ();}
     };
 
     template <class T>
     struct chrono_numeric_limits<T,true> {
-        static T lowest() throw() {return (std::numeric_limits<T>::min)  ();}
+        static BOOST_CHRONO_LIB_CONSTEXPR T lowest() BOOST_CHRONO_LIB_NOEXCEPT_OR_THROW {return (std::numeric_limits<T>::min)  ();}
     };
 
     template <>
     struct chrono_numeric_limits<float,true> {
-        static float lowest() throw()
+        static BOOST_CHRONO_LIB_CONSTEXPR float lowest() BOOST_CHRONO_LIB_NOEXCEPT_OR_THROW
         {
             return -(std::numeric_limits<float>::max) ();
         }
@@ -358,7 +358,7 @@ namespace detail {
 
     template <>
     struct chrono_numeric_limits<double,true> {
-        static double lowest() throw()
+        static BOOST_CHRONO_LIB_CONSTEXPR double lowest() BOOST_CHRONO_LIB_NOEXCEPT_OR_THROW
         {
             return -(std::numeric_limits<double>::max) ();
         }
@@ -366,7 +366,7 @@ namespace detail {
 
     template <>
     struct chrono_numeric_limits<long double,true> {
-        static long double lowest() throw()
+        static BOOST_CHRONO_LIB_CONSTEXPR long double lowest() BOOST_CHRONO_LIB_NOEXCEPT_OR_THROW
         {
             return -(std::numeric_limits<long double>::max)();
         }
@@ -381,12 +381,12 @@ template <class Rep>
 struct duration_values
 {
     static BOOST_CONSTEXPR Rep zero() {return Rep(0);}
-    static BOOST_CONSTEXPR Rep max BOOST_PREVENT_MACRO_SUBSTITUTION ()
+    static BOOST_CHRONO_LIB_CONSTEXPR Rep max BOOST_PREVENT_MACRO_SUBSTITUTION ()
     {
         return (std::numeric_limits<Rep>::max)();
     }
 
-    static BOOST_CONSTEXPR Rep min BOOST_PREVENT_MACRO_SUBSTITUTION ()
+    static BOOST_CHRONO_LIB_CONSTEXPR Rep min BOOST_PREVENT_MACRO_SUBSTITUTION ()
     {
         return detail::numeric_limits<Rep>::lowest();
     }
@@ -452,8 +452,8 @@ namespace chrono {
                 >::type* = 0
             ) : rep_(r) { }
         //~duration() {} //= default;
-        BOOST_CONSTEXPR
-        duration(const duration& rhs) : rep_(rhs.rep_) {} // = default;
+        //BOOST_CONSTEXPR
+        //duration(const duration& rhs) : rep_(rhs.rep_) {} // = default;
         duration& operator=(const duration& rhs) // = default;
         {
             if (&rhs != this) rep_= rhs.rep_;
@@ -484,7 +484,7 @@ namespace chrono {
         // arithmetic
 
         BOOST_CONSTEXPR
-        duration  operator+() const {return *this;}
+        duration  operator+() const {return duration(rep_);;}
         BOOST_CONSTEXPR
         duration  operator-() const {return duration(-rep_);}
         duration& operator++()      {++rep_; return *this;}
@@ -514,11 +514,11 @@ namespace chrono {
         {
             return duration(duration_values<rep>::zero());
         }
-        static BOOST_CONSTEXPR duration min BOOST_PREVENT_MACRO_SUBSTITUTION ()
+        static BOOST_CHRONO_LIB_CONSTEXPR duration min BOOST_PREVENT_MACRO_SUBSTITUTION ()
         {
             return duration((duration_values<rep>::min)());
         }
-        static BOOST_CONSTEXPR duration max BOOST_PREVENT_MACRO_SUBSTITUTION ()
+        static BOOST_CHRONO_LIB_CONSTEXPR duration max BOOST_PREVENT_MACRO_SUBSTITUTION ()
         {
             return duration((duration_values<rep>::max)());
         }
@@ -761,7 +761,7 @@ namespace detail
     // Duration >=
 
     template <class Rep1, class Period1, class Rep2, class Period2>
-    inline
+    inline BOOST_CONSTEXPR
     bool
     operator>=(const duration<Rep1, Period1>& lhs,
           const duration<Rep2, Period2>& rhs)

3party/boost/boost/chrono/io/duration_get.hpp

@@ -0,0 +1,542 @@
+//  (C) Copyright Howard Hinnant
+//  (C) Copyright 2011 Vicente J. Botet Escriba
+//  Use, modification and distribution are 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).
+//
+
+#ifndef BOOST_CHRONO_IO_DURATION_GET_HPP
+#define BOOST_CHRONO_IO_DURATION_GET_HPP
+
+#include <boost/chrono/config.hpp>
+#include <string>
+#include <boost/type_traits/is_scalar.hpp>
+#include <boost/utility/enable_if.hpp>
+#include <boost/type_traits/is_signed.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/math/common_factor_rt.hpp>
+#include <boost/chrono/detail/scan_keyword.hpp>
+#include <boost/chrono/detail/no_warning/signed_unsigned_cmp.hpp>
+
+#include <boost/assert.hpp>
+#include <locale>
+
+/**
+ * Duration formatting facet for input.
+ */
+namespace boost
+{
+  namespace chrono
+  {
+
+    namespace detail
+    {
+      template <class Rep, bool = is_scalar<Rep>::value>
+      struct duration_io_intermediate
+      {
+        typedef Rep type;
+      };
+
+      template <class Rep>
+      struct duration_io_intermediate<Rep, true>
+      {
+        typedef typename mpl::if_c<is_floating_point<Rep>::value, long double, typename mpl::if_c<
+            is_signed<Rep>::value, long long, unsigned long long>::type>::type type;
+      };
+
+      template <typename intermediate_type>
+      typename enable_if<is_integral<intermediate_type> , bool>::type reduce(intermediate_type& r,
+          unsigned long long& den, std::ios_base::iostate& err)
+      {
+        typedef typename common_type<intermediate_type, unsigned long long>::type common_type_t;
+
+        // Reduce r * num / den
+        common_type_t t = math::gcd<common_type_t>(common_type_t(r), common_type_t(den));
+        r /= t;
+        den /= t;
+        if (den != 1)
+        {
+          // Conversion to Period is integral and not exact
+          err |= std::ios_base::failbit;
+          return false;
+        }
+        return true;
+      }
+      template <typename intermediate_type>
+      typename disable_if<is_integral<intermediate_type> , bool>::type reduce(intermediate_type&, unsigned long long&,
+          std::ios_base::iostate&)
+      {
+        return true;
+      }
+
+    }
+
+    /**
+     * @c duration_get is used to parse a character sequence, extracting
+     * components of a duration into a class duration.
+     * Each get member parses a format as produced by a corresponding format specifier to time_put<>::put.
+     * If the sequence being parsed matches the correct format, the
+     * corresponding member of the class duration argument are set to the
+     * value used to produce the sequence;
+     * otherwise either an error is reported or unspecified values are assigned.
+     * In other words, user confirmation is required for reliable parsing of
+     * user-entered durations, but machine-generated formats can be parsed
+     * reliably. This allows parsers to be aggressive about interpreting user
+     * variations on standard formats.
+     *
+     * If the end iterator is reached during parsing of the get() member
+     * function, the member sets std::ios_base::eofbit in err.
+     */
+    template <class CharT, class InputIterator = std::istreambuf_iterator<CharT> >
+    class duration_get: public std::locale::facet
+    {
+    public:
+      /**
+       * Type of character the facet is instantiated on.
+       */
+      typedef CharT char_type;
+      /**
+       * Type of character string passed to member functions.
+       */
+      typedef std::basic_string<CharT> string_type;
+      /**
+       * Type of iterator used to scan the character buffer.
+       */
+      typedef InputIterator iter_type;
+
+      /**
+       * Construct a @c duration_get facet.
+       * @param refs
+       * @Effects Construct a @c duration_get facet.
+       * If the @c refs argument is @c 0 then destruction of the object is
+       * delegated to the @c locale, or locales, containing it. This allows
+       * the user to ignore lifetime management issues. On the other had,
+       * if @c refs is @c 1 then the object must be explicitly deleted;
+       * the @c locale will not do so. In this case, the object can be
+       * maintained across the lifetime of multiple locales.
+       */
+
+      explicit duration_get(size_t refs = 0) :
+        std::locale::facet(refs)
+      {
+      }
+
+      /**
+       * @param s start input stream iterator
+       * @param end end input stream iterator
+       * @param ios a reference to a ios_base
+       * @param err the ios_base state
+       * @param d the duration
+       * @param pattern begin of the formatting pattern
+       * @param pat_end end of the formatting pattern
+       *
+       * Requires: [pattern,pat_end) shall be a valid range.
+       *
+       * Effects: The function starts by evaluating err = std::ios_base::goodbit.
+       * It then enters a loop, reading zero or more characters from s at
+       * each iteration. Unless otherwise specified below, the loop
+       * terminates when the first of the following conditions holds:
+       * - The expression pattern == pat_end evaluates to true.
+       * - The expression err == std::ios_base::goodbit evaluates to false.
+       * - The expression s == end evaluates to true, in which case the
+       * function evaluates err = std::ios_base::eofbit | std::ios_base::failbit.
+       * - The next element of pattern is equal to '%', followed by a conversion
+       * specifier character, format.
+       * If the number of elements in the range [pattern,pat_end) is not
+       * sufficient to unambiguously determine whether the conversion
+       * specification is complete and valid, the function evaluates
+       * err = std::ios_base::failbit. Otherwise, the function evaluates
+       * s = get_value(s, end, ios, err, r) when the conversion specification is 'v' and
+       * s = get_value(s, end, ios, err, rt) when the conversion specification is 'u'.
+       * If err == std::ios_base::goodbit holds after
+       * the evaluation of the expression, the function increments pattern to
+       * point just past the end of the conversion specification and continues
+       * looping.
+       * - The expression isspace(*pattern, ios.getloc()) evaluates to true, in
+       * which case the function first increments pattern until
+       * pattern == pat_end || !isspace(*pattern, ios.getloc()) evaluates to true,
+       * then advances s until s == end || !isspace(*s, ios.getloc()) is true,
+       * and finally resumes looping.
+       * - The next character read from s matches the element pointed to by
+       * pattern in a case-insensitive comparison, in which case the function
+       * evaluates ++pattern, ++s and continues looping. Otherwise, the function
+       * evaluates err = std::ios_base::failbit.
+       *
+       * Once r and rt are retrieved,
+       * Returns: s
+       */
+      template <typename Rep, typename Period>
+      iter_type get(iter_type s, iter_type end, std::ios_base& ios, std::ios_base::iostate& err,
+          duration<Rep, Period> &d, const char_type *pattern, const char_type *pat_end) const
+      {
+        if (std::has_facet<duration_units<CharT> >(ios.getloc()))
+        {
+          duration_units<CharT> const&facet = std::use_facet<duration_units<CharT> >(ios.getloc());
+          return get(facet, s, end, ios, err, d, pattern, pat_end);
+        }
+        else
+        {
+          duration_units_default<CharT> facet;
+          return get(facet, s, end, ios, err, d, pattern, pat_end);
+        }
+      }
+
+      template <typename Rep, typename Period>
+      iter_type get(duration_units<CharT> const&facet, iter_type s, iter_type end, std::ios_base& ios,
+          std::ios_base::iostate& err, duration<Rep, Period> &d, const char_type *pattern, const char_type *pat_end) const
+      {
+
+        typedef typename detail::duration_io_intermediate<Rep>::type intermediate_type;
+        intermediate_type r;
+        rt_ratio rt;
+        bool value_found = false, unit_found = false;
+
+        const std::ctype<char_type>& ct = std::use_facet<std::ctype<char_type> >(ios.getloc());
+        while (pattern != pat_end && err == std::ios_base::goodbit)
+        {
+          if (s == end)
+          {
+            err |= std::ios_base::eofbit;
+            break;
+          }
+          if (ct.narrow(*pattern, 0) == '%')
+          {
+            if (++pattern == pat_end)
+            {
+              err |= std::ios_base::failbit;
+              return s;
+            }
+            char cmd = ct.narrow(*pattern, 0);
+            switch (cmd)
+            {
+            case 'v':
+            {
+              if (value_found)
+              {
+                err |= std::ios_base::failbit;
+                return s;
+              }
+              value_found = true;
+              s = get_value(s, end, ios, err, r);
+              if (err & (std::ios_base::badbit | std::ios_base::failbit))
+              {
+                return s;
+              }
+              break;
+            }
+            case 'u':
+            {
+              if (unit_found)
+              {
+                err |= std::ios_base::failbit;
+                return s;
+              }
+              unit_found = true;
+              s = get_unit(facet, s, end, ios, err, rt);
+              if (err & (std::ios_base::badbit | std::ios_base::failbit))
+              {
+                return s;
+              }
+              break;
+            }
+            default:
+              BOOST_ASSERT(false && "Boost::Chrono internal error.");
+              break;
+            }
+
+            ++pattern;
+          }
+          else if (ct.is(std::ctype_base::space, *pattern))
+          {
+            for (++pattern; pattern != pat_end && ct.is(std::ctype_base::space, *pattern); ++pattern)
+              ;
+            for (; s != end && ct.is(std::ctype_base::space, *s); ++s)
+              ;
+          }
+          else if (ct.toupper(*s) == ct.toupper(*pattern))
+          {
+            ++s;
+            ++pattern;
+          }
+          else
+          {
+            err |= std::ios_base::failbit;
+            return s;
+          }
+
+        }
+
+        unsigned long long num = rt.num;
+        unsigned long long den = rt.den;
+
+        // r should be multiplied by (num/den) / Period
+        // Reduce (num/den) / Period to lowest terms
+        unsigned long long gcd_n1_n2 = math::gcd<unsigned long long>(num, Period::num);
+        unsigned long long gcd_d1_d2 = math::gcd<unsigned long long>(den, Period::den);
+        num /= gcd_n1_n2;
+        den /= gcd_d1_d2;
+        unsigned long long n2 = Period::num / gcd_n1_n2;
+        unsigned long long d2 = Period::den / gcd_d1_d2;
+        if (num > (std::numeric_limits<unsigned long long>::max)() / d2 || den
+            > (std::numeric_limits<unsigned long long>::max)() / n2)
+        {
+          // (num/den) / Period overflows
+          err |= std::ios_base::failbit;
+          return s;
+        }
+        num *= d2;
+        den *= n2;
+
+        typedef typename common_type<intermediate_type, unsigned long long>::type common_type_t;
+
+        // num / den is now factor to multiply by r
+        if (!detail::reduce(r, den, err)) return s;
+
+        if (chrono::detail::gt(r, ( (duration_values<common_type_t>::max)() / num)))
+        {
+          // Conversion to Period overflowed
+          err |= std::ios_base::failbit;
+          return s;
+        }
+        common_type_t t = r * num;
+        t /= den;
+        if (t > 0)
+        {
+          Rep pt = t;
+          if ( (duration_values<Rep>::max)() < pt)
+          {
+            // Conversion to Period overflowed
+            err |= std::ios_base::failbit;
+            return s;
+          }
+        }
+        // Success!  Store it.
+        r = Rep(t);
+        d = duration<Rep, Period> (r);
+
+        return s;
+      }
+
+      /**
+       *
+       * @param s start input stream iterator
+       * @param end end input stream iterator
+       * @param ios a reference to a ios_base
+       * @param err the ios_base state
+       * @param d the duration
+       * Stores the duration pattern from the @c duration_unit facet in let say @c str. Last as if
+       * @code
+       *   return get(s, end, ios, err, ios, d, str.data(), str.data() + str.size());
+       * @codeend
+       * @Returns An iterator pointing just beyond the last character that can be determined to be part of a valid name
+       */
+      template <typename Rep, typename Period>
+      iter_type get(iter_type s, iter_type end, std::ios_base& ios, std::ios_base::iostate& err,
+          duration<Rep, Period> & d) const
+      {
+        if (std::has_facet<duration_units<CharT> >(ios.getloc()))
+        {
+          duration_units<CharT> const&facet = std::use_facet<duration_units<CharT> >(ios.getloc());
+          std::basic_string<CharT> str = facet.get_pattern();
+          return get(facet, s, end, ios, err, d, str.data(), str.data() + str.size());
+        }
+        else
+        {
+          duration_units_default<CharT> facet;
+          std::basic_string<CharT> str = facet.get_pattern();
+          return get(facet, s, end, ios, err, d, str.data(), str.data() + str.size());
+        }
+      }
+
+      /**
+       *
+       * @param s start input stream iterator
+       * @param end end input stream iterator
+       * @param ios a reference to a ios_base
+       * @param err the ios_base state
+       * @param r a reference to the duration representation.
+       * @Effects As if
+       * @code
+       * return std::use_facet<std::num_get<cahr_type, iter_type> >(ios.getloc()).get(s, end, ios, err, r);
+       * @endcode
+       *
+       * @Returns An iterator pointing just beyond the last character that can be determined to be part of a valid name
+       */
+      template <typename Rep>
+      iter_type get_value(iter_type s, iter_type end, std::ios_base& ios, std::ios_base::iostate& err, Rep& r) const
+      {
+        return std::use_facet<std::num_get<CharT, iter_type> >(ios.getloc()).get(s, end, ios, err, r);
+      }
+
+      /**
+       *
+       * @param s start input stream iterator
+       * @param e end input stream iterator
+       * @param ios a reference to a ios_base
+       * @param err the ios_base state
+       * @param rt a reference to the duration run-time ratio.
+       * @Returns An iterator pointing just beyond the last character that can be determined to be part of a valid name
+       */
+      iter_type get_unit(iter_type i, iter_type e, std::ios_base& is, std::ios_base::iostate& err, rt_ratio &rt) const
+      {
+        if (std::has_facet<duration_units<CharT> >(is.getloc()))
+        {
+          return get_unit(std::use_facet<duration_units<CharT> >(is.getloc()), i, e, is, err, rt);
+        }
+        else
+        {
+          duration_units_default<CharT> facet;
+          return get_unit(facet, i, e, is, err, rt);
+        }
+      }
+
+
+      iter_type get_unit(duration_units<CharT> const &facet, iter_type i, iter_type e, std::ios_base& is,
+          std::ios_base::iostate& err, rt_ratio &rt) const
+      {
+
+        if (*i == '[')
+        {
+          // parse [N/D]s or [N/D]second or [N/D]seconds format
+          ++i;
+          i = std::use_facet<std::num_get<CharT, iter_type> >(is.getloc()).get(i, e, is, err, rt.num);
+          if ( (err & std::ios_base::failbit) != 0)
+          {
+            return i;
+          }
+
+          if (i == e)
+          {
+            err |= std::ios_base::failbit;
+            return i;
+          }
+          CharT x = *i++;
+          if (x != '/')
+          {
+            err |= std::ios_base::failbit;
+            return i;
+          }
+          i = std::use_facet<std::num_get<CharT, iter_type> >(is.getloc()).get(i, e, is, err, rt.den);
+          if ( (err & std::ios_base::failbit) != 0)
+          {
+            return i;
+          }
+          if (i == e)
+          {
+            err |= std::ios_base::failbit;
+            return i;
+          }
+          if (*i != ']')
+          {
+            err |= std::ios_base::failbit;
+            return i;
+          }
+          ++i;
+          if (i == e)
+          {
+            err |= std::ios_base::failbit;
+            return i;
+          }
+          // parse s or second or seconds
+          return do_get_n_d_valid_unit(facet, i, e, is, err);
+        }
+        else
+        {
+          return do_get_valid_unit(facet, i, e, is, err, rt);
+        }
+      }
+
+      /**
+       * Unique identifier for this type of facet.
+       */
+      static std::locale::id id;
+
+      /**
+       * @Effects Destroy the facet
+       */
+      ~duration_get()
+      {
+      }
+
+    protected:
+
+      /**
+       * Extracts the run-time ratio associated to the duration when it is given in prefix form.
+       *
+       * This is an extension point of this facet so that we can take in account other periods that can have a useful
+       * translation in other contexts, as e.g. days and weeks.
+       *
+       * @param facet the duration_units facet
+       * @param s start input stream iterator.
+       * @param e end input stream iterator.
+       * @param ios a reference to a ios_base.
+       * @param err the ios_base state.
+       * @return @c s
+       */
+      iter_type do_get_n_d_valid_unit(duration_units<CharT> const &facet, iter_type i, iter_type e,
+          std::ios_base&, std::ios_base::iostate& err) const
+      {
+        // parse SI name, short or long
+
+        const string_type* units = facet.get_n_d_valid_units_start();
+        const string_type* units_end = facet.get_n_d_valid_units_end();
+
+        const string_type* k = chrono_detail::scan_keyword(i, e, units, units_end,
+        //~ std::use_facet<std::ctype<CharT> >(loc),
+            err);
+        if (!facet.match_n_d_valid_unit(k))
+        {
+          err |= std::ios_base::failbit;
+        }
+
+        return i;
+      }
+
+      /**
+       * Extracts the run-time ratio associated to the duration when it is given in prefix form.
+       *
+       * This is an extension point of this facet so that we can take in account other periods that can have a useful
+       * translation in other contexts, as e.g. days and weeks.
+       *
+       * @param facet the duration_units facet
+       * @param s start input stream iterator.
+       * @param e end input stream iterator.
+       * @param ios a reference to a ios_base.
+       * @param err the ios_base state.
+       * @param rt a reference to the duration run-time ratio.
+       * @Effects
+       * @Returns An iterator pointing just beyond the last character that can be determined to be part of a valid name.
+       */
+      iter_type do_get_valid_unit(duration_units<CharT> const &facet, iter_type i, iter_type e,
+          std::ios_base&, std::ios_base::iostate& err, rt_ratio &rt) const
+      {
+        // parse SI name, short or long
+
+        const string_type* units = facet.get_valid_units_start();
+        const string_type* units_end = facet.get_valid_units_end();
+
+        err = std::ios_base::goodbit;
+        const string_type* k = chrono_detail::scan_keyword(i, e, units, units_end,
+        //~ std::use_facet<std::ctype<CharT> >(loc),
+            err);
+
+        if (!facet.match_valid_unit(k, rt))
+        {
+          err |= std::ios_base::failbit;
+        }
+        return i;
+
+      }
+    };
+
+    /**
+     * Unique identifier for this type of facet.
+     */
+    template <class CharT, class InputIterator>
+    std::locale::id duration_get<CharT, InputIterator>::id;
+
+  } // chrono
+}
+// boost
+
+#endif  // header

3party/boost/boost/chrono/io/duration_io.hpp

@@ -0,0 +1,230 @@
+//  (C) Copyright Howard Hinnant
+//  (C) Copyright 2011 Vicente J. Botet Escriba
+//  Use, modification and distribution are 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).
+//
+// This code was adapted by Vicente from Howard Hinnant's experimental work
+// on chrono i/o to Boost
+
+#ifndef BOOST_CHRONO_IO_DURATION_IO_HPP
+#define BOOST_CHRONO_IO_DURATION_IO_HPP
+
+#include <boost/chrono/chrono.hpp>
+#include <boost/ratio/ratio_io.hpp>
+#include <boost/chrono/io/duration_style.hpp>
+#include <boost/chrono/io/ios_base_state.hpp>
+#include <boost/chrono/io/duration_put.hpp>
+#include <boost/chrono/io/duration_get.hpp>
+#include <boost/chrono/io/utility/manip_base.hpp>
+#include <locale>
+#include <iostream>
+
+namespace boost
+{
+  namespace chrono
+  {
+
+    /**
+     * duration parameterized manipulator.
+     */
+
+    class duration_fmt: public manip<duration_fmt>
+    {
+      duration_style style_;
+    public:
+
+      /**
+       * explicit manipulator constructor from a @c duration_style
+       */
+      explicit duration_fmt(duration_style style)BOOST_NOEXCEPT
+      : style_(style)
+      {}
+
+      /**
+       * Change the duration_style ios state;
+       */
+      void operator()(std::ios_base &ios) const
+
+      {
+        set_duration_style(ios, style_);
+      }
+    };
+
+    /**
+     * duration_style i/o saver.
+     *
+     * See Boost.IO i/o state savers for a motivating compression.
+     */
+    struct duration_style_io_saver
+    {
+
+      //! the type of the state to restore
+      typedef std::ios_base state_type;
+      //! the type of aspect to save
+      typedef duration_style aspect_type;
+
+      /**
+       * Explicit construction from an i/o stream.
+       *
+       * Store a reference to the i/o stream and the value of the associated @c duration_style.
+       */
+      explicit duration_style_io_saver(state_type &s) :
+        s_save_(s)
+      {
+        a_save_ = get_duration_style(s_save_);
+      }
+
+      /**
+       * Construction from an i/o stream and a @c duration_style to restore.
+       *
+       * Stores a reference to the i/o stream and the value @c duration_style to restore given as parameter.
+       */
+      duration_style_io_saver(state_type &s, aspect_type new_value) :
+        s_save_(s), a_save_(new_value)
+      {
+      }
+
+      /**
+       * Destructor.
+       *
+       * Restores the i/o stream with the duration_style to be restored.
+       */
+      ~duration_style_io_saver()
+      {
+        this->restore();
+      }
+
+      /**
+       * Restores the i/o stream with the duration_style to be restored.
+       */
+      void restore()
+      {
+        set_duration_style(s_save_, a_save_);
+      }
+
+    private:
+      state_type& s_save_;
+      aspect_type a_save_;
+    };
+
+    /**
+     * duration stream inserter
+     * @param os the output stream
+     * @param d to value to insert
+     * @return @c os
+     */
+    template <class CharT, class Traits, class Rep, class Period>
+    std::basic_ostream<CharT, Traits>&
+    operator<<(std::basic_ostream<CharT, Traits>& os, const duration<Rep, Period>& d)
+    {
+      typedef std::basic_string<CharT, Traits> string_type;
+#ifndef BOOST_NO_EXCEPTIONS
+      bool failed = false;
+      try // BOOST_NO_EXCEPTIONS protected
+#endif
+      {
+        std::ios_base::iostate err = std::ios_base::goodbit;
+#ifndef BOOST_NO_EXCEPTIONS
+        try // BOOST_NO_EXCEPTIONS protected
+#endif
+        {
+          typename std::basic_ostream<CharT, Traits>::sentry opfx(os);
+          if (bool(opfx))
+          {
+            if (!std::has_facet<duration_put<CharT> >(os.getloc()))
+            {
+              if (duration_put<CharT> ().put(os, os, os.fill(), d) .failed())
+              {
+                err = std::ios_base::badbit;
+              }
+            }
+            else if (std::use_facet<duration_put<CharT> >(os.getloc()) .put(os, os, os.fill(), d) .failed())
+            {
+              err = std::ios_base::badbit;
+            }
+            os.width(0);
+          }
+        }
+#ifndef BOOST_NO_EXCEPTIONS
+        catch (...) // BOOST_NO_EXCEPTIONS protected
+        {
+          bool flag = false;
+          try // BOOST_NO_EXCEPTIONS protected
+          {
+            os.setstate(std::ios_base::failbit);
+          }
+          catch (std::ios_base::failure ) // BOOST_NO_EXCEPTIONS protected
+          {
+            flag = true;
+          }
+          if (flag) throw;
+        }
+#endif
+        if (err) os.setstate(err);
+        return os;
+      }
+#ifndef BOOST_NO_EXCEPTIONS
+      catch (...) // BOOST_NO_EXCEPTIONS protected
+      {
+        failed = true;
+      }
+      if (failed) os.setstate(std::ios_base::failbit | std::ios_base::badbit);
+#endif
+      return os;
+    }
+
+    /**
+     *
+     * @param is the input stream
+     * @param d the duration
+     * @return @c is
+     */
+    template <class CharT, class Traits, class Rep, class Period>
+    std::basic_istream<CharT, Traits>&
+    operator>>(std::basic_istream<CharT, Traits>& is, duration<Rep, Period>& d)
+    {
+      std::ios_base::iostate err = std::ios_base::goodbit;
+
+#ifndef BOOST_NO_EXCEPTIONS
+      try // BOOST_NO_EXCEPTIONS protected
+#endif
+      {
+        typename std::basic_istream<CharT, Traits>::sentry ipfx(is);
+        if (bool(ipfx))
+        {
+          if (!std::has_facet<duration_get<CharT> >(is.getloc()))
+          {
+            duration_get<CharT> ().get(is, std::istreambuf_iterator<CharT, Traits>(), is, err, d);
+          }
+          else
+          {
+            std::use_facet<duration_get<CharT> >(is.getloc()) .get(is, std::istreambuf_iterator<CharT, Traits>(), is,
+                err, d);
+          }
+        }
+      }
+#ifndef BOOST_NO_EXCEPTIONS
+      catch (...) // BOOST_NO_EXCEPTIONS protected
+      {
+        bool flag = false;
+        try // BOOST_NO_EXCEPTIONS protected
+        {
+          is.setstate(std::ios_base::failbit);
+        }
+        catch (std::ios_base::failure ) // BOOST_NO_EXCEPTIONS protected
+        {
+          flag = true;
+        }
+        if (flag) throw; // BOOST_NO_EXCEPTIONS protected
+      }
+#endif
+      if (err) is.setstate(err);
+      return is;
+    }
+
+  } // chrono
+
+}
+
+#endif  // header

3party/boost/boost/chrono/io/duration_put.hpp

@@ -0,0 +1,264 @@
+//  (C) Copyright Howard Hinnant
+//  (C) Copyright 2011 Vicente J. Botet Escriba
+//  Use, modification and distribution are 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).
+//
+
+/**
+ * Duration formatting facet for output.
+ */
+#ifndef BOOST_CHRONO_IO_DURATION_PUT_HPP
+#define BOOST_CHRONO_IO_DURATION_PUT_HPP
+
+#include <boost/chrono/config.hpp>
+#include <boost/chrono/io/duration_units.hpp>
+#include <boost/assert.hpp>
+#include <locale>
+
+namespace boost
+{
+  namespace chrono
+  {
+
+    /**
+     * @tparam ChatT a character type
+     * @tparam OutputIterator a model of @c OutputIterator
+     *
+     * The @c duration_put facet provides facilities for formatted output of duration values.
+     * The member function of @c duration_put take a duration and format it into character string representation.
+     *
+     */
+    template <class CharT, class OutputIterator = std::ostreambuf_iterator<CharT> >
+    class duration_put: public std::locale::facet
+    {
+    public:
+      /**
+       * Type of character the facet is instantiated on.
+       */
+      typedef CharT char_type;
+      /**
+       * Type of character string passed to member functions.
+       */
+      typedef std::basic_string<CharT> string_type;
+      /**
+       * Type of iterator used to write in the character buffer.
+       */
+      typedef OutputIterator iter_type;
+
+      /**
+       * Construct a duration_put facet.
+       * @param refs
+       * @Effects Construct a duration_put facet.
+       * If the @c refs argument is @c 0 then destruction of the object is
+       * delegated to the @c locale, or locales, containing it. This allows
+       * the user to ignore lifetime management issues. On the other had,
+       * if @c refs is @c 1 then the object must be explicitly deleted;
+       * the @c locale will not do so. In this case, the object can be
+       * maintained across the lifetime of multiple locales.
+       */
+      explicit duration_put(size_t refs = 0) :
+        std::locale::facet(refs)
+      {
+      }
+
+      /**
+       *
+       * @param s an output stream iterator
+       * @param ios a reference to a ios_base
+       * @param fill the character used as filler
+       * @param d the duration
+       * @param pattern begin of the formatting pattern
+       * @param pat_end end of the formatting pattern
+       *
+       * @Effects Steps through the sequence from @c pattern to @c pat_end,
+       * identifying characters that are part of a pattern sequence. Each character
+       * that is not part of a pattern sequence is written to @c s immediately, and
+       * each pattern sequence, as it is identified, results in a call to
+       * @c put_value or @c put_unit;
+       * thus, pattern elements and other characters are interleaved in the output
+       * in the order in which they appear in the pattern. Pattern sequences are
+       * identified by converting each character @c c to a @c char value as if by
+       * @c ct.narrow(c,0), where @c ct is a reference to @c ctype<charT> obtained from
+       * @c ios.getloc(). The first character of each sequence is equal to @c '%',
+       * followed by a pattern specifier character @c spec, which can be @c 'v' for
+       * the duration value or @c 'u' for the duration unit. .
+       * For each valid pattern sequence identified, calls
+       * <c>put_value(s, ios, fill, d)</c> or <c>put_unit(s, ios, fill, d)</c>.
+       *
+       * @Returns An iterator pointing immediately after the last character produced.
+       */
+      template <typename Rep, typename Period>
+      iter_type put(iter_type s, std::ios_base& ios, char_type fill, duration<Rep, Period> const& d, const CharT* pattern,
+          const CharT* pat_end) const
+      {
+        if (std::has_facet<duration_units<CharT> >(ios.getloc()))
+        {
+          duration_units<CharT> const&facet = std::use_facet<duration_units<CharT> >(
+              ios.getloc());
+          return put(facet, s, ios, fill, d, pattern, pat_end);
+        }
+        else
+        {
+          duration_units_default<CharT> facet;
+          return put(facet, s, ios, fill, d, pattern, pat_end);
+        }
+      }
+
+      template <typename Rep, typename Period>
+      iter_type put(duration_units<CharT> const& units_facet, iter_type s, std::ios_base& ios, char_type fill,
+          duration<Rep, Period> const& d, const CharT* pattern, const CharT* pat_end) const
+      {
+
+        const std::ctype<char_type>& ct = std::use_facet<std::ctype<char_type> >(ios.getloc());
+        for (; pattern != pat_end; ++pattern)
+        {
+          if (ct.narrow(*pattern, 0) == '%')
+          {
+            if (++pattern == pat_end)
+            {
+              *s++ = pattern[-1];
+              break;
+            }
+            char fmt = ct.narrow(*pattern, 0);
+            switch (fmt)
+            {
+            case 'v':
+            {
+              s = put_value(s, ios, fill, d);
+              break;
+            }
+            case 'u':
+            {
+              s = put_unit(units_facet, s, ios, fill, d);
+              break;
+            }
+            default:
+              BOOST_ASSERT(false && "Boost::Chrono internal error.");
+              break;
+            }
+          }
+          else
+            *s++ = *pattern;
+        }
+        return s;
+      }
+
+      /**
+       *
+       * @param s an output stream iterator
+       * @param ios a reference to a ios_base
+       * @param fill the character used as filler
+       * @param d the duration
+       * @Effects imbue in @c ios the @c duration_units_default facet if not already present.
+       * Retrieves Stores the duration pattern from the @c duration_unit facet in let say @c str. Last as if
+       * @code
+       *   return put(s, ios, d, str.data(), str.data() + str.size());
+       * @endcode
+       * @Returns An iterator pointing immediately after the last character produced.
+       */
+      template <typename Rep, typename Period>
+      iter_type put(iter_type s, std::ios_base& ios, char_type fill, duration<Rep, Period> const& d) const
+      {
+        if (std::has_facet<duration_units<CharT> >(ios.getloc()))
+        {
+          duration_units<CharT> const&facet = std::use_facet<duration_units<CharT> >(
+              ios.getloc());
+          std::basic_string<CharT> str = facet.get_pattern();
+          return put(facet, s, ios, fill, d, str.data(), str.data() + str.size());
+        }
+        else
+        {
+          duration_units_default<CharT> facet;
+          std::basic_string<CharT> str = facet.get_pattern();
+          return put(facet, s, ios, fill, d, str.data(), str.data() + str.size());
+        }
+      }
+
+      /**
+       *
+       * @param s an output stream iterator
+       * @param ios a reference to a ios_base
+       * @param fill the character used as filler
+       * @param d the duration
+       * @Effects As if s=std::use_facet<std::num_put<CharT, iter_type> >(ios.getloc()).put(s, ios, fill, static_cast<long int> (d.count())).
+       * @Returns s, iterator pointing immediately after the last character produced.
+       */
+      template <typename Rep, typename Period>
+      iter_type put_value(iter_type s, std::ios_base& ios, char_type fill, duration<Rep, Period> const& d) const
+      {
+        return std::use_facet<std::num_put<CharT, iter_type> >(ios.getloc()).put(s, ios, fill,
+            static_cast<long int> (d.count()));
+      }
+
+      /**
+       *
+       * @param s an output stream iterator
+       * @param ios a reference to a ios_base
+       * @param fill the character used as filler
+       * @param d the duration
+       * @Effects Let facet be the duration_units<CharT> facet associated to ios. If the associated unit is named,
+       * as if
+       * @code
+          string_type str = facet.get_unit(get_duration_style(ios), d);
+          s=std::copy(str.begin(), str.end(), s);
+       * @endcode
+       * Otherwise, format the unit as "[Period::num/Period::den]" followed by the unit associated to [N/D] obtained using facet.get_n_d_unit(get_duration_style(ios), d)
+       * @Returns s, iterator pointing immediately after the last character produced.
+       */
+      template <typename Rep, typename Period>
+      iter_type put_unit(iter_type s, std::ios_base& ios, char_type fill, duration<Rep, Period> const& d) const
+      {
+        if (std::has_facet<duration_units<CharT> >(ios.getloc()))
+        {
+          duration_units<CharT> const&facet = std::use_facet<duration_units<CharT> >(
+              ios.getloc());
+          return put_unit(facet, s, ios, fill, d);
+        }
+        else
+        {
+          duration_units_default<CharT> facet;
+          return put_unit(facet, s, ios, fill, d);
+        }
+      }
+
+      template <typename Rep, typename Period>
+      iter_type put_unit(duration_units<CharT> const& facet, iter_type s, std::ios_base& ios, char_type fill,
+          duration<Rep, Period> const& d) const
+      {
+        if (facet.template is_named_unit<Period>()) {
+          string_type str = facet.get_unit(get_duration_style(ios), d);
+          s=std::copy(str.begin(), str.end(), s);
+        } else {
+          *s++ = CharT('[');
+          std::use_facet<std::num_put<CharT, iter_type> >(ios.getloc()).put(s, ios, fill, Period::num);
+          *s++ = CharT('/');
+          std::use_facet<std::num_put<CharT, iter_type> >(ios.getloc()).put(s, ios, fill, Period::den);
+          *s++ = CharT(']');
+          string_type str = facet.get_n_d_unit(get_duration_style(ios), d);
+          s=std::copy(str.begin(), str.end(), s);
+        }
+        return s;
+      }
+
+      /**
+       * Unique identifier for this type of facet.
+       */
+      static std::locale::id id;
+
+      /**
+       * @Effects Destroy the facet
+       */
+      ~duration_put()
+      {
+      }
+
+    };
+
+    template <class CharT, class OutputIterator>
+    std::locale::id duration_put<CharT, OutputIterator>::id;
+
+  } // chrono
+} // boost
+
+#endif  // header

3party/boost/boost/chrono/io/duration_style.hpp

@@ -0,0 +1,35 @@
+//  (C) Copyright Howard Hinnant
+//  (C) Copyright 2011 Vicente J. Botet Escriba
+//  Use, modification and distribution are 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).
+//
+// This code was adapted by Vicente from Howard Hinnant's experimental work
+// on chrono i/o to Boost
+
+#ifndef BOOST_CHRONO_IO_DURATION_STYLE_HPP
+#define BOOST_CHRONO_IO_DURATION_STYLE_HPP
+
+#include <boost/detail/scoped_enum_emulation.hpp>
+
+namespace boost
+{
+  namespace chrono
+  {
+    /**
+     * Scoped enumeration emulation stating whether the duration I/O style is long or short.
+     * prefix means duration::rep with whatever stream/locale settings are set for it followed by a long name representing the unit
+     * symbol means duration::rep with whatever stream/locale settings are set for it followed by a SI unit abbreviation
+     */
+    BOOST_SCOPED_ENUM_DECLARE_BEGIN(duration_style)
+          {
+            prefix, symbol
+          }
+    BOOST_SCOPED_ENUM_DECLARE_END(duration_style)
+
+
+  } // chrono
+
+}
+
+#endif  // header

3party/boost/boost/chrono/io/duration_units.hpp

@@ -0,0 +1,992 @@
+//  (C) Copyright Howard Hinnant
+//  (C) Copyright 2011 Vicente J. Botet Escriba
+//  Use, modification and distribution are 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).
+//
+
+#ifndef BOOST_CHRONO_IO_DURATION_UNITS_HPP
+#define BOOST_CHRONO_IO_DURATION_UNITS_HPP
+
+#include <boost/chrono/config.hpp>
+#include <boost/ratio/ratio_io.hpp>
+#include <boost/chrono/duration.hpp>
+#include <boost/chrono/io/duration_style.hpp>
+#include <boost/chrono/io/ios_base_state.hpp>
+#include <boost/assert.hpp>
+#include <string>
+#include <ios>
+#include <locale>
+#include <algorithm>
+
+namespace boost
+{
+  namespace chrono
+  {
+    class rt_ratio
+    {
+    public:
+      template <typename Period>
+      rt_ratio(Period const&) :
+        num(Period::type::num), den(Period::type::den)
+      {
+      }
+
+      rt_ratio(intmax_t n = 0, intmax_t d = 0) :
+        num(n), den(d)
+      {
+      }
+
+      intmax_t num;
+      intmax_t den;
+    };
+
+    /**
+     * @c duration_units facet gives useful information about the duration units,
+     * as the number of plural forms, the plural form associated to a duration,
+     * the text associated to a plural form and a duration's period,
+     */
+    template <typename CharT = char>
+    class duration_units: public std::locale::facet
+    {
+    public:
+      /**
+       * Type of character the facet is instantiated on.
+       */
+      typedef CharT char_type;
+      /**
+       * Type of character string passed to member functions.
+       */
+      typedef std::basic_string<CharT> string_type;
+
+      /**
+       * Unique identifier for this type of facet.
+       */
+      static std::locale::id id;
+
+      /**
+       * Construct a @c duration_units facet.
+       * @param refs
+       * @Effects Construct a @c duration_units facet.
+       * If the @c refs argument is @c 0 then destruction of the object is
+       * delegated to the @c locale, or locales, containing it. This allows
+       * the user to ignore lifetime management issues. On the other had,
+       * if @c refs is @c 1 then the object must be explicitly deleted;
+       * the @c locale will not do so. In this case, the object can be
+       * maintained across the lifetime of multiple locales.
+       */
+      explicit duration_units(size_t refs = 0) :
+        std::locale::facet(refs)
+      {
+      }
+
+      /**
+       * @return pointer to the start of valid [N/D] units.
+       */
+      virtual const string_type* get_n_d_valid_units_start() const =0;
+      /**
+       * @effect calls the do_...
+       * @return pointer to the end of valid [N/D] units.
+       */
+      virtual const string_type* get_n_d_valid_units_end() const=0;
+
+      /**
+       * @return pointer to the start of valid units, symbol or prefix with its different plural forms.
+       */
+      virtual const string_type* get_valid_units_start() const=0;
+      /**
+       * @return pointer to the end of valid units.
+       */
+      virtual const string_type* get_valid_units_end() const=0;
+
+      /**
+       * @param k the found pointer to the [N/D] unit.
+       * @return true if @c k matches a valid unit.
+       */
+      virtual bool match_n_d_valid_unit(const string_type* k) const = 0;
+      /**
+       * @param k the found pointer to the unit.
+       * @Effects @c rt is set to the valid Period when the @c k matches a valid unit.
+       * @return true if @c k matches a valid unit.
+       */
+      virtual bool match_valid_unit(const string_type* k, rt_ratio& rt) const = 0;
+
+      /**
+       * @effect calls the do_...
+       * @return the pattern to be used by default.
+       */
+      virtual string_type get_pattern() const=0;
+
+      /**
+       * @effect calls the do_...
+       * @return the unit associated to this duration.
+       */
+      template <typename Rep, typename Period>
+      string_type get_unit(duration_style style, duration<Rep, Period> const& d) const
+      {
+        return do_get_unit(style, rt_ratio(Period()), static_cast<intmax_t>(d.count()));
+      }
+      /**
+       * @effect calls the do_...
+       * @return the [N/D] suffix unit associated to this duration.
+       */
+      template <typename Rep, typename Period>
+      string_type get_n_d_unit(duration_style style, duration<Rep, Period> const& d) const
+      {
+        return do_get_n_d_unit(style, rt_ratio(Period()), static_cast<intmax_t>(d.count()));
+      }
+
+      /**
+       * @effect calls the do_...
+       * @return true if the unit associated to the given Period is named, false otherwise.
+       */
+      template <typename Period>
+      bool is_named_unit() const
+      {
+        return do_is_named_unit(rt_ratio(Period()));
+      }
+
+
+    protected:
+
+      /**
+       * @Effects Destroys the facet
+       */
+      virtual ~duration_units()
+      {
+      }
+      /**
+       * @return the [N/D] suffix unit associated to this duration.
+       */
+      virtual string_type do_get_n_d_unit(duration_style style, rt_ratio rt, intmax_t v) const = 0;
+      /**
+       * @return the unit associated to this duration.
+       */
+      virtual string_type do_get_unit(duration_style style,rt_ratio rt, intmax_t v) const = 0;
+      /**
+       * @return true if the unit associated to the given Period is named, false otherwise.
+       */
+      virtual bool do_is_named_unit(rt_ratio rt) const =0;
+
+    };
+
+    template <typename CharT>
+    std::locale::id duration_units<CharT>::id;
+
+    namespace detail
+    {
+      template<typename CharT>
+      struct duration_units_default_holder
+      {
+        typedef std::basic_string<CharT> string_type;
+        static string_type* n_d_valid_units_;
+        static string_type* valid_units_;
+        static bool initialized_;
+      };
+      template <typename CharT>
+      typename duration_units_default_holder<CharT>::string_type* duration_units_default_holder<CharT>::n_d_valid_units_=0;
+      template <typename CharT>
+      typename duration_units_default_holder<CharT>::string_type* duration_units_default_holder<CharT>::valid_units_=0;
+      template<typename CharT>
+      bool duration_units_default_holder<CharT>::initialized_ = false;
+    }
+
+    /**
+     * This class is used to define the strings for the default English
+     */
+    template <typename CharT = char>
+    class duration_units_default: public duration_units<CharT>
+    {
+    protected:
+      static const std::size_t pfs_ = 2;
+
+    public:
+      /**
+       * Type of character the facet is instantiated on.
+       */
+      typedef CharT char_type;
+      /**
+       * Type of character string passed to member functions.
+       */
+      typedef std::basic_string<CharT> string_type;
+
+      /**
+       * Construct a @c duration_units_default facet.
+       * @param refs
+       * @Effects Construct a @c duration_units_default facet.
+       * If the @c refs argument is @c 0 then destruction of the object is
+       * delegated to the @c locale, or locales, containing it. This allows
+       * the user to ignore lifetime management issues. On the other had,
+       * if @c refs is @c 1 then the object must be explicitly deleted;
+       * the @c locale will not do so. In this case, the object can be
+       * maintained across the lifetime of multiple locales.
+       */
+      explicit duration_units_default(size_t refs = 0) :
+        duration_units<CharT> (refs)
+      {
+      }
+
+      /**
+       * Destroys the facet.
+       */
+      ~duration_units_default()
+      {
+      }
+
+    public:
+
+      /**
+       * @param k the found pointer to the [N/D] unit.
+       * @return true if @c k matches a valid unit.
+       */
+      bool match_n_d_valid_unit(const string_type* k) const
+      {
+        std::size_t index = (k - get_n_d_valid_units_start()) / (pfs_ + 1);
+        switch (index)
+        {
+        case 0:
+          break;
+        default:
+          return false;
+        }
+        return true;
+      }
+      /**
+       * @param k the found pointer to the unit.
+       * @Effects @c rt is set to the valid Period when the @c k matches a valid unit.
+       * @return true if @c k matches a valid unit.
+       */
+      bool match_valid_unit(const string_type* k, rt_ratio& rt) const
+      {
+        std::size_t index = (k - get_valid_units_start()) / (pfs_ + 1);
+        switch (index)
+        {
+        case 0:
+          rt = rt_ratio(atto());
+          break;
+        case 1:
+          rt = rt_ratio(femto());
+          break;
+        case 2:
+          rt = rt_ratio(pico());
+          break;
+        case 3:
+          rt = rt_ratio(nano());
+          break;
+        case 4:
+          rt = rt_ratio(micro());
+          break;
+        case 5:
+          rt = rt_ratio(milli());
+          break;
+        case 6:
+          rt = rt_ratio(centi());
+          break;
+        case 7:
+          rt = rt_ratio(deci());
+          break;
+        case 8:
+          rt = rt_ratio(deca());
+          break;
+        case 9:
+          rt = rt_ratio(hecto());
+          break;
+        case 10:
+          rt = rt_ratio(kilo());
+          break;
+        case 11:
+          rt = rt_ratio(mega());
+          break;
+        case 12:
+          rt = rt_ratio(giga());
+          break;
+        case 13:
+          rt = rt_ratio(tera());
+          break;
+        case 14:
+          rt = rt_ratio(peta());
+          break;
+        case 15:
+          rt = rt_ratio(exa());
+          break;
+        case 16:
+          rt = rt_ratio(ratio<1> ());
+          break;
+        case 17:
+          rt = rt_ratio(ratio<60> ());
+          break;
+        case 18:
+          rt = rt_ratio(ratio<3600> ());
+          break;
+        default:
+          return false;
+        }
+        return true;
+      }
+
+      /**
+       * @return pointer to the start of valid [N/D] units.
+       */
+      virtual const string_type* get_n_d_valid_units_start()const
+      {
+        return  detail::duration_units_default_holder<CharT>::n_d_valid_units_;
+      }
+      /**
+       * @return pointer to the end of valid [N/D] units.
+       */
+      virtual const string_type* get_n_d_valid_units_end()const
+      {
+        return detail::duration_units_default_holder<CharT>::n_d_valid_units_ + (pfs_ + 1);
+      }
+
+      /**
+       * @return pointer to the start of valid units.
+       */
+      virtual string_type* get_valid_units_start() const
+      {
+        return detail::duration_units_default_holder<CharT>::valid_units_;
+      }
+      /**
+       * @return pointer to the end of valid units.
+       */
+      virtual string_type* get_valid_units_end() const
+      {
+        return detail::duration_units_default_holder<CharT>::valid_units_ + 19 * (pfs_ + 1);
+      }
+
+      string_type get_pattern() const
+      {
+        static const CharT t[] =
+        { '%', 'v', ' ', '%', 'u' };
+        static const string_type pattern(t, t + sizeof (t) / sizeof (t[0]));
+
+        return pattern;
+      }
+
+    protected:
+      /**
+       *
+       * This facet names the units associated to the following periods:
+       * atto,femto,pico,nano,micro,milli,centi,deci,ratio<1>,deca,hecto,kilo,mega,giga,tera,peta,exa,ratio<60> and ratio<3600>.
+       * @return true if the unit associated to the given Period is named, false otherwise.
+       */
+      bool do_is_named_unit(rt_ratio rt) const
+      {
+        if (rt.num==1) {
+          switch (rt.den)
+          {
+          case BOOST_RATIO_INTMAX_C(1):
+          case BOOST_RATIO_INTMAX_C(10):
+          case BOOST_RATIO_INTMAX_C(100):
+          case BOOST_RATIO_INTMAX_C(1000):
+          case BOOST_RATIO_INTMAX_C(1000000):
+          case BOOST_RATIO_INTMAX_C(1000000000):
+          case BOOST_RATIO_INTMAX_C(1000000000000):
+          case BOOST_RATIO_INTMAX_C(1000000000000000):
+          case BOOST_RATIO_INTMAX_C(1000000000000000000):
+            return true;
+          default:
+            return false;
+          }
+        } else if (rt.den==1) {
+          switch (rt.num)
+          {
+          case BOOST_RATIO_INTMAX_C(10):
+          case BOOST_RATIO_INTMAX_C(60):
+          case BOOST_RATIO_INTMAX_C(100):
+          case BOOST_RATIO_INTMAX_C(1000):
+          case BOOST_RATIO_INTMAX_C(3600):
+          case BOOST_RATIO_INTMAX_C(1000000):
+          case BOOST_RATIO_INTMAX_C(1000000000):
+          case BOOST_RATIO_INTMAX_C(1000000000000):
+          case BOOST_RATIO_INTMAX_C(1000000000000000):
+          case BOOST_RATIO_INTMAX_C(1000000000000000000):
+            return true;
+          default:
+            return false;
+          }
+        }
+        return false;
+
+      }
+
+      /**
+       * In English the suffix used after [N/D] is the one associated to the period ratio<1>.
+       * @return the [N/D] suffix unit associated to this duration.
+       */
+      string_type do_get_n_d_unit(duration_style style, rt_ratio, intmax_t v) const
+      {
+        return do_get_unit(style, ratio<1>(), do_get_plural_form(v));
+      }
+
+      /**
+       * @return the unit associated to this duration if it is named, "" otherwise.
+       */
+      string_type do_get_unit(duration_style style, rt_ratio rt, intmax_t v) const
+      {
+        if (rt.num==1) {
+          switch (rt.den)
+          {
+          case BOOST_RATIO_INTMAX_C(1):
+            return do_get_unit(style, ratio<1>(), do_get_plural_form(v));
+          case BOOST_RATIO_INTMAX_C(10):
+            return do_get_unit(style, deci(), do_get_plural_form(v));
+          case BOOST_RATIO_INTMAX_C(100):
+            return do_get_unit(style, centi(), do_get_plural_form(v));
+          case BOOST_RATIO_INTMAX_C(1000):
+            return do_get_unit(style, milli(), do_get_plural_form(v));
+          case BOOST_RATIO_INTMAX_C(1000000):
+            return do_get_unit(style, micro(), do_get_plural_form(v));
+          case BOOST_RATIO_INTMAX_C(1000000000):
+            return do_get_unit(style, nano(), do_get_plural_form(v));
+          case BOOST_RATIO_INTMAX_C(1000000000000):
+            return do_get_unit(style, pico(), do_get_plural_form(v));
+          case BOOST_RATIO_INTMAX_C(1000000000000000):
+            return do_get_unit(style, femto(), do_get_plural_form(v));
+          case BOOST_RATIO_INTMAX_C(1000000000000000000):
+            return do_get_unit(style, atto(), do_get_plural_form(v));
+          default:
+            ;
+          }
+        } else if (rt.den==1) {
+          switch (rt.num)
+          {
+          case BOOST_RATIO_INTMAX_C(10):
+             return do_get_unit(style, deca(), do_get_plural_form(v));
+          case BOOST_RATIO_INTMAX_C(60):
+            return do_get_unit(style, ratio<60>(), do_get_plural_form(v));
+          case BOOST_RATIO_INTMAX_C(100):
+             return do_get_unit(style, hecto(), do_get_plural_form(v));
+           case BOOST_RATIO_INTMAX_C(1000):
+             return do_get_unit(style, kilo(), do_get_plural_form(v));
+           case BOOST_RATIO_INTMAX_C(3600):
+             return do_get_unit(style, ratio<3600>(), do_get_plural_form(v));
+           case BOOST_RATIO_INTMAX_C(1000000):
+             return do_get_unit(style, mega(), do_get_plural_form(v));
+           case BOOST_RATIO_INTMAX_C(1000000000):
+             return do_get_unit(style, giga(), do_get_plural_form(v));
+           case BOOST_RATIO_INTMAX_C(1000000000000):
+             return do_get_unit(style, tera(), do_get_plural_form(v));
+           case BOOST_RATIO_INTMAX_C(1000000000000000):
+             return do_get_unit(style, peta(), do_get_plural_form(v));
+           case BOOST_RATIO_INTMAX_C(1000000000000000000):
+             return do_get_unit(style, exa(), do_get_plural_form(v));
+           default:
+             ;
+           }
+        }
+        BOOST_ASSERT(false&&"ratio parameter can not be translated");
+        //throw "exception";
+        return string_type();
+      }
+
+    protected:
+      /**
+       * @return the number of associated plural forms this facet manages.
+       */
+      virtual std::size_t do_get_plural_forms() const
+      {
+        return static_get_plural_forms();
+      }
+      static std::size_t static_get_plural_forms()
+      {
+        return pfs_;
+      }
+      /**
+       * Gets the associated plural form.
+       * @param value the duration representation
+       * @return the plural form associated to the @c value parameter. In English there are 2 plural forms
+       * 0 singular (-1 or 1)
+       * 1 plural for all others
+       */
+      virtual std::size_t do_get_plural_form(int_least64_t value) const
+      {
+        return static_get_plural_form(value);
+      }
+      static std::size_t static_get_plural_form(int_least64_t value)
+      {
+        return (value == -1 || value == 1) ? 0 : 1;
+      }
+
+      /**
+       * @param style the duration style.
+       * @param period the period associated to the duration seconds.
+       * @param pf the requested plural form.
+       * @return if style is symbol returns "s", otherwise if pf is 0 return "second", if pf is 1 "seconds"
+       */
+      virtual string_type do_get_unit(duration_style style, ratio<1> u, std::size_t pf) const
+      {
+        return static_get_unit(style,u,pf);
+      }
+      static string_type static_get_unit(duration_style style, ratio<1> , std::size_t pf)
+      {
+        static const CharT t[] =
+        { 's' };
+        static const string_type symbol(t, t + sizeof (t) / sizeof (t[0]));
+        static const CharT u[] =
+        { 's', 'e', 'c', 'o', 'n', 'd' };
+        static const string_type singular(u, u + sizeof (u) / sizeof (u[0]));
+        static const CharT v[] =
+        { 's', 'e', 'c', 'o', 'n', 'd', 's' };
+        static const string_type plural(v, v + sizeof (v) / sizeof (v[0]));
+
+        if (style == duration_style::symbol)
+        {
+          return symbol;
+        }
+        if (pf == 0)
+        {
+          return singular;
+        }
+        if (pf == 1)
+        {
+          return plural;
+        }
+        BOOST_ASSERT(false&&"style/pf parameters not valid");
+        //throw "exception";
+        return string_type();
+      }
+
+      /**
+       * @param style the duration style.
+       * @param period the period associated to the duration minutes.
+       * @param pf the requested plural form.
+       * @return if style is symbol returns "min", otherwise if pf is 0 return "minute", if pf is 1 "minutes"
+       */
+      virtual string_type do_get_unit(duration_style style, ratio<60> u, std::size_t pf) const
+      {
+        return static_get_unit(style,u,pf);
+      }
+      static string_type static_get_unit(duration_style style, ratio<60> , std::size_t pf)
+      {
+        static const CharT t[] =
+        { 'm', 'i', 'n' };
+        static const string_type symbol(t, t + sizeof (t) / sizeof (t[0]));
+
+        static const CharT u[] =
+        { 'm', 'i', 'n', 'u', 't', 'e' };
+        static const string_type singular(u, u + sizeof (u) / sizeof (u[0]));
+        static const CharT v[] =
+        { 'm', 'i', 'n', 'u', 't', 'e', 's' };
+        static const string_type plural(v, v + sizeof (v) / sizeof (v[0]));
+
+        if (style == duration_style::symbol) return symbol;
+        if (pf == 0) return singular;
+        if (pf == 1) return plural;
+        BOOST_ASSERT(false&&"style/pf parameters not valid");
+        //throw "exception";
+        return string_type();
+
+      }
+
+      /**
+       * @param style the duration style.
+       * @param period the period associated to the duration hours.
+       * @param pf the requested plural form.
+       * @return if style is symbol returns "h", otherwise if pf is 0 return "hour", if pf is 1 "hours"
+       */
+      virtual string_type do_get_unit(duration_style style, ratio<3600> u, std::size_t pf) const
+      {
+        return static_get_unit(style,u,pf);
+      }
+      static string_type static_get_unit(duration_style style, ratio<3600> , std::size_t pf)
+      {
+        static const CharT t[] =
+        { 'h' };
+        static const string_type symbol(t, t + sizeof (t) / sizeof (t[0]));
+        static const CharT u[] =
+        { 'h', 'o', 'u', 'r' };
+        static const string_type singular(u, u + sizeof (u) / sizeof (u[0]));
+        static const CharT v[] =
+        { 'h', 'o', 'u', 'r', 's' };
+        static const string_type plural(v, v + sizeof (v) / sizeof (v[0]));
+
+        if (style == duration_style::symbol) return symbol;
+        if (pf == 0) return singular;
+        if (pf == 1) return plural;
+        BOOST_ASSERT(false&&"style/pf parameters not valid");
+        //throw "exception";
+        return string_type();
+
+      }
+      /**
+       * @param style the duration style.
+       * @param u the period tag atto.
+       * @param pf the requested plural form.
+       * @return the concatenation of the prefix associated to @c period + the one associated to seconds.
+       */
+      virtual string_type do_get_unit(duration_style style, atto u, std::size_t pf) const
+      {
+        return do_get_ratio_prefix(style, u) + do_get_unit(style, ratio<1> (), pf);
+      }
+      static string_type static_get_unit(duration_style style, atto u, std::size_t pf)
+      {
+        return static_get_ratio_prefix(style, u) + static_get_unit(style, ratio<1> (), pf);
+      }
+      /**
+       * @param style the duration style.
+       * @param u the period tag femto.
+       * @param pf the requested plural form.
+       * @return the concatenation of the prefix associated to period @c u + the one associated to seconds.
+       */
+      virtual string_type do_get_unit(duration_style style, femto u, std::size_t pf) const
+      {
+        return do_get_ratio_prefix(style, u) + do_get_unit(style, ratio<1> (), pf);
+      }
+      static string_type static_get_unit(duration_style style, femto u, std::size_t pf)
+      {
+        return static_get_ratio_prefix(style, u) + static_get_unit(style, ratio<1> (), pf);
+      }
+      /**
+       * @param style the duration style.
+       * @param u the period tag femto.
+       * @param pf the requested plural form.
+       * @return the concatenation of the prefix associated to period @c u + the one associated to seconds.
+       */
+      virtual string_type do_get_unit(duration_style style, pico u, std::size_t pf) const
+      {
+        return do_get_ratio_prefix(style, u) + do_get_unit(style, ratio<1> (), pf);
+      }
+      static string_type static_get_unit(duration_style style, pico u, std::size_t pf)
+      {
+        return static_get_ratio_prefix(style, u) + static_get_unit(style, ratio<1> (), pf);
+      }
+      virtual string_type do_get_unit(duration_style style, nano u, std::size_t pf) const
+      {
+        return do_get_ratio_prefix(style, u) + do_get_unit(style, ratio<1> (), pf);
+      }
+      static string_type static_get_unit(duration_style style, nano u, std::size_t pf)
+      {
+        return static_get_ratio_prefix(style, u) + static_get_unit(style, ratio<1> (), pf);
+      }
+      virtual string_type do_get_unit(duration_style style, micro u, std::size_t pf) const
+      {
+        return do_get_ratio_prefix(style, u) + do_get_unit(style, ratio<1> (), pf);
+      }
+      static string_type static_get_unit(duration_style style, micro u, std::size_t pf)
+      {
+        return static_get_ratio_prefix(style, u) + static_get_unit(style, ratio<1> (), pf);
+      }
+      virtual string_type do_get_unit(duration_style style, milli u, std::size_t pf) const
+      {
+        return do_get_ratio_prefix(style, u) + do_get_unit(style, ratio<1> (), pf);
+      }
+      static string_type static_get_unit(duration_style style, milli u, std::size_t pf)
+      {
+        return static_get_ratio_prefix(style, u) + static_get_unit(style, ratio<1> (), pf);
+      }
+      virtual string_type do_get_unit(duration_style style, centi u, std::size_t pf) const
+      {
+        return do_get_ratio_prefix(style, u) + do_get_unit(style, ratio<1> (), pf);
+      }
+      static string_type static_get_unit(duration_style style, centi u, std::size_t pf)
+      {
+        return static_get_ratio_prefix(style, u) + static_get_unit(style, ratio<1> (), pf);
+      }
+      virtual string_type do_get_unit(duration_style style, deci u, std::size_t pf) const
+      {
+        return do_get_ratio_prefix(style, u) + do_get_unit(style, ratio<1> (), pf);
+      }
+      static string_type static_get_unit(duration_style style, deci u, std::size_t pf)
+      {
+        return static_get_ratio_prefix(style, u) + static_get_unit(style, ratio<1> (), pf);
+      }
+      virtual string_type do_get_unit(duration_style style, deca u, std::size_t pf) const
+      {
+        return do_get_ratio_prefix(style, u) + do_get_unit(style, ratio<1> (), pf);
+      }
+      static string_type static_get_unit(duration_style style, deca u, std::size_t pf)
+      {
+        return static_get_ratio_prefix(style, u) + static_get_unit(style, ratio<1> (), pf);
+      }
+      virtual string_type do_get_unit(duration_style style, hecto u, std::size_t pf) const
+      {
+        return do_get_ratio_prefix(style, u) + do_get_unit(style, ratio<1> (), pf);
+      }
+      static string_type static_get_unit(duration_style style, hecto u, std::size_t pf)
+      {
+        return static_get_ratio_prefix(style, u) + static_get_unit(style, ratio<1> (), pf);
+      }
+      virtual string_type do_get_unit(duration_style style, kilo u, std::size_t pf) const
+      {
+        return do_get_ratio_prefix(style, u) + do_get_unit(style, ratio<1> (), pf);
+      }
+      static string_type static_get_unit(duration_style style, kilo u, std::size_t pf)
+      {
+        return static_get_ratio_prefix(style, u) + static_get_unit(style, ratio<1> (), pf);
+      }
+      virtual string_type do_get_unit(duration_style style, mega u, std::size_t pf) const
+      {
+        return do_get_ratio_prefix(style, u) + do_get_unit(style, ratio<1> (), pf);
+      }
+      static string_type static_get_unit(duration_style style, mega u, std::size_t pf)
+      {
+        return static_get_ratio_prefix(style, u) + static_get_unit(style, ratio<1> (), pf);
+      }
+      virtual string_type do_get_unit(duration_style style, giga u, std::size_t pf) const
+      {
+        return do_get_ratio_prefix(style, u) + do_get_unit(style, ratio<1> (), pf);
+      }
+      static string_type static_get_unit(duration_style style, giga u, std::size_t pf)
+      {
+        return static_get_ratio_prefix(style, u) + static_get_unit(style, ratio<1> (), pf);
+      }
+      virtual string_type do_get_unit(duration_style style, tera u, std::size_t pf) const
+      {
+        return do_get_ratio_prefix(style, u) + do_get_unit(style, ratio<1> (), pf);
+      }
+      static string_type static_get_unit(duration_style style, tera u, std::size_t pf)
+      {
+        return static_get_ratio_prefix(style, u) + static_get_unit(style, ratio<1> (), pf);
+      }
+      virtual string_type do_get_unit(duration_style style, peta u, std::size_t pf) const
+      {
+        return do_get_ratio_prefix(style, u) + do_get_unit(style, ratio<1> (), pf);
+      }
+      static string_type static_get_unit(duration_style style, peta u, std::size_t pf)
+      {
+        return static_get_ratio_prefix(style, u) + static_get_unit(style, ratio<1> (), pf);
+      }
+      virtual string_type do_get_unit(duration_style style, exa u, std::size_t pf) const
+      {
+        return do_get_ratio_prefix(style, u) + do_get_unit(style, ratio<1> (), pf);
+      }
+      static string_type static_get_unit(duration_style style, exa u, std::size_t pf)
+      {
+        return static_get_ratio_prefix(style, u) + static_get_unit(style, ratio<1> (), pf);
+      }
+
+    protected:
+
+      /**
+       * @param style the duration style.
+       * @param u the period tag atto.
+       * @return depending on the value of @c style return the ratio_string symbol or prefix.
+       */
+      virtual string_type do_get_ratio_prefix(duration_style style, atto u) const
+      {
+        return static_get_ratio_prefix(style, u);
+      }
+      static string_type static_get_ratio_prefix(duration_style style, atto)
+      {
+        if (style == duration_style::symbol) return ratio_string<atto, CharT>::symbol();
+        return ratio_string<atto, CharT>::prefix();
+      }
+      virtual string_type do_get_ratio_prefix(duration_style style, femto u) const
+      {
+        return static_get_ratio_prefix(style, u);
+      }
+      static string_type static_get_ratio_prefix(duration_style style, femto)
+      {
+        if (style == duration_style::symbol) return ratio_string<femto, CharT>::symbol();
+        return ratio_string<femto, CharT>::prefix();
+      }
+      virtual string_type do_get_ratio_prefix(duration_style style, pico u) const
+      {
+        return static_get_ratio_prefix(style, u);
+      }
+      static string_type static_get_ratio_prefix(duration_style style, pico)
+      {
+        if (style == duration_style::symbol) return ratio_string<pico, CharT>::symbol();
+        return ratio_string<pico, CharT>::prefix();
+      }
+      virtual string_type do_get_ratio_prefix(duration_style style, nano u) const
+      {
+        return static_get_ratio_prefix(style, u);
+      }
+      static string_type static_get_ratio_prefix(duration_style style, nano)
+      {
+        if (style == duration_style::symbol) return ratio_string<nano, CharT>::symbol();
+        return ratio_string<nano, CharT>::prefix();
+      }
+      virtual string_type do_get_ratio_prefix(duration_style style, micro u) const
+      {
+        return static_get_ratio_prefix(style, u);
+      }
+      static string_type static_get_ratio_prefix(duration_style style, micro)
+      {
+        if (style == duration_style::symbol) return ratio_string<micro, CharT>::symbol();
+        return ratio_string<micro, CharT>::prefix();
+      }
+      virtual string_type do_get_ratio_prefix(duration_style style, milli u) const
+      {
+        return static_get_ratio_prefix(style, u);
+      }
+      static string_type static_get_ratio_prefix(duration_style style, milli)
+      {
+        if (style == duration_style::symbol) return ratio_string<milli, CharT>::symbol();
+        return ratio_string<milli, CharT>::prefix();
+      }
+      virtual string_type do_get_ratio_prefix(duration_style style, centi u) const
+      {
+        return static_get_ratio_prefix(style, u);
+      }
+      static string_type static_get_ratio_prefix(duration_style style, centi)
+      {
+        if (style == duration_style::symbol) return ratio_string<centi, CharT>::symbol();
+        return ratio_string<centi, CharT>::prefix();
+      }
+      virtual string_type do_get_ratio_prefix(duration_style style, deci u) const
+      {
+        return static_get_ratio_prefix(style, u);
+      }
+      static string_type static_get_ratio_prefix(duration_style style, deci)
+      {
+        if (style == duration_style::symbol) return ratio_string<deci, CharT>::symbol();
+        return ratio_string<deci, CharT>::prefix();
+      }
+      virtual string_type do_get_ratio_prefix(duration_style style, deca u) const
+      {
+        return static_get_ratio_prefix(style, u);
+      }
+      static string_type static_get_ratio_prefix(duration_style style, deca)
+      {
+        if (style == duration_style::symbol) return ratio_string<deca, CharT>::symbol();
+        return ratio_string<deca, CharT>::prefix();
+      }
+      virtual string_type do_get_ratio_prefix(duration_style style, hecto u) const
+      {
+        return static_get_ratio_prefix(style, u);
+      }
+      static string_type static_get_ratio_prefix(duration_style style, hecto)
+      {
+        if (style == duration_style::symbol) return ratio_string<hecto, CharT>::symbol();
+        return ratio_string<hecto, CharT>::prefix();
+      }
+      virtual string_type do_get_ratio_prefix(duration_style style, kilo u) const
+      {
+        return static_get_ratio_prefix(style, u);
+      }
+      static string_type static_get_ratio_prefix(duration_style style, kilo)
+      {
+        if (style == duration_style::symbol) return ratio_string<kilo, CharT>::symbol();
+        return ratio_string<kilo, CharT>::prefix();
+      }
+      virtual string_type do_get_ratio_prefix(duration_style style, mega u) const
+      {
+        return static_get_ratio_prefix(style, u);
+      }
+      static string_type static_get_ratio_prefix(duration_style style, mega)
+      {
+        if (style == duration_style::symbol) return ratio_string<mega, CharT>::symbol();
+        return ratio_string<mega, CharT>::prefix();
+      }
+      virtual string_type do_get_ratio_prefix(duration_style style, giga u) const
+      {
+        return static_get_ratio_prefix(style, u);
+      }
+      static string_type static_get_ratio_prefix(duration_style style, giga)
+      {
+        if (style == duration_style::symbol) return ratio_string<giga, CharT>::symbol();
+        return ratio_string<giga, CharT>::prefix();
+      }
+      virtual string_type do_get_ratio_prefix(duration_style style, tera u) const
+      {
+        return static_get_ratio_prefix(style, u);
+      }
+      static string_type static_get_ratio_prefix(duration_style style, tera)
+      {
+        if (style == duration_style::symbol) return ratio_string<tera, CharT>::symbol();
+        return ratio_string<tera, CharT>::prefix();
+      }
+      virtual string_type do_get_ratio_prefix(duration_style style, peta u) const
+      {
+        return static_get_ratio_prefix(style, u);
+      }
+      static string_type static_get_ratio_prefix(duration_style style, peta)
+      {
+        if (style == duration_style::symbol) return ratio_string<peta, CharT>::symbol();
+        return ratio_string<peta, CharT>::prefix();
+      }
+      virtual string_type do_get_ratio_prefix(duration_style style, exa u) const
+      {
+        return static_get_ratio_prefix(style, u);
+      }
+      static string_type static_get_ratio_prefix(duration_style style, exa)
+      {
+        if (style == duration_style::symbol) return ratio_string<exa, CharT>::symbol();
+        return ratio_string<exa, CharT>::prefix();
+      }
+
+    protected:
+      template <typename Period>
+      string_type* fill_units(string_type* it, Period) const
+      {
+        std::size_t pfs = do_get_plural_forms();
+        for (std::size_t pf = 0; pf < pfs; ++pf)
+        {
+          *it++ = do_get_unit(duration_style::prefix, Period(), pf);
+        }
+        *it++ = do_get_unit(duration_style::symbol, Period(), 0);
+        return it;
+      }
+    public:
+      template <typename Period>
+      static string_type* static_fill_units(string_type* it, Period)
+      {
+        std::size_t pfs = static_get_plural_forms();
+        for (std::size_t pf = 0; pf < pfs; ++pf)
+        {
+          *it++ = static_get_unit(duration_style::prefix, Period(), pf);
+        }
+        *it++ = static_get_unit(duration_style::symbol, Period(), 0);
+        return it;
+      }
+      static string_type* static_init_valid_units(string_type* it)
+      {
+        it = static_fill_units(it, atto());
+        it = static_fill_units(it, femto());
+        it = static_fill_units(it, pico());
+        it = static_fill_units(it, nano());
+        it = static_fill_units(it, micro());
+        it = static_fill_units(it, milli());
+        it = static_fill_units(it, centi());
+        it = static_fill_units(it, deci());
+        it = static_fill_units(it, deca());
+        it = static_fill_units(it, hecto());
+        it = static_fill_units(it, kilo());
+        it = static_fill_units(it, mega());
+        it = static_fill_units(it, giga());
+        it = static_fill_units(it, tera());
+        it = static_fill_units(it, peta());
+        it = static_fill_units(it, exa());
+        it = static_fill_units(it, ratio<1> ());
+        it = static_fill_units(it, ratio<60> ());
+        it = static_fill_units(it, ratio<3600> ());
+        return it;
+      }
+    };
+
+    namespace detail
+    {
+
+      template<typename CharT>
+      struct duration_units_default_initializer_t
+      {
+        duration_units_default_initializer_t()
+          {
+              if (!duration_units_default_holder<CharT>::initialized_)
+              {
+                typedef typename duration_units_default_holder<CharT>::string_type string_type;
+                duration_units_default_holder<CharT>::n_d_valid_units_ = new string_type[3];
+                duration_units_default_holder<CharT>::valid_units_ = new string_type[19 * 3];
+
+                string_type* it = duration_units_default_holder<CharT>::n_d_valid_units_;
+                it = duration_units_default<CharT>::static_fill_units(it, ratio<1> ());
+                it = duration_units_default<CharT>::static_init_valid_units(duration_units_default_holder<CharT>::valid_units_);
+
+                duration_units_default_holder<CharT>::initialized_ = true;
+              }
+          }
+      };
+      namespace /**/
+      {
+        duration_units_default_initializer_t<char> duration_units_default_initializer;
+        duration_units_default_initializer_t<wchar_t> wduration_units_default_initializer;
+      } // namespace
+    }
+  } // chrono
+
+} // boost
+
+#endif  // header

3party/boost/boost/chrono/io/ios_base_state.hpp

@@ -0,0 +1,150 @@
+//  (C) Copyright 2011 Vicente J. Botet Escriba
+//  Use, modification and distribution are 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).
+//
+// This code was adapted by Vicente from Howard Hinnant's experimental work
+// on chrono i/o to Boost
+
+#ifndef BOOST_CHRONO_IO_IOS_BASE_STATE_HPP
+#define BOOST_CHRONO_IO_IOS_BASE_STATE_HPP
+
+#include <boost/chrono/config.hpp>
+#include <locale>
+#include <boost/chrono/io/duration_style.hpp>
+#include <boost/chrono/io/timezone.hpp>
+#include <boost/chrono/io/utility/ios_base_state_ptr.hpp>
+
+namespace boost
+{
+  namespace chrono
+  {
+
+    class fmt_masks : public ios_flags<fmt_masks>
+    {
+      typedef ios_flags<fmt_masks> base_type;
+
+    public:
+      fmt_masks(std::ios_base& ios): base_type(ios) {}
+      enum type
+      {
+        uses_symbol = 1 << 0,
+        uses_local  = 1 << 1
+      };
+
+      inline duration_style get_duration_style()
+      {
+        return (flags() & uses_symbol) ? duration_style::symbol : duration_style::prefix;
+      }
+      inline void set_duration_style(duration_style style)
+      {
+        if (style == duration_style::symbol)
+          setf(uses_symbol);
+        else
+          unsetf(uses_symbol);
+      }
+
+      inline timezone get_timezone()
+      {
+        return (flags() & uses_local) ? timezone::local : timezone::utc;
+      }
+      inline void set_timezone(timezone tz)
+      {
+        if (tz == timezone::local)
+          setf(uses_local);
+        else
+          unsetf(uses_local);
+      }
+    };
+    namespace detail
+    {
+      namespace /**/ {
+        xalloc_key_initializer<fmt_masks > fmt_masks_xalloc_key_initializer;
+      } // namespace
+    } // namespace detail
+
+    inline duration_style get_duration_style(std::ios_base & ios)
+    {
+      return fmt_masks(ios).get_duration_style();
+    }
+    inline void set_duration_style(std::ios_base& ios, duration_style style)
+    {
+      fmt_masks(ios).set_duration_style(style);
+    }
+    inline std::ios_base&  symbol_format(std::ios_base& ios)
+    {
+      fmt_masks(ios).setf(fmt_masks::uses_symbol);
+      return ios;
+    }
+    inline std::ios_base&  name_format(std::ios_base& ios)
+    {
+      fmt_masks(ios).unsetf(fmt_masks::uses_symbol);
+      return ios;
+    }
+
+    inline timezone get_timezone(std::ios_base & ios)
+    {
+      return fmt_masks(ios).get_timezone();
+    }
+    inline void set_timezone(std::ios_base& ios, timezone tz)
+    {
+      fmt_masks(ios).set_timezone(tz);
+    }
+    inline std::ios_base& local_timezone(std::ios_base& ios)
+    {
+      fmt_masks(ios).setf(fmt_masks::uses_local);
+      return ios;
+    }
+
+    inline std::ios_base& utc_timezone(std::ios_base& ios)
+    {
+      fmt_masks(ios).unsetf(fmt_masks::uses_local);
+      return ios;
+    }
+
+    namespace detail
+    {
+
+      template<typename CharT>
+      struct ios_base_data_aux
+      {
+        std::basic_string<CharT> time_fmt;
+        std::basic_string<CharT> duration_fmt;
+      public:
+
+        ios_base_data_aux() :
+          time_fmt(""),
+          duration_fmt("")
+        {
+        }
+      };
+      template<typename CharT>
+      struct ios_base_data  {};
+      namespace /**/ {
+        xalloc_key_initializer<detail::ios_base_data<char>      > ios_base_data_aux_xalloc_key_initializer;
+        xalloc_key_initializer<detail::ios_base_data<wchar_t>   > wios_base_data_aux_xalloc_key_initializer;
+#if BOOST_CHRONO_HAS_UNICODE_SUPPORT
+        xalloc_key_initializer<detail::ios_base_data<char16_t>  > u16ios_base_data_aux_xalloc_key_initializer;
+        xalloc_key_initializer<detail::ios_base_data<char32_t>  > u32ios_base_data_aux_xalloc_key_initializer;
+#endif
+      } // namespace
+    } // namespace detail
+
+    template<typename CharT>
+    inline std::basic_string<CharT> get_time_fmt(std::ios_base & ios)
+    {
+      ios_state_not_null_ptr<detail::ios_base_data<CharT>, detail::ios_base_data_aux<CharT> > ptr(ios);
+      return ptr->time_fmt;
+    }
+    template<typename CharT>
+    inline void set_time_fmt(std::ios_base& ios, std::basic_string<
+        CharT> const& fmt)
+    {
+      ios_state_not_null_ptr<detail::ios_base_data<CharT>, detail::ios_base_data_aux<CharT> > ptr(ios);
+      ptr->time_fmt = fmt;
+    }
+
+  } // chrono
+} // boost
+
+#endif  // header

3party/boost/boost/chrono/io/time_point_get.hpp

@@ -0,0 +1,333 @@
+//  (C) Copyright Howard Hinnant
+//  (C) Copyright 2011 Vicente J. Botet Escriba
+//  Use, modification and distribution are 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).
+//
+
+#ifndef BOOST_CHRONO_IO_TIME_POINT_GET_HPP
+#define BOOST_CHRONO_IO_TIME_POINT_GET_HPP
+
+#include <boost/chrono/config.hpp>
+#include <boost/chrono/detail/scan_keyword.hpp>
+#include <boost/chrono/io/time_point_units.hpp>
+#include <boost/chrono/io/duration_get.hpp>
+#include <boost/assert.hpp>
+#include <locale>
+#include <string>
+
+/**
+ * Duration formatting facet for input.
+ */
+namespace boost
+{
+  namespace chrono
+  {
+
+    template <class CharT, class InputIterator = std::istreambuf_iterator<CharT> >
+    class time_point_get: public std::locale::facet
+    {
+    public:
+      /**
+       * Type of character the facet is instantiated on.
+       */
+      typedef CharT char_type;
+      /**
+       * Type of iterator used to scan the character buffer.
+       */
+      typedef InputIterator iter_type;
+
+      /**
+       * Construct a @c time_point_get facet.
+       * @param refs
+       * @Effects Construct a @c time_point_get facet.
+       * If the @c refs argument is @c 0 then destruction of the object is
+       * delegated to the @c locale, or locales, containing it. This allows
+       * the user to ignore lifetime management issues. On the other had,
+       * if @c refs is @c 1 then the object must be explicitly deleted;
+       * the @c locale will not do so. In this case, the object can be
+       * maintained across the lifetime of multiple locales.
+       */
+
+      explicit time_point_get(size_t refs = 0) :
+        std::locale::facet(refs)
+      {
+      }
+
+      /**
+       * @param s start input stream iterator
+       * @param end end input stream iterator
+       * @param ios a reference to a ios_base
+       * @param err the ios_base state
+       * @param d the duration
+       * @param pattern begin of the formatting pattern
+       * @param pat_end end of the formatting pattern
+       *
+       * Requires: [pattern,pat_end) shall be a valid range.
+       *
+       * Effects: The function starts by evaluating err = std::ios_base::goodbit.
+       * It then enters a loop, reading zero or more characters from s at
+       * each iteration. Unless otherwise specified below, the loop
+       * terminates when the first of the following conditions holds:
+       * - The expression pattern == pat_end evaluates to true.
+       * - The expression err == std::ios_base::goodbit evaluates to false.
+       * - The expression s == end evaluates to true, in which case the
+       * function evaluates err = std::ios_base::eofbit | std::ios_base::failbit.
+       * - The next element of pattern is equal to '%', followed by a conversion
+       * specifier character, the functions @c get_duration or @c get_epoch are called depending on
+       * whether the format is @c 'd' or @c 'e'.
+       * If the number of elements in the range [pattern,pat_end) is not
+       * sufficient to unambiguously determine whether the conversion
+       * specification is complete and valid, the function evaluates
+       * err = std::ios_base::failbit. Otherwise, the function evaluates
+       * s = do_get(s, end, ios, err, d). If err == std::ios_base::goodbit holds after
+       * the evaluation of the expression, the function increments pattern to
+       * point just past the end of the conversion specification and continues
+       * looping.
+       * - The expression isspace(*pattern, ios.getloc()) evaluates to true, in
+       * which case the function first increments pattern until
+       * pattern == pat_end || !isspace(*pattern, ios.getloc()) evaluates to true,
+       * then advances s until s == end || !isspace(*s, ios.getloc()) is true,
+       * and finally resumes looping.
+       * - The next character read from s matches the element pointed to by
+       * pattern in a case-insensitive comparison, in which case the function
+       * evaluates ++pattern, ++s and continues looping. Otherwise, the function
+       * evaluates err = std::ios_base::failbit.
+       *
+       * Returns: s
+       */
+
+      template <class Clock, class Duration>
+      iter_type get(iter_type i, iter_type e, std::ios_base& is, std::ios_base::iostate& err,
+          time_point<Clock, Duration> &tp, const char_type *pattern, const char_type *pat_end) const
+      {
+        if (std::has_facet<time_point_units<CharT> >(is.getloc()))
+        {
+          time_point_units<CharT> const &facet = std::use_facet<time_point_units<CharT> >(is.getloc());
+          return get(facet, i, e, is, err, tp, pattern, pat_end);
+        }
+        else
+        {
+          time_point_units_default<CharT> facet;
+          return get(facet, i, e, is, err, tp, pattern, pat_end);
+        }
+      }
+
+      template <class Clock, class Duration>
+      iter_type get(time_point_units<CharT> const &facet, iter_type s, iter_type end, std::ios_base& ios,
+          std::ios_base::iostate& err, time_point<Clock, Duration> &tp, const char_type *pattern,
+          const char_type *pat_end) const
+      {
+
+        Duration d;
+        bool duration_found = false, epoch_found = false;
+
+        const std::ctype<char_type>& ct = std::use_facet<std::ctype<char_type> >(ios.getloc());
+        err = std::ios_base::goodbit;
+        while (pattern != pat_end && err == std::ios_base::goodbit)
+        {
+          //std::cerr << __FILE__ << ":" << __LINE__ << " err " << err << std::endl;
+          if (s == end)
+          {
+            err |= std::ios_base::eofbit;
+            break;
+          }
+          if (ct.narrow(*pattern, 0) == '%')
+          {
+            if (++pattern == pat_end)
+            {
+              err |= std::ios_base::failbit;
+              return s;
+            }
+            char cmd = ct.narrow(*pattern, 0);
+            switch (cmd)
+            {
+            case 'd':
+            {
+              if (duration_found)
+              {
+                err |= std::ios_base::failbit;
+                return s;
+              }
+              duration_found = true;
+              s = get_duration(s, end, ios, err, d);
+              //std::cerr << __FILE__ << ":" << __LINE__ << " err " << err << std::endl;
+              if (err & (std::ios_base::badbit | std::ios_base::failbit))
+              {
+                return s;
+              }
+              break;
+            }
+            case 'e':
+            {
+              if (epoch_found)
+              {
+                err |= std::ios_base::failbit;
+                return s;
+              }
+              epoch_found = true;
+              s = get_epoch<Clock> (facet, s, end, ios, err);
+              //std::cerr << __FILE__ << ":" << __LINE__ << " err " << err << std::endl;
+              if (err & (std::ios_base::badbit | std::ios_base::failbit))
+              {
+                return s;
+              }
+              break;
+            }
+            default:
+              BOOST_ASSERT(false && "Boost::Chrono internal error.");
+              break;
+            }
+
+            ++pattern;
+          }
+          else if (ct.is(std::ctype_base::space, *pattern))
+          {
+            for (++pattern; pattern != pat_end && ct.is(std::ctype_base::space, *pattern); ++pattern)
+              ;
+            for (; s != end && ct.is(std::ctype_base::space, *s); ++s)
+              ;
+          }
+          else if (ct.toupper(*s) == ct.toupper(*pattern))
+          {
+            ++s;
+            ++pattern;
+          }
+          else
+          {
+            err |= std::ios_base::failbit;
+          }
+        }
+
+        // Success!  Store it.
+        tp = time_point<Clock, Duration> (d);
+        return s;
+      }
+
+      /**
+       *
+       * @param s an input stream iterator
+       * @param ios a reference to a ios_base
+       * @param d the duration
+       * Stores the duration pattern from the @c duration_unit facet in let say @c str. Last as if
+       * @code
+       *   return get(s, end, ios, err, ios, d, str.data(), str.data() + str.size());
+       * @codeend
+       * @Returns An iterator pointing just beyond the last character that can be determined to be part of a valid name
+       */
+      template <class Clock, class Duration>
+      iter_type get(iter_type i, iter_type e, std::ios_base& is, std::ios_base::iostate& err,
+          time_point<Clock, Duration> &tp) const
+      {
+        if (std::has_facet<time_point_units<CharT> >(is.getloc()))
+        {
+          time_point_units<CharT> const &facet = std::use_facet<time_point_units<CharT> >(is.getloc());
+          std::basic_string<CharT> str = facet.get_pattern();
+          return get(facet, i, e, is, err, tp, str.data(), str.data() + str.size());
+        }
+        else
+        {
+          time_point_units_default<CharT> facet;
+          std::basic_string<CharT> str = facet.get_pattern();
+          return get(facet, i, e, is, err, tp, str.data(), str.data() + str.size());
+        }
+      }
+
+      /**
+       * As if
+       * @code
+       * return facet.get(s, end, ios, err, d);
+       * @endcode
+       * where @c facet is either the @c duration_get facet associated to the @c ios or an instance of the default @c duration_get facet.
+       *
+       * @Returns An iterator pointing just beyond the last character that can be determined to be part of a valid duration.
+       */
+      template <typename Rep, typename Period>
+      iter_type get_duration(iter_type i, iter_type e, std::ios_base& is, std::ios_base::iostate& err,
+          duration<Rep, Period>& d) const
+      {
+        if (std::has_facet<duration_get<CharT> >(is.getloc()))
+        {
+          duration_get<CharT> const &facet = std::use_facet<duration_get<CharT> >(is.getloc());
+          return get_duration(facet, i, e, is, err, d);
+        }
+        else
+        {
+          duration_get<CharT> facet;
+          return get_duration(facet, i, e, is, err, d);
+        }
+      }
+
+      template <typename Rep, typename Period>
+      iter_type get_duration(duration_get<CharT> const& facet, iter_type s, iter_type end, std::ios_base& ios,
+          std::ios_base::iostate& err, duration<Rep, Period>& d) const
+      {
+        return facet.get(s, end, ios, err, d);
+      }
+
+      /**
+       *
+       * @Effects Let @c facet be the @c time_point_units facet associated to @c is or a new instance of the default @c time_point_units_default facet.
+       * Let @c epoch be the epoch string associated to the Clock using this facet.
+       * Scans @c i to match @c epoch or @c e is reached.
+       *
+       * If not match before the @c e is reached @c std::ios_base::failbit is set in @c err.
+       * If @c e is reached @c std::ios_base::failbit is set in @c err.
+       *
+       * @Returns An iterator pointing just beyond the last character that can be determined to be part of a valid epoch.
+       */
+      template <class Clock>
+      iter_type get_epoch(iter_type i, iter_type e, std::ios_base& is, std::ios_base::iostate& err) const
+      {
+        if (std::has_facet<time_point_units<CharT> >(is.getloc()))
+        {
+          time_point_units<CharT> const &facet = std::use_facet<time_point_units<CharT> >(is.getloc());
+          return get_epoch(facet, i, e, is, err);
+        }
+        else
+        {
+          time_point_units_default<CharT> facet;
+          return get_epoch(facet, i, e, is, err);
+        }
+      }
+
+      template <class Clock>
+      iter_type get_epoch(time_point_units<CharT> const &facet, iter_type i, iter_type e, std::ios_base&,
+          std::ios_base::iostate& err) const
+      {
+        const std::basic_string<CharT> epoch = facet.template get_epoch<Clock> ();
+        std::ptrdiff_t k = chrono_detail::scan_keyword(i, e, &epoch, &epoch + 1,
+        //~ std::use_facet<std::ctype<CharT> >(ios.getloc()),
+            err) - &epoch;
+        if (k == 1)
+        {
+          err |= std::ios_base::failbit;
+          return i;
+        }
+        return i;
+      }
+
+      /**
+       * Unique identifier for this type of facet.
+       */
+      static std::locale::id id;
+
+      /**
+       * @Effects Destroy the facet
+       */
+      ~time_point_get()
+      {
+      }
+    };
+
+    /**
+     * Unique identifier for this type of facet.
+     */
+    template <class CharT, class InputIterator>
+    std::locale::id time_point_get<CharT, InputIterator>::id;
+
+  } // chrono
+}
+// boost
+
+#endif  // header

3party/boost/boost/chrono/io/time_point_put.hpp

@@ -0,0 +1,261 @@
+//  (C) Copyright Howard Hinnant
+//  (C) Copyright 2011 Vicente J. Botet Escriba
+//  Use, modification and distribution are 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).
+//
+
+/**
+ * Duration formatting facet for output.
+ */
+#ifndef BOOST_CHRONO_IO_TIME_POINT_PUT_HPP
+#define BOOST_CHRONO_IO_TIME_POINT_PUT_HPP
+
+#include <boost/chrono/config.hpp>
+#include <boost/chrono/io/time_point_units.hpp>
+#include <boost/chrono/io/duration_put.hpp>
+#include <boost/assert.hpp>
+#include <locale>
+
+namespace boost
+{
+  namespace chrono
+  {
+
+    /**
+     * @tparam ChatT a character type
+     * @tparam OutputIterator a model of @c OutputIterator
+     *
+     * The @c time_point_put facet provides facilities for formatted output of @c time_point values.
+     * The member function of @c time_point_put take a @c time_point and format it into character string representation.
+     *
+     */
+    template <class CharT, class OutputIterator = std::ostreambuf_iterator<CharT> >
+    class time_point_put: public std::locale::facet
+    {
+    public:
+      /**
+       * Type of character the facet is instantiated on.
+       */
+      typedef CharT char_type;
+      /**
+       * Type of character string passed to member functions.
+       */
+      typedef std::basic_string<CharT> string_type;
+      /**
+       * Type of iterator used to write in the character buffer.
+       */
+      typedef OutputIterator iter_type;
+
+      /**
+       * Construct a time_point_put facet.
+       * @param refs
+       * @Effects Construct a time_point_put facet.
+       * If the @c refs argument is @c 0 then destruction of the object is
+       * delegated to the @c locale, or locales, containing it. This allows
+       * the user to ignore lifetime management issues. On the other had,
+       * if @c refs is @c 1 then the object must be explicitly deleted;
+       * the @c locale will not do so. In this case, the object can be
+       * maintained across the lifetime of multiple locales.
+       */
+      explicit time_point_put(size_t refs = 0) :
+        std::locale::facet(refs)
+      {
+      }
+
+      /**
+       * @param i an output stream iterator
+       * @param ios a reference to a ios_base
+       * @param fill the character used as filler
+       * @param tp the @c time_point
+       * @param pattern begin of the formatting pattern
+       * @param pat_end end of the formatting pattern
+       *
+       * @Effects Steps through the sequence from @c pattern to @c pat_end,
+       * identifying characters that are part of a pattern sequence. Each character
+       * that is not part of a pattern sequence is written to @c s immediately, and
+       * each pattern sequence, as it is identified, results in a call to
+       * @c put_duration or @c put_epoch;
+       * thus, pattern elements and other characters are interleaved in the output
+       * in the order in which they appear in the pattern. Pattern sequences are
+       * identified by converting each character @c c to a @c char value as if by
+       * @c ct.narrow(c,0), where @c ct is a reference to @c ctype<charT> obtained from
+       * @c ios.getloc(). The first character of each sequence is equal to @c '%',
+       * followed by a pattern specifier character @c spec, which can be @c 'd' for
+       * the duration value or @c 'e' for the epoch.
+       * For each valid pattern sequence identified, calls
+       * <c>put_duration(s, ios, fill, tp.time_since_epoch())</c> or <c>put_epoch(s, ios)</c>.
+       *
+       * @Returns An iterator pointing immediately after the last character produced.
+       */
+
+      template <class Clock, class Duration>
+      iter_type put(iter_type i, std::ios_base& ios, char_type fill, time_point<Clock, Duration> const& tp, const CharT* pattern,
+          const CharT* pat_end) const
+      {
+        if (std::has_facet<time_point_units<CharT> >(ios.getloc()))
+        {
+          time_point_units<CharT> const &facet =
+              std::use_facet<time_point_units<CharT> >(ios.getloc());
+          return put(facet, i, ios, fill, tp, pattern, pat_end);
+        }
+        else
+        {
+          time_point_units_default<CharT> facet;
+          return put(facet, i, ios, fill, tp, pattern, pat_end);
+        }
+      }
+
+      template <class Clock, class Duration>
+      iter_type put(time_point_units<CharT> const& units_facet, iter_type s, std::ios_base& ios, char_type fill,
+          time_point<Clock, Duration> const& tp, const CharT* pattern, const CharT* pat_end) const
+      {
+
+        const std::ctype<char_type>& ct = std::use_facet<std::ctype<char_type> >(ios.getloc());
+        for (; pattern != pat_end; ++pattern)
+        {
+          if (ct.narrow(*pattern, 0) == '%')
+          {
+            if (++pattern == pat_end)
+            {
+              *s++ = pattern[-1];
+              break;
+            }
+            char fmt = ct.narrow(*pattern, 0);
+            switch (fmt)
+            {
+            case 'd':
+            {
+              s = put_duration(s, ios, fill, tp.time_since_epoch());
+              break;
+            }
+            case 'e':
+            {
+              s = put_epoch<Clock> (units_facet, s, ios);
+              break;
+            }
+            default:
+              BOOST_ASSERT(false && "Boost::Chrono internal error.");
+              break;
+            }
+          }
+          else
+            *s++ = *pattern;
+        }
+        return s;
+      }
+
+      /**
+       * @param i an output stream iterator
+       * @param ios a reference to a ios_base
+       * @param fill the character used as filler
+       * @param tp the @c time_point
+       * @param pattern begin of the formatting pattern
+       * @param pat_end end of the formatting pattern
+       *
+       * @Effects Stores the time_point pattern from the @c time_point_unit facet in let say @c str. Last as if
+       * @code
+       *   return put(s, ios, dill, tp, str.data(), str.data() + str.size());
+       * @endcode
+       * @Returns An iterator pointing immediately after the last character produced.
+       */
+      template <class Clock, class Duration>
+      iter_type put(iter_type i, std::ios_base& ios, char_type fill, time_point<Clock, Duration> const& tp) const
+      {
+        if (std::has_facet<time_point_units<CharT> >(ios.getloc()))
+        {
+          time_point_units<CharT> const &facet =
+              std::use_facet<time_point_units<CharT> >(ios.getloc());
+          std::basic_string<CharT> str = facet.get_pattern();
+          return put(facet, i, ios, fill, tp, str.data(), str.data() + str.size());
+        }
+        else
+        {
+          time_point_units_default<CharT> facet;
+          std::basic_string<CharT> str = facet.get_pattern();
+          return put(facet, i, ios, fill, tp, str.data(), str.data() + str.size());
+        }
+      }
+
+      /**
+       * @param i an output stream iterator
+       * @param ios a reference to a ios_base
+       * @param fill the character used as filler
+       * @param d the @c duration
+       * @Effects As if <c>facet.put(s, ios, fill, d)</c> where facet is the @c duration_put<CharT> facet associated
+       * to the @c ios or a new instance of @c duration_put<CharT>.
+       * @Returns An iterator pointing immediately after the last character produced.
+       */
+      template <typename Rep, typename Period>
+      iter_type put_duration(iter_type i, std::ios_base& ios, char_type fill, duration<Rep, Period> const& d) const
+      {
+        if (std::has_facet<duration_put<CharT> >(ios.getloc()))
+        {
+          duration_put<CharT> const &facet = std::use_facet<duration_put<CharT> >(ios.getloc());
+          return facet.put(i, ios, fill, d);
+        }
+        else
+        {
+          duration_put<CharT> facet;
+          return facet.put(i, ios, fill, d);
+        }
+      }
+
+      /**
+       *
+       * @param i an output stream iterator
+       * @param ios a reference to a ios_base
+       * @Effects As if
+       * @code
+       * string_type str = facet.template get_epoch<Clock>();
+       * s=std::copy(str.begin(), str.end(), s);
+       * @endcode
+       * where facet is the @c time_point_units<CharT> facet associated
+       * to the @c ios or a new instance of @c time_point_units_default<CharT>.
+       * @Returns s, iterator pointing immediately after the last character produced.
+       */
+
+      template <typename Clock>
+      iter_type put_epoch(iter_type i, std::ios_base& os) const
+      {
+        if (std::has_facet<time_point_units<CharT> >(os.getloc()))
+        {
+          time_point_units<CharT> const &facet = std::use_facet<time_point_units<CharT> >(os.getloc());
+          return put_epoch<Clock> (facet, i, os);
+        }
+        else
+        {
+          time_point_units_default<CharT> facet;
+          return put_epoch<Clock> (facet, i, os);
+        }
+      }
+
+      template <typename Clock>
+      iter_type put_epoch(time_point_units<CharT> const& facet, iter_type s, std::ios_base&) const
+      {
+        string_type str = facet.template get_epoch<Clock>();
+        s= std::copy(str.begin(), str.end(), s);
+        return s;
+      }
+
+      /**
+       * Unique identifier for this type of facet.
+       */
+      static std::locale::id id;
+
+      /**
+       * @Effects Destroy the facet
+       */
+      ~time_point_put()
+      {
+      }
+
+    };
+
+    template <class CharT, class OutputIterator>
+    std::locale::id time_point_put<CharT, OutputIterator>::id;
+
+  } // chrono
+} // boost
+
+#endif  // header

3party/boost/boost/chrono/io/time_point_units.hpp

@@ -0,0 +1,244 @@
+//  (C) Copyright Howard Hinnant
+//  (C) Copyright 2011 Vicente J. Botet Escriba
+//  Use, modification and distribution are 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).
+//
+
+#ifndef BOOST_CHRONO_IO_TIME_POINT_UNITS_HPP
+#define BOOST_CHRONO_IO_TIME_POINT_UNITS_HPP
+
+#include <boost/chrono/config.hpp>
+#include <boost/chrono/process_cpu_clocks.hpp>
+#include <boost/chrono/system_clocks.hpp>
+#include <boost/chrono/thread_clock.hpp>
+#include <boost/chrono/io/ios_base_state.hpp>
+#include <string>
+#include <iostream>
+#include <ios>
+#include <locale>
+#include <algorithm>
+
+namespace boost
+{
+  namespace chrono
+  {
+
+    /**
+     * @c time_point_units facet gives useful information about the time_point pattern,
+     * the text associated to a time_point's epoch,
+     */
+    template <typename CharT=char>
+    class time_point_units: public std::locale::facet
+    {
+    public:
+      /**
+       * Type of character the facet is instantiated on.
+       */
+      typedef CharT char_type;
+      /**
+       * Type of character string used by member functions.
+       */
+      typedef std::basic_string<char_type> string_type;
+
+      /**
+       * Unique identifier for this type of facet.
+       */
+      static std::locale::id id;
+
+      /**
+       * Construct a @c time_point_units facet.
+       * @param refs
+       * @Effects Construct a @c time_point_units facet.
+       * If the @c refs argument is @c 0 then destruction of the object is
+       * delegated to the @c locale, or locales, containing it. This allows
+       * the user to ignore lifetime management issues. On the other had,
+       * if @c refs is @c 1 then the object must be explicitly deleted;
+       * the @c locale will not do so. In this case, the object can be
+       * maintained across the lifetime of multiple locales.
+       */
+      explicit time_point_units(size_t refs = 0) :
+        std::locale::facet(refs)
+      {
+      }
+
+      /**
+       * @return the pattern to be used by default.
+       */
+      virtual string_type get_pattern() const =0;
+
+      /**
+       * @return the epoch associated to the clock @c Clock calling @c do_get_epoch(Clock())
+       */
+      template <typename Clock>
+      string_type get_epoch() const
+      {
+        return do_get_epoch(Clock());
+      }
+
+    protected:
+      /**
+       * Destroy the facet.
+       */
+      virtual ~time_point_units() {}
+
+
+      /**
+       *
+       * @param c a dummy instance of @c system_clock.
+       * @return The epoch string associated to the @c system_clock.
+       */
+      virtual string_type do_get_epoch(system_clock) const=0;
+
+      /**
+       *
+       * @param c a dummy instance of @c steady_clock.
+       * @return The epoch string associated to the @c steady_clock.
+       */
+      virtual string_type do_get_epoch(steady_clock) const=0;
+
+#if defined(BOOST_CHRONO_HAS_PROCESS_CLOCKS)
+      /**
+       *
+       * @param c a dummy instance of @c process_real_cpu_clock.
+       * @return The epoch string associated to the @c process_real_cpu_clock.
+       */
+      virtual string_type do_get_epoch(process_real_cpu_clock) const=0;
+      /**
+       *
+       * @param c a dummy instance of @c process_user_cpu_clock.
+       * @return The epoch string associated to the @c process_user_cpu_clock.
+       */
+      virtual string_type do_get_epoch(process_user_cpu_clock) const=0;
+      /**
+       *
+       * @param c a dummy instance of @c process_system_cpu_clock.
+       * @return The epoch string associated to the @c process_system_cpu_clock.
+       */
+      virtual string_type do_get_epoch(process_system_cpu_clock) const=0;
+      /**
+       *
+       * @param c a dummy instance of @c process_cpu_clock.
+       * @return The epoch string associated to the @c process_cpu_clock.
+       */
+      virtual string_type do_get_epoch(process_cpu_clock) const=0;
+#endif
+#if defined(BOOST_CHRONO_HAS_THREAD_CLOCK)
+      /**
+       *
+       * @param c a dummy instance of @c thread_clock.
+       * @return The epoch string associated to the @c thread_clock.
+       */
+      virtual string_type do_get_epoch(thread_clock) const=0;
+#endif
+
+    };
+
+    template <typename CharT>
+    std::locale::id time_point_units<CharT>::id;
+
+
+    // This class is used to define the strings for the default English
+    template <typename CharT=char>
+    class time_point_units_default: public time_point_units<CharT>
+    {
+    public:
+      /**
+       * Type of character the facet is instantiated on.
+       */
+      typedef CharT char_type;
+      /**
+       * Type of character string returned by member functions.
+       */
+      typedef std::basic_string<char_type> string_type;
+
+      explicit time_point_units_default(size_t refs = 0) :
+        time_point_units<CharT> (refs)
+      {
+      }
+      ~time_point_units_default() {}
+
+      /**
+       * @return the default pattern "%d%e".
+       */
+      string_type get_pattern() const
+      {
+        static const CharT t[] =
+        { '%', 'd', '%', 'e' };
+        static const string_type pattern(t, t + sizeof (t) / sizeof (t[0]));
+
+        return pattern;
+      }
+
+    protected:
+      /**
+       * @param c a dummy instance of @c system_clock.
+       * @return The epoch string returned by @c clock_string<system_clock,CharT>::since().
+       */
+      string_type do_get_epoch(system_clock ) const
+      {
+        return clock_string<system_clock,CharT>::since();
+      }
+      /**
+       * @param c a dummy instance of @c steady_clock.
+       * @return The epoch string returned by @c clock_string<steady_clock,CharT>::since().
+       */
+      string_type do_get_epoch(steady_clock ) const
+      {
+        return clock_string<steady_clock,CharT>::since();
+      }
+
+#if defined(BOOST_CHRONO_HAS_PROCESS_CLOCKS)
+      /**
+       * @param c a dummy instance of @c process_real_cpu_clock.
+       * @return The epoch string returned by @c clock_string<process_real_cpu_clock,CharT>::since().
+       */
+      string_type do_get_epoch(process_real_cpu_clock ) const
+      {
+        return clock_string<process_real_cpu_clock,CharT>::since();
+      }
+      /**
+       * @param c a dummy instance of @c process_user_cpu_clock.
+       * @return The epoch string returned by @c clock_string<process_user_cpu_clock,CharT>::since().
+       */
+      string_type do_get_epoch(process_user_cpu_clock ) const
+      {
+        return clock_string<process_user_cpu_clock,CharT>::since();
+      }
+      /**
+       * @param c a dummy instance of @c process_system_cpu_clock.
+       * @return The epoch string returned by @c clock_string<process_system_cpu_clock,CharT>::since().
+       */
+      string_type do_get_epoch(process_system_cpu_clock ) const
+      {
+        return clock_string<process_system_cpu_clock,CharT>::since();
+      }
+      /**
+       * @param c a dummy instance of @c process_cpu_clock.
+       * @return The epoch string returned by @c clock_string<process_cpu_clock,CharT>::since().
+       */
+      string_type do_get_epoch(process_cpu_clock ) const
+      {
+        return clock_string<process_cpu_clock,CharT>::since();
+      }
+
+#endif
+#if defined(BOOST_CHRONO_HAS_THREAD_CLOCK)
+      /**
+       * @param c a dummy instance of @c thread_clock.
+       * @return The epoch string returned by @c clock_string<thread_clock,CharT>::since().
+       */
+      string_type do_get_epoch(thread_clock ) const
+      {
+        return clock_string<thread_clock,CharT>::since();
+      }
+#endif
+
+    };
+
+
+  } // chrono
+
+} // boost
+
+#endif  // header

3party/boost/boost/chrono/io/timezone.hpp

@@ -0,0 +1,30 @@
+//  (C) Copyright Howard Hinnant
+//  (C) Copyright 2010-2011 Vicente J. Botet Escriba
+//  Use, modification and distribution are 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).
+//
+// This code was adapted by Vicente from Howard Hinnant's experimental work
+// on chrono i/o to Boost
+
+#ifndef BOOST_CHRONO_IO_TIMEZONE_HPP
+#define BOOST_CHRONO_IO_TIMEZONE_HPP
+#include <boost/detail/scoped_enum_emulation.hpp>
+
+namespace boost
+{
+  namespace chrono
+  {
+    /**
+     * Scoped enumeration emulation stating whether the time_point for system_clock I/O is UTC or local.
+     */
+    BOOST_SCOPED_ENUM_DECLARE_BEGIN(timezone)
+          {
+            utc, local
+          }
+    BOOST_SCOPED_ENUM_DECLARE_END(timezone)
+
+  } // chrono
+} // boost
+
+#endif  // header

3party/boost/boost/chrono/io/utility/ios_base_state_ptr.hpp

@@ -0,0 +1,436 @@
+//  boost/chrono/utility/ios_base_pword_ptr.hpp  ------------------------------------------------------------//
+
+//  Copyright 2011 Vicente J. Botet Escriba
+
+//  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/chrono for documentation.
+
+#ifndef BOOST_CHRONO_UTILITY_IOS_BASE_STATE_PTR_HPP
+#define BOOST_CHRONO_UTILITY_IOS_BASE_STATE_PTR_HPP
+
+#include <ios>
+#include <boost/assert.hpp>
+
+/**
+ *
+
+
+ */
+namespace boost
+{
+  namespace chrono
+  {
+    namespace detail
+    {
+
+      /**
+       * xalloc key holder.
+       */
+      template <typename T>
+      struct xalloc_key_holder
+      {
+        static int value; //< the xalloc value associated to T.
+        static bool initialized; //< whether the value has been initialized or not.
+      };
+
+      template <typename T>
+      int xalloc_key_holder<T>::value = 0;
+
+      template <typename T>
+      bool xalloc_key_holder<T>::initialized = false;
+
+    }
+
+    /**
+     * xalloc key initialiazer.
+     *
+     * Declare a static variable of this type to ensure that the xalloc_key_holder<T> is initialized correctly.
+     */
+    template <typename T>
+    struct xalloc_key_initializer
+    {
+      xalloc_key_initializer()
+      {
+        std::cout << __FILE__ << ":" << __LINE__ << std::endl;
+        if (!detail::xalloc_key_holder<T>::initialized)
+        {
+          detail::xalloc_key_holder<T>::value = std::ios_base::xalloc();
+          detail::xalloc_key_holder<T>::initialized = true;
+          std::cout << __FILE__ << ":" << __LINE__ << " " << detail::xalloc_key_holder<T>::value <<std::endl;
+        }
+      }
+    };
+    /**
+     * @c ios_state_ptr is a smart pointer to a ios_base specific state.
+     */
+    template <typename Final, typename T>
+    class ios_state_ptr
+    {
+    public:
+      /**
+       * The pointee type
+       */
+      typedef T element_type;
+      /**
+       * Explicit constructor.
+       * @param ios the ios
+       * @Effects Constructs a @c ios_state_ptr by storing the associated @c ios.
+       */
+      explicit ios_state_ptr(std::ios_base& ios) :
+        ios_(ios)
+      {
+        std::cout << __FILE__ << ":" << __LINE__ << std::endl;
+
+      }
+      /**
+       * Nothing to do as xalloc index can not be removed.
+       */
+      ~ios_state_ptr()
+      {
+      }
+
+      /**
+       * @Effects Allocates the index if not already done.
+       * Registers the callback responsible of maintaining the state pointer coherency, if not already done.
+       * Retrieves the associated ios pointer
+       * @return the retrieved pointer statically casted to const.
+       */
+      T const* get() const BOOST_NOEXCEPT
+      {
+        register_once(index(), ios_);
+        void* &pw = ios_.pword(index());
+        if (pw == 0)
+        {
+          return 0;
+        }
+        return static_cast<const T*> (pw);
+      }
+      /**
+       * @Effects Allocates the index if not already done.
+       * Registers the callback responsible of maintaining the state pointer coherency, if not already done.
+       * Retrieves the associated ios pointer
+       * @return the retrieved pointer.
+       */
+      T * get() BOOST_NOEXCEPT
+      {
+        register_once(index(), ios_);
+        void* &pw = ios_.pword(index());
+        if (pw == 0)
+        {
+          return 0;
+        }
+        return static_cast<T*> (pw);
+      }
+      /**
+       * @Effects as if @c return get();
+       * @return the retrieved pointer.
+       */
+      T * operator->()BOOST_NOEXCEPT
+      {
+        return get();
+      }
+      /**
+       * @Effects as if @c return get();
+       * @return the retrieved pointer.
+       */
+      T const * operator->() const BOOST_NOEXCEPT
+      {
+        return get();
+      }
+
+      /**
+       * @Effects as if @c return *get();
+       * @return a reference to the retrieved state.
+       * @Remark The behavior is undefined if @c get()==0.
+       */
+      T & operator*() BOOST_NOEXCEPT
+      {
+        return *get();
+      }
+      /**
+       * @Effects as if @c return *get();
+       * @return a reference to the retrieved state.
+       * @Remark The behavior is undefined if @c get()==0.
+       */
+      T const & operator *() const BOOST_NOEXCEPT
+      {
+        return *get();
+      }
+
+      /**
+       * @Effects reset the current pointer after storing in a temporary variable the pointer to the current state.
+       * @return the stored state pointer.
+       */
+      T * release() BOOST_NOEXCEPT
+      {
+        T const* f = get();
+        reset();
+        return f;
+      }
+
+      /**
+       *
+       * @param new_ptr the new pointer.
+       * @Effects deletes the current state and replace it with the new one.
+       */
+      void reset(T* new_ptr = 0)BOOST_NOEXCEPT
+      {
+        register_once(index(), ios_);
+        void*& pw = ios_.pword(index());
+        delete static_cast<T*> (pw);
+        pw = new_ptr;
+      }
+
+#if defined(BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS)
+        typedef T* (ios_state_ptr::*bool_type)();
+        operator bool_type() const BOOST_NOEXCEPT
+        {
+            return (get()!=0)?&ios_state_ptr::release:0;
+        }
+        bool operator!() const BOOST_NOEXCEPT
+        {
+          return (get()==0)?&ios_state_ptr::release:0;
+        }
+#else
+        /**
+         * Explicit conversion to bool.
+         */
+        explicit operator bool() const BOOST_NOEXCEPT
+        {
+          return get()!=0;
+        }
+#endif
+
+      std::ios_base& getios()BOOST_NOEXCEPT
+      {
+        return ios_;
+      }
+      std::ios_base& getios() const BOOST_NOEXCEPT
+      {
+        return ios_;
+      }
+      /**
+       * Implicit conversion to the ios_base
+       */
+      operator std::ios_base&() BOOST_NOEXCEPT
+      {
+        return ios_;
+      }
+      /**
+       * Implicit conversion to the ios_base const
+       */
+      operator std::ios_base&() const BOOST_NOEXCEPT
+      {
+        return ios_;
+      }
+    private:
+      static inline bool is_registerd(std::ios_base& ios)
+      {
+        long iw = ios.iword(index());
+        return (iw == 1);
+      }
+      static inline void set_registered(std::ios_base& ios)
+      {
+        long& iw = ios.iword(index());
+        iw = 1;
+      }
+      static inline void callback(std::ios_base::event evt, std::ios_base& ios, int index)
+      {
+        switch (evt)
+        {
+        case std::ios_base::erase_event:
+        {
+          void*& pw = ios.pword(index);
+          if (pw != 0)
+          {
+            T* ptr = static_cast<T*> (pw);
+            delete ptr;
+            pw = 0;
+          }
+          break;
+        }
+        case std::ios_base::copyfmt_event:
+        {
+          void*& pw = ios.pword(index);
+          if (pw != 0)
+          {
+            pw = new T(*static_cast<T*> (pw));
+          }
+          break;
+        }
+        default:
+          break;
+        }
+      }
+
+      static inline int index()
+      {
+        return detail::xalloc_key_holder<Final>::value;
+      }
+
+      static inline void register_once(int indx, std::ios_base& ios)
+      {
+        // needs a mask registered
+        if (!is_registerd(ios))
+        {
+          set_registered(ios);
+          ios.register_callback(callback, indx);
+        }
+      }
+
+    protected:
+      std::ios_base& ios_;
+      //static detail::xalloc_key_initializer<Final> xalloc_key_initializer_;
+
+    };
+    //template <typename Final, typename T>
+    //detail::xalloc_key_initializer<Final> ios_state_ptr<Final,T>::xalloc_key_initializer_;
+
+
+    /**
+     * @c ios_state_not_null_ptr is a non null variant of @c ios_state_ptr.
+     * @tparm T
+     * @Requires @c T must be @c DefaultConstructible and @c HeapAllocatable
+     */
+    template <typename Final, typename T>
+    class ios_state_not_null_ptr: public ios_state_ptr<Final, T>
+    {
+      typedef ios_state_ptr<Final, T> base_type;
+    public:
+      explicit ios_state_not_null_ptr(std::ios_base& ios) :
+      base_type(ios)
+      {
+        if (this->get() == 0)
+        {
+          this->base_type::reset(new T());
+        }
+      }
+      ~ios_state_not_null_ptr()
+      {
+      }
+
+      void reset(T* new_value) BOOST_NOEXCEPT
+      {
+        BOOST_ASSERT(new_value!=0);
+        this->base_type::reset(new_value);
+      }
+
+    };
+
+    /**
+     * This class is useful to associate some flags to an std::ios_base.
+     */
+    template <typename Final>
+    class ios_flags
+    {
+    public:
+      /**
+       *
+       * @param ios the associated std::ios_base.
+       * @Postcondition <c>flags()==0</c>
+       */
+      explicit ios_flags(std::ios_base& ios) :
+        ios_(ios)
+      {
+      }
+      ~ios_flags()
+      {
+      }
+
+      /**
+       * @Returns The format control information.
+       */
+      long flags() const BOOST_NOEXCEPT
+      {
+        return value();
+      }
+
+      /**
+       * @param v the new bit mask.
+       * @Postcondition <c>v == flags()</c>.
+       * @Returns The previous value of @c flags().
+       */
+      long flags(long v)BOOST_NOEXCEPT
+      {
+        long tmp = flags();
+        ref() = v;
+        return tmp;
+      }
+
+      /**
+       * @param v the new value
+       * @Effects: Sets @c v in @c flags().
+       * @Returns: The previous value of @c flags().
+       */
+      long setf(long v)
+      {
+        long tmp = value();
+        ref() |= v;
+        return tmp;
+      }
+
+      /**
+       * @param mask the bit mask to clear.
+       * @Effects: Clears @c mask in @c flags().
+       */
+      void unsetf(long mask)
+      {
+        ref() &= ~mask;
+      }
+
+      /**
+       *
+       * @param v
+       * @param mask
+       * @Effects: Clears @c mask in @c flags(), sets <c>v & mask</c> in @c flags().
+       * @Returns: The previous value of flags().
+       */
+      long setf(long v, long mask)
+      {
+        long tmp = value();
+        unsetf(mask);
+        ref() |= v & mask;
+        return tmp;
+      }
+
+      /**
+       * implicit conversion to the @c ios_base
+       */
+      operator std::ios_base&()BOOST_NOEXCEPT
+      {
+        return ios_;
+      }
+      /**
+       * implicit conversion to the @c ios_base const
+       */
+      operator std::ios_base const&() const BOOST_NOEXCEPT
+      {
+        return ios_;
+      }
+    private:
+      long value() const BOOST_NOEXCEPT
+      {
+        return ios_.iword(index());
+      }
+      long& ref()BOOST_NOEXCEPT
+      {
+        return ios_.iword(index());
+      }
+      static inline int index()
+      {
+        return detail::xalloc_key_holder<Final>::value;
+      }
+
+      std::ios_base& ios_;
+      //static detail::xalloc_key_initializer<Final> xalloc_key_initializer_;
+
+    };
+    //template <typename Final>
+    //detail::xalloc_key_initializer<Final> ios_flags<Final>::xalloc_key_initializer_;
+
+  } // namespace chrono
+} // namespace boost
+
+#endif // header

3party/boost/boost/chrono/io/utility/manip_base.hpp

@@ -0,0 +1,101 @@
+//  boost/chrono/utility/manip_base.hpp  ------------------------------------------------------------//
+
+//  Copyright 2011 Vicente J. Botet Escriba
+
+//  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/chrono for documentation.
+
+#ifndef BOOST_CHRONO_UTILITY_MANIP_BASE_PTR_HPP
+#define BOOST_CHRONO_UTILITY_MANIP_BASE_PTR_HPP
+
+#include <ios>
+
+/**
+ *
+
+ */
+
+namespace boost
+{
+  namespace chrono
+  {
+
+    /**
+     * manip is a manipulator mixin class following the CRTP.
+     * @tparam Final the derived from manip and final type
+     *
+     * @Example
+     * @code
+
+    class mendl: public manip<mendl>
+    {
+    public:
+      explicit mendl(size_t how_many) :
+        count(how_many) {}
+      template <typename out_stream>
+      void operator()(out_stream &out) const
+      {
+        for (size_t line = 0; line < count; ++line)
+        {
+          out.put(out.widen('\n'));
+        }
+        out.flush();
+      }
+    private:
+      size_t count;
+    };
+
+     * @codeend
+     */
+    template <typename Final>
+    class manip
+    {
+    public:
+      /**
+       *
+       * @param ios the io stream or ios_base.
+       * @Effects calls to the manipulator final functor.
+       */
+      //template <typename out_stream>
+      void operator()(std::ios_base &ios) const
+      {
+        (*static_cast<const Final *> (this))(ios);
+      }
+    };
+
+    /**
+     * @c manip stream inserter
+     * @param out the io stream or ios_base.
+     * @param op the manipulator instance.
+     * @Effects if @c out is good calls to the manipulator functor @op.
+     * @return @c out
+     */
+    template <typename out_stream, typename manip_type>
+    out_stream &operator<<(out_stream &out, const manip<manip_type> &op)
+    {
+      if (out.good())
+        op(out);
+      return out;
+    }
+
+    /**
+     * @c manip stream extractor
+     * @param in the io stream or ios_base.
+     * @param op  the manipulator instance.
+     * @Effects if @c in is good calls to the manipulator functor @op.
+     * @return @c in
+     */
+    template <typename in_stream, typename manip_type>
+    in_stream &operator>>(in_stream &in, const manip<manip_type> &op)
+    {
+      if (in.good())
+        op(in);
+      return in;
+    }
+
+  } // namespace chrono
+} // namespace boost
+
+#endif // header

3party/boost/boost/chrono/io/utility/to_string.hpp

@@ -0,0 +1,50 @@
+//  boost/chrono/utility/to_string.hpp
+//
+//  Copyright 2011 Vicente J. Botet Escriba
+//  Use, modification and distribution are 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).
+
+#ifndef BOOST_CHRONO_UTILITY_TO_STRING_HPP
+#define BOOST_CHRONO_UTILITY_TO_STRING_HPP
+
+#include <boost/chrono/config.hpp>
+#include <string>
+#include <sstream>
+
+namespace boost
+{
+  namespace chrono
+  {
+    template <typename CharT, typename T>
+    std::basic_string<CharT> to_basic_string(T const&v) {
+      std::basic_stringstream<CharT> sstr;
+      sstr << v;
+      return sstr.str();
+    }
+
+    template <typename T>
+    std::string to_string(T const&v) {
+      return to_basic_string<char>(v);
+    }
+#ifndef BOOST_NO_STD_WSTRING
+    template <typename T>
+    std::wstring to_wstring(T const&v) {
+      return to_basic_string<wchar_t>(v);
+    }
+#endif
+#if BOOST_CHRONO_HAS_UNICODE_SUPPORT
+    template <typename T>
+    std::basic_string<char16_t> to_u16string(T const&v) {
+      return to_basic_string<char16_t>(v);
+    }
+    template <typename T>
+    std::basic_string<char32_t> to_u32string(T const&v) {
+      return to_basic_string<char32_t>(v);
+    }
+#endif
+  } // chrono
+
+} // boost
+
+#endif  // header

3party/boost/boost/chrono/io_v1/chrono_io.hpp

@@ -265,59 +265,59 @@ template <class CharT, class Traits, class Rep, class Period>
 std::basic_istream<CharT, Traits>&
 operator>>(std::basic_istream<CharT, Traits>& is, duration<Rep, Period>& d)
 {
-  std::cerr << __FILE__ << "[" << __LINE__ << "]"<< std::endl;
+  //std::cerr << __FILE__ << "[" << __LINE__ << "]"<< std::endl;
     typedef duration_punct<CharT> Facet;
     std::locale loc = is.getloc();
-    std::cerr << __FILE__ << "[" << __LINE__ << "]"<< std::endl;
+    //std::cerr << __FILE__ << "[" << __LINE__ << "]"<< std::endl;
     if (!std::has_facet<Facet>(loc)) {
-      std::cerr << __FILE__ << "[" << __LINE__ << "]"<< std::endl;
+      //std::cerr << __FILE__ << "[" << __LINE__ << "]"<< std::endl;
         is.imbue(std::locale(loc, new Facet));
     }
-    std::cerr << __FILE__ << "[" << __LINE__ << "]"<< std::endl;
+    //std::cerr << __FILE__ << "[" << __LINE__ << "]"<< std::endl;
     loc = is.getloc();
     const Facet& f = std::use_facet<Facet>(loc);
     typedef typename chrono_detail::duration_io_intermediate<Rep>::type intermediate_type;
     intermediate_type r;
     std::ios_base::iostate err = std::ios_base::goodbit;
     // read value into r
-    std::cerr << __FILE__ << "[" << __LINE__ << "]"<< std::endl;
+    //std::cerr << __FILE__ << "[" << __LINE__ << "]"<< std::endl;
     is >> r;
-    std::cerr << __FILE__ << "[" << __LINE__ << "]"<< std::endl;
+    //std::cerr << __FILE__ << "[" << __LINE__ << "]"<< std::endl;
     if (is.good())
     {
-      std::cerr << __FILE__ << "[" << __LINE__ << "]"<< std::endl;
+      //std::cerr << __FILE__ << "[" << __LINE__ << "]"<< std::endl;
         // now determine unit
         typedef std::istreambuf_iterator<CharT, Traits> in_iterator;
         in_iterator i(is);
         in_iterator e;
-        std::cerr << __FILE__ << "[" << __LINE__ << "]"<< std::endl;
+        //std::cerr << __FILE__ << "[" << __LINE__ << "]"<< std::endl;
         if (i != e && *i == ' ')  // mandatory ' ' after value
         {
-          std::cerr << __FILE__ << "[" << __LINE__ << "]"<< std::endl;
+          //std::cerr << __FILE__ << "[" << __LINE__ << "]"<< std::endl;
             ++i;
             if (i != e)
             {
-              std::cerr << __FILE__ << "[" << __LINE__ << "]"<< std::endl;
+              //std::cerr << __FILE__ << "[" << __LINE__ << "]"<< std::endl;
                 // unit is num / den (yet to be determined)
                 unsigned long long num = 0;
                 unsigned long long den = 0;
                 if (*i == '[')
                 {
-                  std::cerr << __FILE__ << "[" << __LINE__ << "]"<< std::endl;
+                  //std::cerr << __FILE__ << "[" << __LINE__ << "]"<< std::endl;
                     // parse [N/D]s or [N/D]seconds format
                     ++i;
                     CharT x;
                     is >> num >> x >> den;
                     if (!is.good() || (x != '/'))
                     {
-                      std::cerr << __FILE__ << "[" << __LINE__ << "]"<< std::endl;
+                      //std::cerr << __FILE__ << "[" << __LINE__ << "]"<< std::endl;
                         is.setstate(is.failbit);
                         return is;
                     }
                     i = in_iterator(is);
                     if (*i != ']')
                     {
-                      std::cerr << __FILE__ << "[" << __LINE__ << "]"<< std::endl;
+                      //std::cerr << __FILE__ << "[" << __LINE__ << "]"<< std::endl;
                         is.setstate(is.failbit);
                         return is;
                     }
@@ -328,27 +328,27 @@ operator>>(std::basic_istream<CharT, Traits>& is, duration<Rep, Period>& d)
                         f.template plural<ratio<1> >(),
                         f.template short_name<ratio<1> >()
                     };
-                    std::cerr << __FILE__ << "[" << __LINE__ << "]"<< std::endl;
+                    //std::cerr << __FILE__ << "[" << __LINE__ << "]"<< std::endl;
                     const std::basic_string<CharT>* k = chrono_detail::scan_keyword(i, e,
                                   units, units + sizeof(units)/sizeof(units[0]),
                                   //~ std::use_facet<std::ctype<CharT> >(loc),
                                   err);
-                    std::cerr << __FILE__ << "[" << __LINE__ << "]"<< std::endl;
+                    //std::cerr << __FILE__ << "[" << __LINE__ << "]"<< std::endl;
                     is.setstate(err);
                     switch ((k - units) / 3)
                     {
                     case 0:
-                      std::cerr << __FILE__ << "[" << __LINE__ << "]"<< std::endl;
+                      //std::cerr << __FILE__ << "[" << __LINE__ << "]"<< std::endl;
                         break;
                     default:
                         is.setstate(err);
-                        std::cerr << __FILE__ << "[" << __LINE__ << "]"<< std::endl;
+                        //std::cerr << __FILE__ << "[" << __LINE__ << "]"<< std::endl;
                         return is;
                     }
                 }
                 else
                 {
-                  std::cerr << __FILE__ << "[" << __LINE__ << "]"<< std::endl;
+                  //std::cerr << __FILE__ << "[" << __LINE__ << "]"<< std::endl;
                     // parse SI name, short or long
                     const std::basic_string<CharT> units[] =
                     {
@@ -410,12 +410,12 @@ operator>>(std::basic_istream<CharT, Traits>& is, duration<Rep, Period>& d)
                         f.template plural<ratio<3600> >(),
                         f.template short_name<ratio<3600> >()
                     };
-                    std::cerr << __FILE__ << "[" << __LINE__ << "]"<< std::endl;
+                    //std::cerr << __FILE__ << "[" << __LINE__ << "]"<< std::endl;
                     const std::basic_string<CharT>* k = chrono_detail::scan_keyword(i, e,
                                   units, units + sizeof(units)/sizeof(units[0]),
                                   //~ std::use_facet<std::ctype<CharT> >(loc),
                                   err);
-                    std::cerr << __FILE__ << "[" << __LINE__ << "]"<< std::endl;
+                    //std::cerr << __FILE__ << "[" << __LINE__ << "]"<< std::endl;
                     switch ((k - units) / 3)
                     {
                     case 0:
@@ -495,12 +495,12 @@ operator>>(std::basic_istream<CharT, Traits>& is, duration<Rep, Period>& d)
                         den = 1;
                         break;
                     default:
-                      std::cerr << __FILE__ << "[" << __LINE__ << "]"<< std::endl;
+                      //std::cerr << __FILE__ << "[" << __LINE__ << "]"<< std::endl;
                         is.setstate(err|is.failbit);
                         return is;
                     }
                 }
-                std::cerr << __FILE__ << "[" << __LINE__ << "]"<< std::endl;
+                //std::cerr << __FILE__ << "[" << __LINE__ << "]"<< std::endl;
                 // unit is num/den
                 // r should be multiplied by (num/den) / Period
                 // Reduce (num/den) / Period to lowest terms
@@ -513,7 +513,7 @@ operator>>(std::basic_istream<CharT, Traits>& is, duration<Rep, Period>& d)
                 if (num > (std::numeric_limits<unsigned long long>::max)() / d2 ||
                     den > (std::numeric_limits<unsigned long long>::max)() / n2)
                 {
-                  std::cerr << __FILE__ << "[" << __LINE__ << "]"<< std::endl;
+                  //std::cerr << __FILE__ << "[" << __LINE__ << "]"<< std::endl;
                     // (num/den) / Period overflows
                     is.setstate(err|is.failbit);
                     return is;
@@ -523,68 +523,68 @@ operator>>(std::basic_istream<CharT, Traits>& is, duration<Rep, Period>& d)
 
                 typedef typename common_type<intermediate_type, unsigned long long>::type common_type_t;
 
-                std::cerr << __FILE__ << "[" << __LINE__ << "]"<< std::endl;
+                //std::cerr << __FILE__ << "[" << __LINE__ << "]"<< std::endl;
                 // num / den is now factor to multiply by r
                 if (!chrono_detail::reduce(r, den, err))
                 {
-                  std::cerr << __FILE__ << "[" << __LINE__ << "]"<< std::endl;
+                  //std::cerr << __FILE__ << "[" << __LINE__ << "]"<< std::endl;
                   is.setstate(err|is.failbit);
                   return is;
                 }
 
                 //if (r > ((duration_values<common_type_t>::max)() / num))
-                std::cerr << __FILE__ << "[" << __LINE__ << "]"<< std::endl;
+                //std::cerr << __FILE__ << "[" << __LINE__ << "]"<< std::endl;
                 if (chrono::detail::gt(r,((duration_values<common_type_t>::max)() / num)))
                 {
                     // Conversion to Period overflowed
-                  std::cerr << __FILE__ << "[" << __LINE__ << "]"<< std::endl;
+                  //std::cerr << __FILE__ << "[" << __LINE__ << "]"<< std::endl;
                     is.setstate(err|is.failbit);
                     return is;
                 }
-                std::cerr << __FILE__ << "[" << __LINE__ << "]"<< std::endl;
+                //std::cerr << __FILE__ << "[" << __LINE__ << "]"<< std::endl;
                 common_type_t t = r * num;
                 t /= den;
-                std::cerr << __FILE__ << "[" << __LINE__ << "]"<< std::endl;
+                //std::cerr << __FILE__ << "[" << __LINE__ << "]"<< std::endl;
 
                 if (t > 0)
                 {
-                  std::cerr << __FILE__ << "[" << __LINE__ << "]"<< std::endl;
+                  //std::cerr << __FILE__ << "[" << __LINE__ << "]"<< std::endl;
                   Rep pt = t;
                   if ( (duration_values<Rep>::max)() < pt)
                   {
-                    std::cerr << __FILE__ << "[" << __LINE__ << "]"<< std::endl;
+                    //std::cerr << __FILE__ << "[" << __LINE__ << "]"<< std::endl;
                     // Conversion to Period overflowed
                     is.setstate(err|is.failbit);
                     return is;
                   }
                 }
-                std::cerr << __FILE__ << "[" << __LINE__ << "]"<< std::endl;
+                //std::cerr << __FILE__ << "[" << __LINE__ << "]"<< std::endl;
                 // Success!  Store it.
                 r = Rep(t);
                 d = duration<Rep, Period>(r);
                 is.setstate(err);
-                std::cerr << __FILE__ << "[" << __LINE__ << "]"<< std::endl;
+                //std::cerr << __FILE__ << "[" << __LINE__ << "]"<< std::endl;
                 return is;
             }
             else {
-              std::cerr << __FILE__ << "[" << __LINE__ << "]"<< std::endl;
+              //std::cerr << __FILE__ << "[" << __LINE__ << "]"<< std::endl;
                 is.setstate(is.failbit | is.eofbit);
                 return is;
             }
         }
         else
         {
-          std::cerr << __FILE__ << "[" << __LINE__ << "]"<< std::endl;
+          //std::cerr << __FILE__ << "[" << __LINE__ << "]"<< std::endl;
             if (i == e)
               is.setstate(is.failbit|is.eofbit);
             else
               is.setstate(is.failbit);
-            std::cerr << __FILE__ << "[" << __LINE__ << "]"<< std::endl;
+            //std::cerr << __FILE__ << "[" << __LINE__ << "]"<< std::endl;
             return is;
         }
     }
     else {
-      std::cerr << __FILE__ << "[" << __LINE__ << "]"<< std::endl;
+      //std::cerr << __FILE__ << "[" << __LINE__ << "]"<< std::endl;
         //is.setstate(is.failbit);
       return is;
     }

3party/boost/boost/chrono/time_point.hpp

@@ -217,12 +217,12 @@ namespace chrono {
 
         // special values
 
-        static BOOST_CONSTEXPR time_point
+        static BOOST_CHRONO_LIB_CONSTEXPR time_point
         min BOOST_PREVENT_MACRO_SUBSTITUTION ()
         {
             return time_point((duration::min)());
         }
-        static BOOST_CONSTEXPR time_point
+        static BOOST_CHRONO_LIB_CONSTEXPR time_point
         max BOOST_PREVENT_MACRO_SUBSTITUTION ()
         {
             return time_point((duration::max)());

3party/boost/boost/config/compiler/gcc.hpp

@@ -184,7 +184,7 @@
 #  define BOOST_NO_CXX11_DELETED_FUNCTIONS
 #endif
 
-#if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 4)
+#if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 5)
 #  define BOOST_NO_SFINAE_EXPR
 #endif
 

3party/boost/boost/container/allocator_traits.hpp

@@ -70,41 +70,41 @@ struct allocator_traits
       typedef unspecified pointer;
       //! Alloc::const_pointer if such a type exists ; otherwise, pointer_traits<pointer>::rebind<const
       //!
-      typedef unspecified const_pointer;
+      typedef see_documentation const_pointer;
       //! Non-standard extension
       //! Alloc::reference if such a type exists; otherwise, value_type&
-      typedef unspecified reference;
+      typedef see_documentation reference;
       //! Non-standard extension
       //! Alloc::const_reference if such a type exists ; otherwise, const value_type&
-      typedef unspecified const_reference;
+      typedef see_documentation const_reference;
       //! Alloc::void_pointer if such a type exists ; otherwise, pointer_traits<pointer>::rebind<void>.
       //!
-      typedef unspecified void_pointer;
+      typedef see_documentation void_pointer;
       //! Alloc::const_void_pointer if such a type exists ; otherwis e, pointer_traits<pointer>::rebind<const
       //!
-      typedef unspecified const_void_pointer;
+      typedef see_documentation const_void_pointer;
       //! Alloc::difference_type if such a type exists ; otherwise, pointer_traits<pointer>::difference_type.
       //!
-      typedef unspecified difference_type;
+      typedef see_documentation difference_type;
       //! Alloc::size_type if such a type exists ; otherwise, make_unsigned<difference_type>::type
       //!
-      typedef unspecified size_type;
+      typedef see_documentation size_type;
       //! Alloc::propagate_on_container_copy_assignment if such a type exists, otherwise an integral_constant
       //! type with internal constant static member `value` == false.
-      typedef unspecified propagate_on_container_copy_assignment;
+      typedef see_documentation propagate_on_container_copy_assignment;
       //! Alloc::propagate_on_container_move_assignment if such a type exists, otherwise an integral_constant
       //! type with internal constant static member `value` == false.
-      typedef unspecified propagate_on_container_move_assignment;
+      typedef see_documentation propagate_on_container_move_assignment;
       //! Alloc::propagate_on_container_swap if such a type exists, otherwise an integral_constant
       //! type with internal constant static member `value` == false.
-      typedef unspecified propagate_on_container_swap;
+      typedef see_documentation propagate_on_container_swap;
       //! Defines an allocator: Alloc::rebind<T>::other if such a type exists; otherwise, Alloc<T, Args>
       //! if Alloc is a class template instantiation of the form Alloc<U, Args>, where Args is zero or
       //! more type arguments ; otherwise, the instantiation of rebind_alloc is ill-formed.
       //!
       //! In C++03 compilers `rebind_alloc` is a struct derived from an allocator
       //! deduced by previously detailed rules.
-      template <class T> using rebind_alloc = unspecified;
+      template <class T> using rebind_alloc = see_documentation;
 
       //! In C++03 compilers `rebind_traits` is a struct derived from
       //! `allocator_traits<OtherAlloc>`, where `OtherAlloc` is
@@ -115,7 +115,7 @@ struct allocator_traits
       //! `type` is an allocator related to Alloc deduced deduced by rules explained in `rebind_alloc`.
       template <class T>
       struct portable_rebind_alloc
-      {  typedef unspecified_type type;  };
+      {  typedef see_documentation type;  };
    #else
       //pointer
       typedef BOOST_INTRUSIVE_OBTAIN_TYPE_WITH_DEFAULT(boost::container::container_detail::, Alloc,

3party/boost/boost/container/container_fwd.hpp

@@ -49,85 +49,85 @@ namespace container {
 
 //vector class
 template <class T
-         ,class A = std::allocator<T> >
+         ,class Allocator = std::allocator<T> >
 class vector;
 
 //vector class
 template <class T
-         ,class A = std::allocator<T> >
+         ,class Allocator = std::allocator<T> >
 class stable_vector;
 
 //vector class
 template <class T
-         ,class A = std::allocator<T> >
+         ,class Allocator = std::allocator<T> >
 class deque;
 
 //list class
 template <class T
-         ,class A = std::allocator<T> >
+         ,class Allocator = std::allocator<T> >
 class list;
 
 //slist class
 template <class T
-         ,class A = std::allocator<T> >
+         ,class Allocator = std::allocator<T> >
 class slist;
 
 //set class
-template <class T
-         ,class Pred  = std::less<T>
-         ,class A = std::allocator<T> >
+template <class Key
+         ,class Compare  = std::less<Key>
+         ,class Allocator = std::allocator<Key> >
 class set;
 
 //multiset class
-template <class T
-         ,class Pred  = std::less<T>
-         ,class A = std::allocator<T> >
+template <class Key
+         ,class Compare  = std::less<Key>
+         ,class Allocator = std::allocator<Key> >
 class multiset;
 
 //map class
 template <class Key
          ,class T
-         ,class Pred  = std::less<Key>
-         ,class A = std::allocator<std::pair<const Key, T> > >
+         ,class Compare  = std::less<Key>
+         ,class Allocator = std::allocator<std::pair<const Key, T> > >
 class map;
 
 //multimap class
 template <class Key
          ,class T
-         ,class Pred  = std::less<Key>
-         ,class A = std::allocator<std::pair<const Key, T> > >
+         ,class Compare  = std::less<Key>
+         ,class Allocator = std::allocator<std::pair<const Key, T> > >
 class multimap;
 
 //flat_set class
-template <class T
-         ,class Pred  = std::less<T>
-         ,class A = std::allocator<T> >
+template <class Key
+         ,class Compare  = std::less<Key>
+         ,class Allocator = std::allocator<Key> >
 class flat_set;
 
 //flat_multiset class
-template <class T
-         ,class Pred  = std::less<T>
-         ,class A = std::allocator<T> >
+template <class Key
+         ,class Compare  = std::less<Key>
+         ,class Allocator = std::allocator<Key> >
 class flat_multiset;
 
 //flat_map class
 template <class Key
          ,class T
-         ,class Pred  = std::less<Key>
-         ,class A = std::allocator<std::pair<Key, T> > >
+         ,class Compare  = std::less<Key>
+         ,class Allocator = std::allocator<std::pair<Key, T> > >
 class flat_map;
 
 //flat_multimap class
 template <class Key
          ,class T
-         ,class Pred  = std::less<Key>
-         ,class A = std::allocator<std::pair<Key, T> > >
+         ,class Compare  = std::less<Key>
+         ,class Allocator = std::allocator<std::pair<Key, T> > >
 class flat_multimap;
 
 //basic_string class
 template <class CharT
          ,class Traits = std::char_traits<CharT>
-         ,class A  = std::allocator<CharT> >
+         ,class Allocator  = std::allocator<CharT> >
 class basic_string;
 
 //! Type used to tag that the input range is

3party/boost/boost/container/detail/adaptive_node_pool_impl.hpp

@@ -348,8 +348,7 @@ class private_adaptive_node_pool_impl
    {
       block_iterator block_it(m_block_multiset.end());
       while(n--){
-         void *pElem = container_detail::to_raw_pointer(chain.front());
-         chain.pop_front();
+         void *pElem = container_detail::to_raw_pointer(chain.pop_front());
          priv_invariants();
          block_info_t *block_info = this->priv_block_from_node(pElem);
          BOOST_ASSERT(block_info->free_nodes.size() < m_real_num_node);

3party/boost/boost/container/detail/advanced_insert_int.hpp

@@ -173,7 +173,6 @@ struct default_construct_aux_proxy
 #ifdef BOOST_CONTAINER_PERFECT_FORWARDING
 
 #include <boost/container/detail/variadic_templates_tools.hpp>
-#include <boost/container/detail/stored_ref.hpp>
 #include <boost/move/move.hpp>
 #include <typeinfo>
 //#include <iostream> //For debugging purposes
@@ -227,8 +226,7 @@ struct advanced_insert_aux_non_movable_emplace
          if(!this->used_){
             alloc_traits::construct( this->a_
                                    , container_detail::to_raw_pointer(&*p)
-                                   , ::boost::container::container_detail::
-                                       stored_ref<Args>::forward(get<IdxPack>(this->args_))...
+                                   , ::boost::forward<Args>(get<IdxPack>(this->args_))...
                                    );
             this->used_ = true;
          }
@@ -241,8 +239,7 @@ struct advanced_insert_aux_non_movable_emplace
       if(!this->used_){
          alloc_traits::construct( this->a_
                                 , container_detail::to_raw_pointer(&*p)
-                                , ::boost::container::container_detail::
-                                    stored_ref<Args>::forward(get<IdxPack>(this->args_))...
+                                  , ::boost::forward<Args>(get<IdxPack>(this->args_))...
                                 );
          this->used_ = true;
       }
@@ -288,7 +285,7 @@ struct advanced_insert_aux_emplace
          aligned_storage<sizeof(value_type), alignment_of<value_type>::value> v;
          value_type *vp = static_cast<value_type *>(static_cast<void *>(&v));
          alloc_traits::construct(this->a_, vp,
-            ::boost::container::container_detail::stored_ref<Args>::forward(get<IdxPack>(this->args_))...);
+            ::boost::forward<Args>(get<IdxPack>(this->args_))...);
          scoped_destructor<A> d(this->a_, vp);
          *p = ::boost::move(*vp);
          d.release();
@@ -305,7 +302,7 @@ struct advanced_insert_aux_emplace
             aligned_storage<sizeof(value_type), alignment_of<value_type>::value> v;
             value_type *vp = static_cast<value_type *>(static_cast<void *>(&v));
             alloc_traits::construct(this->a_, vp,
-               ::boost::container::container_detail::stored_ref<Args>::forward(get<IdxPack>(this->args_))...);
+               ::boost::forward<Args>(get<IdxPack>(this->args_))...);
             try {
                *p = ::boost::move(*vp);
             } catch (...) {
@@ -413,7 +410,7 @@ struct BOOST_PP_CAT(BOOST_PP_CAT(advanced_insert_aux_emplace, n), arg)
          alloc_traits::construct(this->a_, vp                                       \
             BOOST_PP_ENUM_TRAILING(n, BOOST_CONTAINER_PP_MEMBER_FORWARD, _));       \
          scoped_destructor<A> d(this->a_, vp);                                      \
-         *p = ::boost::move(*vp);                                                     \
+         *p = ::boost::move(*vp);                                                   \
          d.release();                                                               \
          this->used_ = true;                                                        \
       }                                                                             \
@@ -430,7 +427,7 @@ struct BOOST_PP_CAT(BOOST_PP_CAT(advanced_insert_aux_emplace, n), arg)
             alloc_traits::construct(this->a_, vp                                    \
                BOOST_PP_ENUM_TRAILING(n, BOOST_CONTAINER_PP_MEMBER_FORWARD, _));    \
             scoped_destructor<A> d(this->a_, vp);                                   \
-            *p = ::boost::move(*vp);                                                  \
+            *p = ::boost::move(*vp);                                                \
             d.release();                                                            \
             this->used_ = true;                                                     \
          }                                                                          \

3party/boost/boost/container/detail/algorithms.hpp

@@ -34,6 +34,30 @@
 namespace boost {
 namespace container {
 
+template<class It>
+struct is_default_construct_iterator
+{
+   static const bool value = false;
+};
+
+template<class U, class D>
+struct is_default_construct_iterator<default_construct_iterator<U, D> >
+{
+   static const bool value = true;
+};
+
+template<class It>
+struct is_emplace_iterator
+{
+   static const bool value = false;
+};
+
+template<class U, class EF, class D>
+struct is_emplace_iterator<emplace_iterator<U, EF, D> >
+{
+   static const bool value = true;
+};
+
 template<class A, class T, class InpIt>
 inline void construct_in_place(A &a, T* dest, InpIt source)
 {     boost::container::allocator_traits<A>::construct(a, dest, *source);  }

3party/boost/boost/container/detail/destroyers.hpp

@@ -27,6 +27,68 @@ namespace boost {
 namespace container {
 namespace container_detail {
 
+//!A deleter for scoped_ptr that deallocates the memory
+//!allocated for an object using a STL allocator.
+template <class A>
+struct scoped_deallocator
+{
+   typedef allocator_traits<A> allocator_traits_type;
+   typedef typename allocator_traits_type::pointer pointer;
+   typedef container_detail::integral_constant<unsigned,
+      boost::container::container_detail::
+         version<A>::value>                   alloc_version;
+   typedef container_detail::integral_constant<unsigned, 1>     allocator_v1;
+   typedef container_detail::integral_constant<unsigned, 2>     allocator_v2;
+
+   private:
+   void priv_deallocate(allocator_v1)
+   {  m_alloc.deallocate(m_ptr, 1); }
+
+   void priv_deallocate(allocator_v2)
+   {  m_alloc.deallocate_one(m_ptr); }
+
+   BOOST_MOVABLE_BUT_NOT_COPYABLE(scoped_deallocator)
+
+   public:
+
+   pointer     m_ptr;
+   A&  m_alloc;
+
+   scoped_deallocator(pointer p, A& a)
+      : m_ptr(p), m_alloc(a)
+   {}
+
+   ~scoped_deallocator()
+   {  if (m_ptr)priv_deallocate(alloc_version());  }
+
+   scoped_deallocator(BOOST_RV_REF(scoped_deallocator) o)
+      :  m_ptr(o.m_ptr), m_alloc(o.m_alloc)
+   {  o.release();  }
+
+   pointer get() const
+   {  return m_ptr;  }
+
+   void release()
+   {  m_ptr = 0; }
+};
+
+template <class Allocator>
+struct null_scoped_deallocator
+{
+   typedef boost::container::allocator_traits<Allocator> AllocTraits;
+   typedef typename AllocTraits::pointer    pointer;
+   typedef typename AllocTraits::size_type  size_type;
+
+   null_scoped_deallocator(pointer, Allocator&, size_type)
+   {}
+
+   void release()
+   {}
+
+   pointer get() const
+   {  return pointer();  }
+};
+
 //!A deleter for scoped_ptr that deallocates the memory
 //!allocated for an array of objects using a STL allocator.
 template <class Allocator>
@@ -239,10 +301,57 @@ class allocator_destroyer
    void operator()(const pointer &p)
    {
       AllocTraits::destroy(a_, container_detail::to_raw_pointer(p));
-      priv_deallocate(p, alloc_version());
+      this->priv_deallocate(p, alloc_version());
    }
 };
 
+template <class A>
+class allocator_destroyer_and_chain_builder
+{
+   typedef allocator_traits<A> allocator_traits_type;
+   typedef typename allocator_traits_type::value_type value_type;
+   typedef typename A::multiallocation_chain    multiallocation_chain;
+
+   A & a_;
+   multiallocation_chain &c_;
+
+   public:
+   allocator_destroyer_and_chain_builder(A &a, multiallocation_chain &c)
+      :  a_(a), c_(c)
+   {}
+
+   void operator()(const typename A::pointer &p)
+   {
+      allocator_traits<A>::destroy(a_, container_detail::to_raw_pointer(p));
+      c_.push_front(p);
+   }
+};
+
+template <class A>
+class allocator_multialloc_chain_node_deallocator
+{
+   typedef allocator_traits<A> allocator_traits_type;
+   typedef typename allocator_traits_type::value_type value_type;
+   typedef typename A::multiallocation_chain    multiallocation_chain;
+   typedef allocator_destroyer_and_chain_builder<A> chain_builder;
+
+   A & a_;
+   multiallocation_chain c_;
+
+   public:
+   allocator_multialloc_chain_node_deallocator(A &a)
+      :  a_(a), c_()
+   {}
+
+   chain_builder get_chain_builder()
+   {  return chain_builder(a_, c_);  }
+
+   ~allocator_multialloc_chain_node_deallocator()
+   {
+      if(!c_.empty())
+         a_.deallocate_individual(boost::move(c_));
+   }
+};
 
 }  //namespace container_detail {
 }  //namespace container {

3party/boost/boost/container/detail/flat_tree.hpp

@@ -48,7 +48,7 @@ class flat_tree_value_compare
    typedef Value              first_argument_type;
    typedef Value              second_argument_type;
    typedef bool               return_type;
-   public:    
+   public:
    flat_tree_value_compare()
       : Compare()
    {}
@@ -65,7 +65,7 @@ class flat_tree_value_compare
 
    const Compare &get_comp() const
       {  return *this;  }
-  
+
    Compare &get_comp()
       {  return *this;  }
 };
@@ -214,6 +214,21 @@ class flat_tree
       : m_data(comp, a)
    { this->m_data.m_vect.insert(this->m_data.m_vect.end(), first, last); }
 
+   template <class InputIterator>
+   flat_tree( bool unique_insertion
+            , InputIterator first, InputIterator last
+            , const Compare& comp     = Compare()
+            , const allocator_type& a = allocator_type())
+      : m_data(comp, a)
+   {
+      if(unique_insertion){
+         this->insert_unique(first, last);
+      }
+      else{
+         this->insert_equal(first, last);
+      }
+   }
+
    ~flat_tree()
    { }
 
@@ -223,7 +238,7 @@ class flat_tree
    flat_tree&  operator=(BOOST_RV_REF(flat_tree) mx)
    {  m_data = boost::move(mx.m_data); return *this;  }
 
-   public:   
+   public:
    // accessors:
    Compare key_comp() const
    { return this->m_data.get_comp(); }
@@ -290,9 +305,9 @@ class flat_tree
    std::pair<iterator,bool> insert_unique(const value_type& val)
    {
       insert_commit_data data;
-      std::pair<iterator,bool> ret = priv_insert_unique_prepare(val, data);
+      std::pair<iterator,bool> ret = this->priv_insert_unique_prepare(val, data);
       if(ret.second){
-         ret.first = priv_insert_commit(data, val);
+         ret.first = this->priv_insert_commit(data, val);
       }
       return ret;
    }
@@ -300,9 +315,9 @@ class flat_tree
    std::pair<iterator,bool> insert_unique(BOOST_RV_REF(value_type) val)
    {
       insert_commit_data data;
-      std::pair<iterator,bool> ret = priv_insert_unique_prepare(val, data);
+      std::pair<iterator,bool> ret = this->priv_insert_unique_prepare(val, data);
       if(ret.second){
-         ret.first = priv_insert_commit(data, boost::move(val));
+         ret.first = this->priv_insert_commit(data, boost::move(val));
       }
       return ret;
    }
@@ -324,9 +339,9 @@ class flat_tree
    iterator insert_unique(const_iterator pos, const value_type& val)
    {
       insert_commit_data data;
-      std::pair<iterator,bool> ret = priv_insert_unique_prepare(pos, val, data);
+      std::pair<iterator,bool> ret = this->priv_insert_unique_prepare(pos, val, data);
       if(ret.second){
-         ret.first = priv_insert_commit(data, val);
+         ret.first = this->priv_insert_commit(data, val);
       }
       return ret.first;
    }
@@ -334,9 +349,9 @@ class flat_tree
    iterator insert_unique(const_iterator pos, BOOST_RV_REF(value_type) mval)
    {
       insert_commit_data data;
-      std::pair<iterator,bool> ret = priv_insert_unique_prepare(pos, mval, data);
+      std::pair<iterator,bool> ret = this->priv_insert_unique_prepare(pos, mval, data);
       if(ret.second){
-         ret.first = priv_insert_commit(data, boost::move(mval));
+         ret.first = this->priv_insert_commit(data, boost::move(mval));
       }
       return ret.first;
    }
@@ -345,45 +360,168 @@ class flat_tree
    {
       insert_commit_data data;
       this->priv_insert_equal_prepare(pos, val, data);
-      return priv_insert_commit(data, val);
+      return this->priv_insert_commit(data, val);
    }
 
    iterator insert_equal(const_iterator pos, BOOST_RV_REF(value_type) mval)
    {
       insert_commit_data data;
       this->priv_insert_equal_prepare(pos, mval, data);
-      return priv_insert_commit(data, boost::move(mval));
+      return this->priv_insert_commit(data, boost::move(mval));
    }
 
    template <class InIt>
    void insert_unique(InIt first, InIt last)
+   {  this->priv_insert_unique_loop(first, last); }
+
+   template <class InIt>
+   void insert_equal(InIt first, InIt last
+      #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
+      , typename container_detail::enable_if_c
+         < container_detail::is_input_iterator<InIt>::value
+         >::type * = 0
+      #endif
+      )
+   {  this->priv_insert_equal_loop(first, last);  }
+
+   template <class InIt>
+   void insert_equal(InIt first, InIt last
+      #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
+      , typename container_detail::enable_if_c
+         < !container_detail::is_input_iterator<InIt>::value
+         >::type * = 0
+      #endif
+      )
    {
-      for ( ; first != last; ++first)
-         this->insert_unique(*first);
+      const size_type len = static_cast<size_type>(std::distance(first, last));
+      this->reserve(this->size()+len);
+      this->priv_insert_equal_loop(first, last);
+   }
+
+   //Ordered
+
+   template <class InIt>
+   void insert_equal(ordered_range_t, InIt first, InIt last
+      #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
+      , typename container_detail::enable_if_c
+         < container_detail::is_input_iterator<InIt>::value
+         >::type * = 0
+      #endif
+      )
+   {  this->priv_insert_equal_loop_ordered(first, last); }
+
+   template <class FwdIt>
+   void insert_equal(ordered_range_t, FwdIt first, FwdIt last
+      #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
+      , typename container_detail::enable_if_c
+         < !container_detail::is_input_iterator<FwdIt>::value &&
+		   container_detail::is_forward_iterator<FwdIt>::value
+         >::type * = 0
+      #endif
+      )
+   {
+      const size_type len = static_cast<size_type>(std::distance(first, last));
+      this->reserve(this->size()+len);
+      this->priv_insert_equal_loop_ordered(first, last);
+   }
+
+   template <class BidirIt>
+   void insert_equal(ordered_range_t, BidirIt first, BidirIt last
+      #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
+      , typename container_detail::enable_if_c
+         < !container_detail::is_input_iterator<BidirIt>::value &&
+           !container_detail::is_forward_iterator<BidirIt>::value
+         >::type * = 0
+      #endif
+      )
+   {
+      size_type len = static_cast<size_type>(std::distance(first, last));
+      const size_type BurstSize = 16;
+      size_type positions[BurstSize];
+
+      //Prereserve all memory so that iterators are not invalidated
+      this->reserve(this->size()+len);
+      const const_iterator beg(this->cbegin());
+      const_iterator pos(beg);
+      //Loop in burst sizes
+      while(len){
+         const size_type burst = len < BurstSize ? len : BurstSize;
+         const const_iterator cend_(this->cend());
+         len -= burst;
+         for(size_type i = 0; i != burst; ++i){
+            //Get the insertion position for each key
+            pos = const_cast<const flat_tree&>(*this).priv_upper_bound(pos, cend_, KeyOfValue()(*first));
+            positions[i] = static_cast<size_type>(pos - beg);
+            ++first;
+         }
+         //Insert all in a single step in the precalculated positions
+         this->m_data.m_vect.insert_ordered_at(burst, positions + burst, first);
+         //Next search position updated
+         pos += burst;
+      }
    }
 
    template <class InIt>
-   void insert_equal(InIt first, InIt last)
-   {
-      typedef typename
-         std::iterator_traits<InIt>::iterator_category ItCat;
-      this->priv_insert_equal(first, last, ItCat());
-   }
+   void insert_unique(ordered_unique_range_t, InIt first, InIt last
+      #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
+      , typename container_detail::enable_if_c
+         < container_detail::is_input_iterator<InIt>::value ||
+           container_detail::is_forward_iterator<InIt>::value
+         >::type * = 0
+      #endif
+      )
+   {  this->priv_insert_unique_loop_hint(first, last);  }
 
-   template <class InIt>
-   void insert_equal(ordered_range_t, InIt first, InIt last)
+   template <class BidirIt>
+   void insert_unique(ordered_unique_range_t, BidirIt first, BidirIt last
+      #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
+      , typename container_detail::enable_if_c
+         < !(container_detail::is_input_iterator<BidirIt>::value ||
+             container_detail::is_forward_iterator<BidirIt>::value)
+         >::type * = 0
+      #endif
+      )
    {
-      typedef typename
-         std::iterator_traits<InIt>::iterator_category ItCat;
-      this->priv_insert_equal(ordered_range_t(), first, last, ItCat());
-   }
+      size_type len = static_cast<size_type>(std::distance(first, last));
+      const size_type BurstSize = 16;
+      size_type positions[BurstSize];
+      size_type skips[BurstSize];
 
-   template <class InIt>
-   void insert_unique(ordered_unique_range_t, InIt first, InIt last)
-   {
-      typedef typename
-         std::iterator_traits<InIt>::iterator_category ItCat;
-      this->priv_insert_unique(ordered_unique_range_t(), first, last, ItCat());
+      //Prereserve all memory so that iterators are not invalidated
+      this->reserve(this->size()+len);
+      const const_iterator beg(this->cbegin());
+      const_iterator pos(beg);
+      const value_compare &value_comp = this->m_data;
+      skips[0u] = 0u;
+      //Loop in burst sizes
+      while(len){
+         const size_type burst = len < BurstSize ? len : BurstSize;
+         size_type unique_burst = 0u;
+         const const_iterator cend_(this->cend());
+         while(unique_burst < burst && len > 0){
+            //Get the insertion position for each key
+            const value_type & val = *first++;
+            --len;
+            pos = const_cast<const flat_tree&>(*this).priv_lower_bound(pos, cend_, KeyOfValue()(val));
+            //Check if already present
+            if(pos != cend_ && !value_comp(val, *pos)){
+               if(unique_burst > 0){
+                  ++skips[unique_burst-1];
+               }
+               continue;
+            }
+
+            //If not present, calculate position
+            positions[unique_burst] = static_cast<size_type>(pos - beg);
+            skips[unique_burst++] = 0u;
+         }
+         if(unique_burst){
+            //Insert all in a single step in the precalculated positions
+            this->m_data.m_vect.insert_ordered_at(unique_burst, positions + unique_burst, skips + unique_burst, first);
+            //Next search position updated
+            pos += unique_burst;
+         }
+      }
    }
 
    #ifdef BOOST_CONTAINER_PERFECT_FORWARDING
@@ -398,9 +536,9 @@ class flat_tree
       value_destructor<stored_allocator_type> d(a, val);
       insert_commit_data data;
       std::pair<iterator,bool> ret =
-         priv_insert_unique_prepare(val, data);
+         this->priv_insert_unique_prepare(val, data);
       if(ret.second){
-         ret.first = priv_insert_commit(data, boost::move(val));
+         ret.first = this->priv_insert_commit(data, boost::move(val));
       }
       return ret;
    }
@@ -414,9 +552,9 @@ class flat_tree
       stored_allocator_traits::construct(a, &val, ::boost::forward<Args>(args)... );
       value_destructor<stored_allocator_type> d(a, val);
       insert_commit_data data;
-      std::pair<iterator,bool> ret = priv_insert_unique_prepare(hint, val, data);
+      std::pair<iterator,bool> ret = this->priv_insert_unique_prepare(hint, val, data);
       if(ret.second){
-         ret.first = priv_insert_commit(data, boost::move(val));
+         ret.first = this->priv_insert_commit(data, boost::move(val));
       }
       return ret.first;
    }
@@ -444,7 +582,7 @@ class flat_tree
       value_destructor<stored_allocator_type> d(a, val);
       insert_commit_data data;
       this->priv_insert_equal_prepare(hint, val, data);
-      iterator i = priv_insert_commit(data, boost::move(val));
+      iterator i = this->priv_insert_commit(data, boost::move(val));
       return i;
    }
 
@@ -462,9 +600,9 @@ class flat_tree
          BOOST_PP_ENUM_TRAILING(n, BOOST_CONTAINER_PP_PARAM_FORWARD, _) );                \
       value_destructor<stored_allocator_type> d(a, val);                                  \
       insert_commit_data data;                                                            \
-      std::pair<iterator,bool> ret = priv_insert_unique_prepare(val, data);               \
+      std::pair<iterator,bool> ret = this->priv_insert_unique_prepare(val, data);         \
       if(ret.second){                                                                     \
-         ret.first = priv_insert_commit(data, boost::move(val));                          \
+         ret.first = this->priv_insert_commit(data, boost::move(val));                    \
       }                                                                                   \
       return ret;                                                                         \
    }                                                                                      \
@@ -480,9 +618,9 @@ class flat_tree
          BOOST_PP_ENUM_TRAILING(n, BOOST_CONTAINER_PP_PARAM_FORWARD, _) );                \
       value_destructor<stored_allocator_type> d(a,  val);                                 \
       insert_commit_data data;                                                            \
-      std::pair<iterator,bool> ret = priv_insert_unique_prepare(hint, val, data);         \
+      std::pair<iterator,bool> ret = this->priv_insert_unique_prepare(hint, val, data);   \
       if(ret.second){                                                                     \
-         ret.first = priv_insert_commit(data, boost::move(val));                          \
+         ret.first = this->priv_insert_commit(data, boost::move(val));                    \
       }                                                                                   \
       return ret.first;                                                                   \
    }                                                                                      \
@@ -513,7 +651,7 @@ class flat_tree
       value_destructor<stored_allocator_type> d(a,  val);                                 \
       insert_commit_data data;                                                            \
       this->priv_insert_equal_prepare(hint, val, data);                                   \
-      iterator i = priv_insert_commit(data, boost::move(val));                            \
+      iterator i = this->priv_insert_commit(data, boost::move(val));                      \
       return i;                                                                           \
    }                                                                                      \
 
@@ -554,22 +692,22 @@ class flat_tree
    // set operations:
    iterator find(const key_type& k)
    {
-      const Compare &key_comp = this->m_data.get_comp();
+      const Compare &key_comp_ = this->m_data.get_comp();
       iterator i = this->lower_bound(k);
 
-      if (i != this->end() && key_comp(k, KeyOfValue()(*i))){ 
-         i = this->end(); 
+      if (i != this->end() && key_comp_(k, KeyOfValue()(*i))){
+         i = this->end();
       }
       return i;
    }
 
    const_iterator find(const key_type& k) const
    {
-      const Compare &key_comp = this->m_data.get_comp();
+      const Compare &key_comp_ = this->m_data.get_comp();
       const_iterator i = this->lower_bound(k);
 
-      if (i != this->end() && key_comp(k, KeyOfValue()(*i))){ 
-         i = this->end(); 
+      if (i != this->end() && key_comp_(k, KeyOfValue()(*i))){
+         i = this->end();
       }
       return i;
    }
@@ -599,11 +737,11 @@ class flat_tree
    std::pair<const_iterator, const_iterator> equal_range(const key_type& k) const
    {  return this->priv_equal_range(this->begin(), this->end(), k);  }
 
-   size_type capacity() const          
+   size_type capacity() const
    { return this->m_data.m_vect.capacity(); }
 
-   void reserve(size_type count)      
-   { this->m_data.m_vect.reserve(count);   }
+   void reserve(size_type count_)
+   { this->m_data.m_vect.reserve(count_);   }
 
    private:
    struct insert_commit_data
@@ -642,18 +780,18 @@ class flat_tree
    }
 
    std::pair<iterator,bool> priv_insert_unique_prepare
-      (const_iterator beg, const_iterator end, const value_type& val, insert_commit_data &commit_data)
+      (const_iterator beg, const_iterator end_, const value_type& val, insert_commit_data &commit_data)
    {
       const value_compare &value_comp  = this->m_data;
-      commit_data.position = this->priv_lower_bound(beg, end, KeyOfValue()(val));
+      commit_data.position = this->priv_lower_bound(beg, end_, KeyOfValue()(val));
       return std::pair<iterator,bool>
          ( *reinterpret_cast<iterator*>(&commit_data.position)
-         , commit_data.position == end || value_comp(val, *commit_data.position));
+         , commit_data.position == end_ || value_comp(val, *commit_data.position));
    }
 
    std::pair<iterator,bool> priv_insert_unique_prepare
       (const value_type& val, insert_commit_data &commit_data)
-   {  return priv_insert_unique_prepare(this->begin(), this->end(), val, commit_data);   }
+   {  return this->priv_insert_unique_prepare(this->begin(), this->end(), val, commit_data);   }
 
    std::pair<iterator,bool> priv_insert_unique_prepare
       (const_iterator pos, const value_type& val, insert_commit_data &commit_data)
@@ -716,7 +854,7 @@ class flat_tree
    RanIt priv_lower_bound(RanIt first, RanIt last,
                           const key_type & key) const
    {
-      const Compare &key_comp = this->m_data.get_comp();
+      const Compare &key_comp_ = this->m_data.get_comp();
       KeyOfValue key_extract;
       difference_type len = last - first, half;
       RanIt middle;
@@ -726,7 +864,7 @@ class flat_tree
          middle = first;
          middle += half;
 
-         if (key_comp(key_extract(*middle), key)) {
+         if (key_comp_(key_extract(*middle), key)) {
             ++middle;
             first = middle;
             len = len - half - 1;
@@ -741,7 +879,7 @@ class flat_tree
    RanIt priv_upper_bound(RanIt first, RanIt last,
                           const key_type & key) const
    {
-      const Compare &key_comp = this->m_data.get_comp();
+      const Compare &key_comp_ = this->m_data.get_comp();
       KeyOfValue key_extract;
       difference_type len = last - first, half;
       RanIt middle;
@@ -751,12 +889,12 @@ class flat_tree
          middle = first;
          middle += half;
 
-         if (key_comp(key, key_extract(*middle))) {
+         if (key_comp_(key, key_extract(*middle))) {
             len = half;
          }
          else{
             first = ++middle;
-            len = len - half - 1; 
+            len = len - half - 1;
          }
       }
       return first;
@@ -766,7 +904,7 @@ class flat_tree
    std::pair<RanIt, RanIt>
       priv_equal_range(RanIt first, RanIt last, const key_type& key) const
    {
-      const Compare &key_comp = this->m_data.get_comp();
+      const Compare &key_comp_ = this->m_data.get_comp();
       KeyOfValue key_extract;
       difference_type len = last - first, half;
       RanIt middle, left, right;
@@ -776,12 +914,12 @@ class flat_tree
          middle = first;
          middle += half;
 
-         if (key_comp(key_extract(*middle), key)){
+         if (key_comp_(key_extract(*middle), key)){
             first = middle;
             ++first;
             len = len - half - 1;
          }
-         else if (key_comp(key, key_extract(*middle))){
+         else if (key_comp_(key, key_extract(*middle))){
             len = half;
          }
          else {
@@ -794,102 +932,38 @@ class flat_tree
       return std::pair<RanIt, RanIt>(first, first);
    }
 
-   template <class BidirIt>
-   void priv_insert_equal(ordered_range_t, BidirIt first, BidirIt last, std::bidirectional_iterator_tag)
+   template<class InIt>
+   void priv_insert_equal_loop(InIt first, InIt last)
    {
-      size_type len = static_cast<size_type>(std::distance(first, last));
-      const size_type BurstSize = 16;
-      size_type positions[BurstSize];
-
-      //Prereserve all memory so that iterators are not invalidated
-      this->reserve(this->size()+len);
-      const const_iterator beg(this->cbegin());
-      const_iterator pos(beg);
-      //Loop in burst sizes
-      while(len){
-         const size_type burst = len < BurstSize ? len : BurstSize;
-         const const_iterator cend(this->cend());
-         len -= burst;
-         for(size_type i = 0; i != burst; ++i){
-            //Get the insertion position for each key
-            pos = const_cast<const flat_tree&>(*this).priv_upper_bound(pos, cend, KeyOfValue()(*first));
-            positions[i] = static_cast<size_type>(pos - beg);
-            ++first;
-         }
-         //Insert all in a single step in the precalculated positions
-         this->m_data.m_vect.insert_ordered_at(burst, positions + burst, first);
-         //Next search position updated
-         pos += burst;
-      }
-   }
-
-   template <class BidirIt>
-   void priv_insert_unique(ordered_unique_range_t, BidirIt first, BidirIt last, std::bidirectional_iterator_tag)
-   {
-      size_type len = static_cast<size_type>(std::distance(first, last));
-      const size_type BurstSize = 16;
-      size_type positions[BurstSize];
-      size_type skips[BurstSize];
-
-      //Prereserve all memory so that iterators are not invalidated
-      this->reserve(this->size()+len);
-      const const_iterator beg(this->cbegin());
-      const_iterator pos(beg);
-      const value_compare &value_comp = this->m_data;
-      //Loop in burst sizes
-      while(len){
-         skips[0u] = 0u;
-         const size_type burst = len < BurstSize ? len : BurstSize;
-         size_type unique_burst = 0u;
-         const const_iterator cend(this->cend());
-         while(unique_burst < burst && len > 0){
-            //Get the insertion position for each key
-            const value_type & val = *first++;
-            --len;
-            pos = const_cast<const flat_tree&>(*this).priv_lower_bound(pos, cend, KeyOfValue()(val));
-            //Check if already present
-            if(pos != cend && !value_comp(*pos, val)){
-               ++skips[unique_burst];
-               continue;
-            }
-
-            //If not present, calculate position
-            positions[unique_burst] = static_cast<size_type>(pos - beg);
-            if(++unique_burst < burst)
-               skips[unique_burst] = 0u;
-         }
-         //Insert all in a single step in the precalculated positions
-         this->m_data.m_vect.insert_ordered_at(unique_burst, positions + unique_burst, skips + unique_burst, first);
-         //Next search position updated
-         pos += unique_burst;
-      }
-   }
-/*
-   template <class FwdIt>
-   void priv_insert_equal_forward(ordered_range_t, FwdIt first, FwdIt last, std::forward_iterator_tag)
-   {  this->priv_insert_equal(first, last, std::forward_iterator_tag());   }
-*/
-   template <class InIt>
-   void priv_insert_equal(ordered_range_t, InIt first, InIt last, std::input_iterator_tag)
-   {  this->priv_insert_equal(first, last, std::input_iterator_tag());  }
-
-   template <class InIt>
-   void priv_insert_unique(ordered_unique_range_t, InIt first, InIt last, std::input_iterator_tag)
-   {  this->priv_insert_unique(first, last, std::input_iterator_tag());  }
-/*
-   template <class FwdIt>
-   void priv_insert_equal_forward(FwdIt first, FwdIt last, std::forward_iterator_tag)
-   {
-      const size_type len = static_cast<size_type>(std::distance(first, last));
-      this->reserve(this->size()+len);
-      this->priv_insert_equal(first, last, std::input_iterator_tag());
-   }
-*/
-   template <class InIt>
-   void priv_insert_equal(InIt first, InIt last, std::input_iterator_tag)
-   {
-      for ( ; first != last; ++first)
+      for ( ; first != last; ++first){
          this->insert_equal(*first);
+      }
+   }
+
+   template<class InIt>
+   void priv_insert_equal_loop_ordered(InIt first, InIt last)
+   {
+      const_iterator pos(this->cend());
+      for ( ; first != last; ++first){
+         pos = this->insert_equal(pos, *first);
+      }
+   }
+
+   template<class InIt>
+   void priv_insert_unique_loop(InIt first, InIt last)
+   {
+      for ( ; first != last; ++first){
+         this->insert_unique(*first);
+      }
+   }
+
+   template<class InIt>
+   void priv_insert_unique_loop_ordered(InIt first, InIt last)
+   {
+      const_iterator pos(this->cend());
+      for ( ; first != last; ++first){
+         pos = this->insert_unique(pos, *first);
+      }
    }
 };
 

3party/boost/boost/container/detail/iterators.hpp

@@ -22,10 +22,10 @@
 #include <boost/container/detail/workaround.hpp>
 #include <boost/move/move.hpp>
 #include <boost/container/allocator_traits.hpp>
+#include <boost/container/detail/type_traits.hpp>
 
 #ifdef BOOST_CONTAINER_PERFECT_FORWARDING
 #include <boost/container/detail/variadic_templates_tools.hpp>
-#include <boost/container/detail/stored_ref.hpp>
 #else
 #include <boost/container/detail/preprocessor.hpp>
 #endif
@@ -222,14 +222,12 @@ class default_construct_iterator
    default_construct_iterator operator-(Difference off) const
    {  return *this + (-off);  }
 
-   const T& operator*() const
-   { return dereference(); }
-
-   const T* operator->() const
-   { return &(dereference()); }
-
-   const T& operator[] (Difference n) const
-   { return dereference(); }
+   //This pseudo-iterator's dereference operations have no sense since value is not
+   //constructed until ::boost::container::construct_in_place is called.
+   //So comment them to catch bad uses
+   //const T& operator*() const;
+   //const T& operator[](difference_type) const;
+   //const T* operator->() const;
 
    private:
    Difference  m_num;
@@ -445,14 +443,12 @@ class emplace_iterator
    this_type operator-(difference_type off) const
    {  return *this + (-off);  }
 
-   const T& operator*() const
-   { return dereference(); }
-
-   const T& operator[](difference_type) const
-   { return dereference(); }
-
-   const T* operator->() const
-   { return &(dereference()); }
+   //This pseudo-iterator's dereference operations have no sense since value is not
+   //constructed until ::boost::container::construct_in_place is called.
+   //So comment them to catch bad uses
+   //const T& operator*() const;
+   //const T& operator[](difference_type) const;
+   //const T* operator->() const;
 
    template<class A>
    void construct_in_place(A &a, T* ptr)
@@ -506,8 +502,7 @@ struct emplace_functor
    void inplace_impl(A &a, T* ptr, const container_detail::index_tuple<IdxPack...>&)
    {
       allocator_traits<A>::construct
-         (a, ptr, container_detail::stored_ref<Args>::forward
-          (container_detail::get<IdxPack>(args_))...);
+         (a, ptr, ::boost::forward<Args>(container_detail::get<IdxPack>(args_))...);
    }
 
    container_detail::tuple<Args&...> args_;
@@ -539,10 +534,78 @@ struct emplace_functor
 
 #endif
 
+namespace container_detail {
+
+template<class T>
+struct has_iterator_category
+{
+   template <typename X>
+   static char test(int, typename X::iterator_category*);
+
+   template <typename X>
+   static int test(int, ...);
+
+   static const bool value = (1 == sizeof(test<T>(0, 0)));
+};
+
+
+template<class T, bool = has_iterator_category<T>::value >
+struct is_input_iterator
+{
+   static const bool value = is_same<typename T::iterator_category, std::input_iterator_tag>::value;
+};
+
+template<class T>
+struct is_input_iterator<T, false>
+{
+   static const bool value = false;
+};
+
+template<class T, bool = has_iterator_category<T>::value >
+struct is_forward_iterator
+{
+   static const bool value = is_same<typename T::iterator_category, std::forward_iterator_tag>::value;
+};
+
+template<class T>
+struct is_forward_iterator<T, false>
+{
+   static const bool value = false;
+};
+
+template<class T, bool = has_iterator_category<T>::value >
+struct is_bidirectional_iterator
+{
+   static const bool value = is_same<typename T::iterator_category, std::bidirectional_iterator_tag>::value;
+};
+
+template<class T>
+struct is_bidirectional_iterator<T, false>
+{
+   static const bool value = false;
+};
+
+template<class T, class IIterator>
+struct iiterator_types
+{
+   typedef typename std::iterator_traits<IIterator>::pointer         it_pointer;
+   typedef typename std::iterator_traits<IIterator>::difference_type difference_type;
+   typedef typename ::boost::intrusive::pointer_traits<it_pointer>::
+      template rebind_pointer<T>::type                               pointer;
+   typedef typename ::boost::intrusive::pointer_traits<it_pointer>::
+      template rebind_pointer<const T>::type                         const_pointer;
+   typedef typename ::boost::intrusive::
+      pointer_traits<pointer>::reference                             reference;
+   typedef typename ::boost::intrusive::
+      pointer_traits<const_pointer>::reference                       const_reference;
+};
+
+
+}  //namespace container_detail {
+
 }  //namespace container {
 }  //namespace boost {
 
 #include <boost/container/detail/config_end.hpp>
 
 #endif   //#ifndef BOOST_CONTAINER_DETAIL_ITERATORS_HPP
-

3party/boost/boost/container/detail/multiallocation_chain.hpp

@@ -45,14 +45,30 @@ class basic_multiallocation_chain
                     > slist_impl_t;
    slist_impl_t slist_impl_;
 
-   static node & to_node(VoidPointer p)
-   {  return *static_cast<node*>(static_cast<void*>(container_detail::to_raw_pointer(p))); }
+   typedef typename boost::intrusive::pointer_traits
+      <VoidPointer>::template rebind_pointer<node>::type    node_ptr;
+   typedef typename boost::intrusive::
+      pointer_traits<node_ptr>                              node_ptr_traits;
+
+   static node & build_node(const VoidPointer &p)
+   {
+      return *::new (static_cast<node*>(static_cast<void*>(container_detail::to_raw_pointer(p)))) node;
+   }
+
+   static VoidPointer destroy_node(node &n)
+   {
+      VoidPointer retptr = node_ptr_traits::pointer_to(n);
+      n.~node();
+      return retptr;
+   }
+
+   static node_ptr to_node_ptr(VoidPointer p)
+   {  return node_ptr_traits::static_cast_from(p);   }
 
    BOOST_MOVABLE_BUT_NOT_COPYABLE(basic_multiallocation_chain)
 
    public:
 
-
    typedef VoidPointer  void_pointer;
    typedef typename slist_impl_t::iterator iterator;
    typedef typename slist_impl_t::size_type size_type;
@@ -94,34 +110,38 @@ class basic_multiallocation_chain
    {  slist_impl_.clear(); }
 
    iterator insert_after(iterator it, void_pointer m)
-   {  return slist_impl_.insert_after(it, to_node(m));   }
+   {  return slist_impl_.insert_after(it, build_node(m));   }
 
    void push_front(void_pointer m)
-   {  return slist_impl_.push_front(to_node(m));   }
+   {  return slist_impl_.push_front(build_node(m));  }
 
    void push_back(void_pointer m)
-   {  return slist_impl_.push_back(to_node(m));   }
+   {  return slist_impl_.push_back(build_node(m));   }
 
-   void pop_front()
-   {  return slist_impl_.pop_front();   }
+   void_pointer pop_front()
+   {
+      node & n = slist_impl_.front();
+      void_pointer ret = destroy_node(n);
+      slist_impl_.pop_front();
+      return ret;
+   }
 
-   void *front()
-   {  return &*slist_impl_.begin();   }
+   void splice_after(iterator after_this, basic_multiallocation_chain &x, iterator before_begin_, iterator before_end)
+   {  slist_impl_.splice_after(after_this, x.slist_impl_, before_begin_, before_end);   }
 
-   void splice_after(iterator after_this, basic_multiallocation_chain &x, iterator before_begin, iterator before_end)
-   {  slist_impl_.splice_after(after_this, x.slist_impl_, before_begin, before_end);   }
-
-   void splice_after(iterator after_this, basic_multiallocation_chain &x, iterator before_begin, iterator before_end, size_type n)
-   {  slist_impl_.splice_after(after_this, x.slist_impl_, before_begin, before_end, n);   }
+   void splice_after(iterator after_this, basic_multiallocation_chain &x, iterator before_begin_, iterator before_end, size_type n)
+   {  slist_impl_.splice_after(after_this, x.slist_impl_, before_begin_, before_end, n);   }
 
    void splice_after(iterator after_this, basic_multiallocation_chain &x)
    {  slist_impl_.splice_after(after_this, x.slist_impl_);   }
 
-   void incorporate_after(iterator after_this, void_pointer begin , iterator before_end)
-   {  slist_impl_.incorporate_after(after_this, &to_node(begin), &to_node(before_end));   }
+   void incorporate_after(iterator after_this, void_pointer begin_ , iterator before_end)
+   {
+      slist_impl_.incorporate_after(after_this, to_node_ptr(begin_), to_node_ptr(before_end));
+   }
 
-   void incorporate_after(iterator after_this, void_pointer begin, void_pointer before_end, size_type n)
-   {  slist_impl_.incorporate_after(after_this, &to_node(begin), &to_node(before_end), n);   }
+   void incorporate_after(iterator after_this, void_pointer begin_, void_pointer before_end, size_type n)
+   {  slist_impl_.incorporate_after(after_this, to_node_ptr(begin_), to_node_ptr(before_end), n);   }
 
    void swap(basic_multiallocation_chain &x)
    {  slist_impl_.swap(x.slist_impl_);   }
@@ -157,18 +177,20 @@ class transform_multiallocation_chain
    MultiallocationChain   holder_;
    typedef typename MultiallocationChain::void_pointer   void_pointer;
    typedef typename boost::intrusive::pointer_traits
-      <void_pointer>::template rebind_pointer<T>::type   pointer;
+      <void_pointer>                                     void_pointer_traits;
+   typedef typename void_pointer_traits::template
+      rebind_pointer<T>::type                            pointer;
+   typedef typename boost::intrusive::pointer_traits
+      <pointer>                                          pointer_traits;
 
-   static pointer cast(void_pointer p)
-   {
-      return pointer(static_cast<T*>(container_detail::to_raw_pointer(p)));
-   }
+   static pointer cast(const void_pointer &p)
+   {  return pointer_traits::static_cast_from(p);  }
 
    public:
    typedef transform_iterator
       < typename MultiallocationChain::iterator
-      , container_detail::cast_functor <T> >                 iterator;
-   typedef typename MultiallocationChain::size_type           size_type;
+      , container_detail::cast_functor <T> >             iterator;
+   typedef typename MultiallocationChain::size_type      size_type;
 
    transform_multiallocation_chain()
       : holder_()
@@ -195,17 +217,14 @@ class transform_multiallocation_chain
    void swap(transform_multiallocation_chain &other_chain)
    {  holder_.swap(other_chain.holder_); }
 
-   void splice_after(iterator after_this, transform_multiallocation_chain &x, iterator before_begin, iterator before_end, size_type n)
-   {  holder_.splice_after(after_this.base(), x.holder_, before_begin.base(), before_end.base(), n);  }
+   void splice_after(iterator after_this, transform_multiallocation_chain &x, iterator before_begin_, iterator before_end, size_type n)
+   {  holder_.splice_after(after_this.base(), x.holder_, before_begin_.base(), before_end.base(), n);  }
 
-   void incorporate_after(iterator after_this, void_pointer begin, void_pointer before_end, size_type n)
-   {  holder_.incorporate_after(after_this.base(), begin, before_end, n);  }
+   void incorporate_after(iterator after_this, pointer begin_, pointer before_end, size_type n)
+   {  holder_.incorporate_after(after_this.base(), begin_, before_end, n);  }
 
-   void pop_front()
-   {  holder_.pop_front();  }
-
-   pointer front()
-   {  return cast(holder_.front());   }
+   pointer pop_front()
+   {  return cast(holder_.pop_front());  }
 
    bool empty() const
    {  return holder_.empty(); }
@@ -234,8 +253,11 @@ class transform_multiallocation_chain
    static iterator iterator_to(pointer p)
    {  return iterator(MultiallocationChain::iterator_to(p));  }
 
-   std::pair<void_pointer, void_pointer> extract_data()
-   {  return holder_.extract_data();  }
+   std::pair<pointer, pointer> extract_data()
+   {
+      std::pair<void_pointer, void_pointer> data(holder_.extract_data());
+      return std::pair<pointer, pointer>(cast(data.first), cast(data.second));
+   }
 
    MultiallocationChain extract_multiallocation_chain()
    {

3party/boost/boost/container/detail/node_alloc_holder.hpp

@@ -43,99 +43,6 @@ namespace boost {
 namespace container {
 namespace container_detail {
 
-//!A deleter for scoped_ptr that deallocates the memory
-//!allocated for an object using a STL allocator.
-template <class A>
-struct scoped_deallocator
-{
-   typedef allocator_traits<A> allocator_traits_type;
-   typedef typename allocator_traits_type::pointer pointer;
-   typedef container_detail::integral_constant<unsigned,
-      boost::container::container_detail::
-         version<A>::value>                   alloc_version;
-   typedef container_detail::integral_constant<unsigned, 1>     allocator_v1;
-   typedef container_detail::integral_constant<unsigned, 2>     allocator_v2;
-
-   private:
-   void priv_deallocate(allocator_v1)
-   {  m_alloc.deallocate(m_ptr, 1); }
-
-   void priv_deallocate(allocator_v2)
-   {  m_alloc.deallocate_one(m_ptr); }
-
-   BOOST_MOVABLE_BUT_NOT_COPYABLE(scoped_deallocator)
-
-   public:
-
-   pointer     m_ptr;
-   A&  m_alloc;
-
-   scoped_deallocator(pointer p, A& a)
-      : m_ptr(p), m_alloc(a)
-   {}
-
-   ~scoped_deallocator()
-   {  if (m_ptr)priv_deallocate(alloc_version());  }
-
-   scoped_deallocator(BOOST_RV_REF(scoped_deallocator) o)
-      :  m_ptr(o.m_ptr), m_alloc(o.m_alloc)
-   {  o.release();  }
-
-   pointer get() const
-   {  return m_ptr;  }
-
-   void release()
-   {  m_ptr = 0; }
-};
-
-template <class A>
-class allocator_destroyer_and_chain_builder
-{
-   typedef allocator_traits<A> allocator_traits_type;
-   typedef typename allocator_traits_type::value_type value_type;
-   typedef typename A::multiallocation_chain    multiallocation_chain;
-
-   A & a_;
-   multiallocation_chain &c_;
-
-   public:
-   allocator_destroyer_and_chain_builder(A &a, multiallocation_chain &c)
-      :  a_(a), c_(c)
-   {}
-
-   void operator()(const typename A::pointer &p)
-   {
-      allocator_traits<A>::destroy(a_, container_detail::to_raw_pointer(p));
-      c_.push_front(p);
-   }
-};
-
-template <class A>
-class allocator_multialloc_chain_node_deallocator
-{
-   typedef allocator_traits<A> allocator_traits_type;
-   typedef typename allocator_traits_type::value_type value_type;
-   typedef typename A::multiallocation_chain    multiallocation_chain;
-   typedef allocator_destroyer_and_chain_builder<A> chain_builder;
-
-   A & a_;
-   multiallocation_chain c_;
-
-   public:
-   allocator_multialloc_chain_node_deallocator(A &a)
-      :  a_(a), c_()
-   {}
-
-   chain_builder get_chain_builder()
-   {  return chain_builder(a_, c_);  }
-
-   ~allocator_multialloc_chain_node_deallocator()
-   {
-      if(!c_.empty())
-         a_.deallocate_individual(boost::move(c_));
-   }
-};
-
 template<class ValueCompare, class Node>
 struct node_compare
    :  private ValueCompare
@@ -340,8 +247,7 @@ struct node_alloc_holder
          Node *p = 0;
          BOOST_TRY{
                for(difference_type i = 0; i < n; ++i, ++beg, --constructed){
-               p = container_detail::to_raw_pointer(mem.front());
-               mem.pop_front();
+               p = container_detail::to_raw_pointer(mem.pop_front());
                //This can throw
                constructed = 0;
                boost::container::construct_in_place(this->node_alloc(), container_detail::addressof(p->m_data), beg);

3party/boost/boost/container/detail/preprocessor.hpp

@@ -16,11 +16,6 @@
 #endif
 
 #include <boost/container/detail/config_begin.hpp>
-
-#ifndef BOOST_NO_RVALUE_REFERENCES
-#include <boost/container/detail/stored_ref.hpp>
-#endif   //#ifndef BOOST_NO_RVALUE_REFERENCES
-
 #include <boost/container/detail/workaround.hpp>
 
 #ifdef BOOST_CONTAINER_PERFECT_FORWARDING
@@ -78,19 +73,10 @@ const BOOST_PP_CAT(Q, n) & BOOST_PP_CAT(q, n) \
 
 #ifndef BOOST_NO_RVALUE_REFERENCES
 
-   #if defined(BOOST_MOVE_MSVC_10_MEMBER_RVALUE_REF_BUG)
-
-   #define BOOST_CONTAINER_PP_PARAM_INIT(z, n, data) \
-   BOOST_PP_CAT(m_p, n) (static_cast<BOOST_PP_CAT(P, n)>( BOOST_PP_CAT(p, n) ))           \
-
-   #else //#if defined(BOOST_MOVE_MSVC_10_MEMBER_RVALUE_REF_BUG)
-
    #define BOOST_CONTAINER_PP_PARAM_INIT(z, n, data) \
    BOOST_PP_CAT(m_p, n) (::boost::forward< BOOST_PP_CAT(P, n) >( BOOST_PP_CAT(p, n) ))           \
    //!
 
-   #endif   //BOOST_MOVE_OLD_RVALUE_REF_BINDING_RULES
-
 #else //BOOST_NO_RVALUE_REFERENCES
 
    #define BOOST_CONTAINER_PP_PARAM_INIT(z, n, data) \
@@ -102,8 +88,68 @@ const BOOST_PP_CAT(Q, n) & BOOST_PP_CAT(q, n) \
 
    #if defined(BOOST_MOVE_MSVC_10_MEMBER_RVALUE_REF_BUG)
 
+      namespace boost {
+      namespace container {
+      namespace container_detail {
+         template<class T>
+         struct ref_holder;
+
+         template<class T>
+         struct ref_holder<T &>
+         {
+            ref_holder(T &t)
+               : t_(t)
+            {}
+            T &t_;
+            T & get() {  return t_;   }
+         };
+
+         template<class T>
+         struct ref_holder<const T>
+         {
+            ref_holder(const T &t)
+               : t_(t)
+            {}
+            const T &t_;
+            const T & get() {  return t_;   }
+         };
+
+         template<class T>
+         struct ref_holder<const T &&>
+         {
+            ref_holder(const T &t)
+               : t_(t)
+            {}
+            const T &t_;
+            const T & get() {  return t_;   }
+         };
+
+         template<class T>
+         struct ref_holder
+         {
+            ref_holder(T &&t)
+               : t_(t)
+            {}
+            T &t_;
+            T && get() {  return ::boost::move(t_);   }
+         };
+
+         template<class T>
+         struct ref_holder<T &&>
+         {
+            ref_holder(T &&t)
+               : t(t)
+            {}
+            T &t;
+            T && get()  { return ::boost::move(t_); }
+         };
+
+      }  //namespace container_detail {
+      }  //namespace container {
+      }  //namespace boost {
+
       #define BOOST_CONTAINER_PP_PARAM_DEFINE(z, n, data)  \
-      BOOST_PP_CAT(P, n) & BOOST_PP_CAT(m_p, n);            \
+         ::boost::container::container_detail::ref_holder<BOOST_PP_CAT(P, n)> BOOST_PP_CAT(m_p, n);  \
       //!
 
    #else //BOOST_MOVE_MSVC_10_MEMBER_RVALUE_REF_BUG
@@ -123,8 +169,7 @@ const BOOST_PP_CAT(Q, n) & BOOST_PP_CAT(q, n) \
 
 #if !defined(BOOST_NO_RVALUE_REFERENCES) && defined(BOOST_MOVE_MSVC_10_MEMBER_RVALUE_REF_BUG)
 
-   #define BOOST_CONTAINER_PP_MEMBER_FORWARD(z, n, data) \
-   ::boost::container::container_detail::stored_ref< BOOST_PP_CAT(P, n) >::forward( BOOST_PP_CAT(this->m_p, n) ) \
+   #define BOOST_CONTAINER_PP_MEMBER_FORWARD(z, n, data) BOOST_PP_CAT(this->m_p, n).get() \
    //!
 
 #else //!defined(BOOST_NO_RVALUE_REFERENCES) && defined(BOOST_MOVE_MSVC_10_MEMBER_RVALUE_REF_BUG)

3party/boost/boost/container/detail/stored_ref.hpp

@@ -1,92 +0,0 @@
-//////////////////////////////////////////////////////////////////////////////
-//
-// (C) Copyright Ion Gaztanaga 2008-2012. 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/container for documentation.
-//
-//////////////////////////////////////////////////////////////////////////////
-
-#ifndef BOOST_CONTAINER_DETAIL_STORED_REF_HPP
-#define BOOST_CONTAINER_DETAIL_STORED_REF_HPP
-
-#include "config_begin.hpp"
-#include <boost/container/detail/workaround.hpp>
-
-#ifndef BOOST_NO_RVALUE_REFERENCES
-
-namespace boost{
-namespace container{
-namespace container_detail{
-
-template<class T>
-struct stored_ref
-{
-
-   static T && forward(T &t)
-   #ifdef BOOST_MOVE_OLD_RVALUE_REF_BINDING_RULES
-   { return t; }
-   #else
-   { return boost::move(t); }
-   #endif
-};
-
-template<class T>
-struct stored_ref<const T>
-{
-   static const T && forward(const T &t)
-   #ifdef BOOST_MOVE_OLD_RVALUE_REF_BINDING_RULES
-   { return t; }
-   #else
-   { return static_cast<const T&&>(t); }
-   #endif
-};
-
-template<class T>
-struct stored_ref<T&&>
-{
-   static T && forward(T &t)
-   #ifdef BOOST_MOVE_OLD_RVALUE_REF_BINDING_RULES
-   { return t; }
-   #else
-   { return boost::move(t); }
-   #endif
-};
-
-template<class T>
-struct stored_ref<const T&&>
-{
-   static const T && forward(const T &t)
-   #ifdef BOOST_MOVE_OLD_RVALUE_REF_BINDING_RULES
-   { return t; }
-   #else
-   { return static_cast<const T &&>(t); }
-   #endif
-};
-
-template<class T>
-struct stored_ref<const T&>
-{
-   static const T & forward(const T &t)
-   {  return t; }
-};
-
-template<class T>
-struct stored_ref<T&>
-{
-   static T & forward(T &t)
-   {  return t; }
-};
-
-}  //namespace container_detail{
-}  //namespace container{
-}  //namespace boost{
-
-#else
-#error "This header can be included only for compiler with rvalue references"
-#endif   //BOOST_NO_RVALUE_REFERENCES
-
-#include <boost/container/detail/config_end.hpp>
-
-#endif   //BOOST_CONTAINER_DETAIL_STORED_REF_HPP

3party/boost/boost/container/detail/tree.hpp

@@ -41,7 +41,7 @@ namespace container {
 namespace container_detail {
 
 template<class Key, class Value, class KeyCompare, class KeyOfValue>
-struct value_compare_impl
+struct tree_value_compare
    :  public KeyCompare
 {
    typedef Value        value_type;
@@ -49,7 +49,7 @@ struct value_compare_impl
    typedef KeyOfValue   key_of_value;
    typedef Key          key_type;
 
-   value_compare_impl(const key_compare &kcomp)
+   tree_value_compare(const key_compare &kcomp)
       :  key_compare(kcomp)
    {}
 
@@ -209,13 +209,13 @@ class rbtree
    : protected container_detail::node_alloc_holder
       < A
       , typename container_detail::intrusive_rbtree_type
-         <A, value_compare_impl<Key, Value, KeyCompare, KeyOfValue> 
+         <A, tree_value_compare<Key, Value, KeyCompare, KeyOfValue> 
          >::type
       , KeyCompare
       >
 {
    typedef typename container_detail::intrusive_rbtree_type
-         < A, value_compare_impl
+         < A, tree_value_compare
             <Key, Value, KeyCompare, KeyOfValue>
          >::type                                            Icont;
    typedef container_detail::node_alloc_holder 
@@ -315,7 +315,7 @@ class rbtree
    typedef Value                                      value_type;
    typedef A                                          allocator_type;
    typedef KeyCompare                                 key_compare;
-   typedef value_compare_impl< Key, Value
+   typedef tree_value_compare< Key, Value
                         , KeyCompare, KeyOfValue>     value_compare;
    typedef typename boost::container::
       allocator_traits<A>::pointer                    pointer;
@@ -476,21 +476,77 @@ class rbtree
    {}
 
    template <class InputIterator>
-   rbtree(InputIterator first, InputIterator last, const key_compare& comp,
-          const allocator_type& a, bool unique_insertion)
+   rbtree(bool unique_insertion, InputIterator first, InputIterator last, const key_compare& comp,
+          const allocator_type& a
+      #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
+      , typename container_detail::enable_if_c
+         < container_detail::is_input_iterator<InputIterator>::value
+            || container_detail::is_same<alloc_version, allocator_v1>::value
+         >::type * = 0
+      #endif
+         )
       : AllocHolder(a, comp)
    {
-      typedef typename std::iterator_traits<InputIterator>::iterator_category ItCat;
-      priv_create_and_insert_nodes(first, last, unique_insertion, alloc_version(), ItCat());
+      if(unique_insertion){
+         this->insert_unique(first, last);
+      }
+      else{
+         this->insert_equal(first, last);
+      }
+   }
+
+   template <class InputIterator>
+   rbtree(bool unique_insertion, InputIterator first, InputIterator last, const key_compare& comp,
+          const allocator_type& a
+      #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
+      , typename container_detail::enable_if_c
+         < !(container_detail::is_input_iterator<InputIterator>::value
+            || container_detail::is_same<alloc_version, allocator_v1>::value)
+         >::type * = 0
+      #endif
+         )
+      : AllocHolder(a, comp)
+   {
+      if(unique_insertion){
+         this->insert_unique(first, last);
+      }
+      else{
+         //Optimized allocation and construction
+         this->allocate_many_and_construct
+            (first, std::distance(first, last), insert_equal_end_hint_functor(this->icont()));
+      }
    }
 
    template <class InputIterator>
    rbtree( ordered_range_t, InputIterator first, InputIterator last
-         , const key_compare& comp = key_compare(), const allocator_type& a = allocator_type())
+         , const key_compare& comp = key_compare(), const allocator_type& a = allocator_type()
+         #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
+         , typename container_detail::enable_if_c
+            < container_detail::is_input_iterator<InputIterator>::value
+               || container_detail::is_same<alloc_version, allocator_v1>::value
+            >::type * = 0
+         #endif
+         )
       : AllocHolder(a, comp)
    {
-      typedef typename std::iterator_traits<InputIterator>::iterator_category ItCat;
-      priv_create_and_insert_ordered_nodes(first, last, alloc_version(), ItCat());
+      this->insert_equal(first, last);
+   }
+
+   template <class InputIterator>
+   rbtree( ordered_range_t, InputIterator first, InputIterator last
+         , const key_compare& comp = key_compare(), const allocator_type& a = allocator_type()
+         #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
+         , typename container_detail::enable_if_c
+            < !(container_detail::is_input_iterator<InputIterator>::value
+               || container_detail::is_same<alloc_version, allocator_v1>::value)
+            >::type * = 0
+         #endif
+         )
+      : AllocHolder(a, comp)
+   {
+      //Optimized allocation and construction
+      this->allocate_many_and_construct
+         (first, std::distance(first, last), push_back_functor(this->icont()));
    }
 
    rbtree(const rbtree& x)
@@ -943,14 +999,14 @@ class rbtree
    {  return const_iterator(this->non_const_icont().upper_bound(k, KeyNodeCompare(value_comp())));  }
 
    std::pair<iterator,iterator> equal_range(const key_type& k)
-   { 
+   {
       std::pair<iiterator, iiterator> ret =
          this->icont().equal_range(k, KeyNodeCompare(value_comp()));
       return std::pair<iterator,iterator>(iterator(ret.first), iterator(ret.second));
    }
 
    std::pair<const_iterator, const_iterator> equal_range(const key_type& k) const
-   { 
+   {
       std::pair<iiterator, iiterator> ret =
          this->non_const_icont().equal_range(k, KeyNodeCompare(value_comp()));
       return std::pair<const_iterator,const_iterator>
@@ -958,108 +1014,39 @@ class rbtree
    }
 
    private:
-   //Iterator range version
-   template<class InpIterator>
-   void priv_create_and_insert_nodes
-      (InpIterator beg, InpIterator end, bool unique, allocator_v1, std::input_iterator_tag)
-   {
-      if(unique){
-         for (; beg != end; ++beg){
-            this->insert_unique(*beg);
-         }
-      }
-      else{
-         for (; beg != end; ++beg){
-            this->insert_equal(*beg);
-         }
-      }
-   }
 
-   template<class InpIterator>
-   void priv_create_and_insert_nodes
-      (InpIterator beg, InpIterator end, bool unique, allocator_v2, std::input_iterator_tag)
-   {  //Just forward to the default one
-      priv_create_and_insert_nodes(beg, end, unique, allocator_v1(), std::input_iterator_tag());
-   }
+   class insert_equal_end_hint_functor;
+   friend class insert_equal_end_hint_functor;
 
-   class insertion_functor;
-   friend class insertion_functor;
-
-   class insertion_functor
+   class insert_equal_end_hint_functor
    {
       Icont &icont_;
+      const iconst_iterator cend_;
 
       public:
-      insertion_functor(Icont &icont)
-         :  icont_(icont)
+      insert_equal_end_hint_functor(Icont &icont)
+         :  icont_(icont), cend_(this->icont_.cend())
       {}
 
       void operator()(Node &n)
-      {  this->icont_.insert_equal(this->icont_.cend(), n); }
+      {  this->icont_.insert_equal(cend_, n); }
    };
 
+   class push_back_functor;
+   friend class push_back_functor;
 
-   template<class FwdIterator>
-   void priv_create_and_insert_nodes
-      (FwdIterator beg, FwdIterator end, bool unique, allocator_v2, std::forward_iterator_tag)
-   {
-      if(beg != end){
-         if(unique){
-            priv_create_and_insert_nodes(beg, end, unique, allocator_v2(), std::input_iterator_tag());
-         }
-         else{
-            //Optimized allocation and construction
-            this->allocate_many_and_construct
-               (beg, std::distance(beg, end), insertion_functor(this->icont()));
-         }
-      }
-   }
-
-   //Iterator range version
-   template<class InpIterator>
-   void priv_create_and_insert_ordered_nodes
-      (InpIterator beg, InpIterator end, allocator_v1, std::input_iterator_tag)
-   {
-      const_iterator cend_n(this->cend());
-      for (; beg != end; ++beg){
-         this->insert_before(cend_n, *beg);
-      }
-   }
-
-   template<class InpIterator>
-   void priv_create_and_insert_ordered_nodes
-      (InpIterator beg, InpIterator end, allocator_v2, std::input_iterator_tag)
-   {  //Just forward to the default one
-      priv_create_and_insert_ordered_nodes(beg, end, allocator_v1(), std::input_iterator_tag());
-   }
-
-   class back_insertion_functor;
-   friend class back_insertion_functor;
-
-   class back_insertion_functor
+   class push_back_functor
    {
       Icont &icont_;
 
       public:
-      back_insertion_functor(Icont &icont)
+      push_back_functor(Icont &icont)
          :  icont_(icont)
       {}
 
       void operator()(Node &n)
       {  this->icont_.push_back(n); }
    };
-
-
-   template<class FwdIterator>
-   void priv_create_and_insert_ordered_nodes
-      (FwdIterator beg, FwdIterator end, allocator_v2, std::forward_iterator_tag)
-   {
-      if(beg != end){
-         //Optimized allocation and construction
-         this->allocate_many_and_construct
-            (beg, std::distance(beg, end), back_insertion_functor(this->icont()));
-      }
-   }
 };
 
 template <class Key, class Value, class KeyOfValue,

3party/boost/boost/container/detail/utilities.hpp

@@ -122,36 +122,6 @@ struct ct_rounded_size
 {
    enum { value = ((OrigSize-1)/RoundTo+1)*RoundTo };
 };
-/*
-template <class _TypeT>
-struct __rw_is_enum
-{
-   struct _C_no { };
-   struct _C_yes { int _C_dummy [2]; };
-
-   struct _C_indirect {
-   // prevent classes with user-defined conversions from matching
-
-   // use double to prevent float->int gcc conversion warnings
-   _C_indirect (double);
-};
-
-// nested struct gets rid of bogus gcc errors
-struct _C_nest {
-   // supply first argument to prevent HP aCC warnings
-   static _C_no _C_is (int, ...);
-   static _C_yes _C_is (int, _C_indirect);
-
-   static _TypeT _C_make_T ();
-};
-
-enum {
-   _C_val = sizeof (_C_yes) == sizeof (_C_nest::_C_is (0, _C_nest::_C_make_T ()))
-   && !::boost::is_fundamental<_TypeT>::value
-};
-
-};
-*/
 
 template<class T>
 struct move_const_ref_type

3party/boost/boost/container/detail/workaround.hpp

@@ -31,6 +31,10 @@
    #define BOOST_CONTAINER_UNIMPLEMENTED_PACK_EXPANSION_TO_FIXED_LIST
 #endif
 
+//Macros for documentation purposes. For code, expands to the argument
+#define BOOST_CONTAINER_IMPDEF(TYPE) TYPE
+#define BOOST_CONTAINER_SEEDOC(TYPE) TYPE
+
 #include <boost/container/detail/config_end.hpp>
 
 #endif   //#ifndef BOOST_CONTAINER_DETAIL_WORKAROUND_HPP

3party/boost/boost/container/scoped_allocator.hpp

@@ -47,10 +47,10 @@ namespace boost { namespace container {
 //! ill-formed.
 //!
 //! [Example:
-//!  template <class T, class A = allocator<T> >  
+//!  template <class T, class Allocator = allocator<T> >  
 //!  class Z {
 //!    public:
-//!      typedef A allocator_type;
+//!      typedef Allocator allocator_type;
 //!
 //!    // Default constructor with optional allocator suffix
 //!    Z(const allocator_type& a = allocator_type());
@@ -61,8 +61,8 @@ namespace boost { namespace container {
 //! };
 //!
 //! // Specialize trait for class template Z
-//! template <class T, class A = allocator<T> >
-//! struct constructible_with_allocator_suffix<Z<T,A> > 
+//! template <class T, class Allocator = allocator<T> >
+//! struct constructible_with_allocator_suffix<Z<T,Allocator> > 
 //!      : ::boost::true_type { };
 //! -- end example]
 //!
@@ -91,10 +91,10 @@ struct constructible_with_allocator_suffix
 //! a constructor, then the program is ill-formed.
 //!
 //! [Example:
-//! template <class T, class A = allocator<T> >
+//! template <class T, class Allocator = allocator<T> >
 //! class Y {
 //!    public:
-//!       typedef A allocator_type;
+//!       typedef Allocator allocator_type;
 //! 
 //!       // Default constructor with and allocator-extended default constructor
 //!       Y();
@@ -111,8 +111,8 @@ struct constructible_with_allocator_suffix
 //! };
 //! 
 //! // Specialize trait for class template Y
-//! template <class T, class A = allocator<T> >
-//! struct constructible_with_allocator_prefix<Y<T,A> > 
+//! template <class T, class Allocator = allocator<T> >
+//! struct constructible_with_allocator_prefix<Y<T,Allocator> > 
 //!       : ::boost::true_type { };
 //! 
 //! -- end example]
@@ -1036,16 +1036,16 @@ class scoped_allocator_adaptor
    typedef typename outer_traits_type::const_pointer        const_pointer;
    typedef typename outer_traits_type::void_pointer         void_pointer;
    typedef typename outer_traits_type::const_void_pointer   const_void_pointer;
-   //! Type: `true_type` if `allocator_traits<A>::propagate_on_container_copy_assignment::value` is
-   //! true for any `A` in the set of `OuterAlloc` and `InnerAllocs...`; otherwise, false_type.
+   //! Type: `true_type` if `allocator_traits<Allocator>::propagate_on_container_copy_assignment::value` is
+   //! true for any `Allocator` in the set of `OuterAlloc` and `InnerAllocs...`; otherwise, false_type.
    typedef typename base_type::
       propagate_on_container_copy_assignment                propagate_on_container_copy_assignment;
-   //! Type: `true_type` if `allocator_traits<A>::propagate_on_container_move_assignment::value` is
-   //! true for any `A` in the set of `OuterAlloc` and `InnerAllocs...`; otherwise, false_type.
+   //! Type: `true_type` if `allocator_traits<Allocator>::propagate_on_container_move_assignment::value` is
+   //! true for any `Allocator` in the set of `OuterAlloc` and `InnerAllocs...`; otherwise, false_type.
    typedef typename base_type::
       propagate_on_container_move_assignment                propagate_on_container_move_assignment;
-   //! Type: `true_type` if `allocator_traits<A>::propagate_on_container_swap::value` is true for any
-   //! `A` in the set of `OuterAlloc` and `InnerAllocs...`; otherwise, false_type.
+   //! Type: `true_type` if `allocator_traits<Allocator>::propagate_on_container_swap::value` is true for any
+   //! `Allocator` in the set of `OuterAlloc` and `InnerAllocs...`; otherwise, false_type.
    typedef typename base_type::
       propagate_on_container_swap                           propagate_on_container_swap;
 
@@ -1211,9 +1211,9 @@ class scoped_allocator_adaptor
       outer_traits_type::deallocate(this->outer_allocator(), p, n);
    }
 
-   //! <b>Returns</b>: A new scoped_allocator_adaptor object where each allocator
+   //! <b>Returns</b>: Allocator new scoped_allocator_adaptor object where each allocator
    //! A in the adaptor is initialized from the result of calling
-   //! `allocator_traits<A>::select_on_container_copy_construction()` on
+   //! `allocator_traits<Allocator>::select_on_container_copy_construction()` on
    //! the corresponding allocator in *this.
    scoped_allocator_adaptor select_on_container_copy_construction() const
    {

3party/boost/boost/context/all.hpp

@@ -4,11 +4,12 @@
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
 
-#ifndef BOOST_CTX_ALL_H
-#define BOOST_CTX_ALL_H
+#ifndef BOOST_CONTEXT_ALL_H
+#define BOOST_CONTEXT_ALL_H
 
 #include <boost/context/fcontext.hpp>
-#include <boost/context/stack_allocator.hpp>
-#include <boost/context/stack_utils.hpp>
+#include <boost/context/guarded_stack_allocator.hpp>
+#include <boost/context/simple_stack_allocator.hpp>
+#include <boost/context/utils.hpp>
 
-#endif // BOOST_CTX_ALL_H
+#endif // BOOST_CONTEXT_ALL_H

3party/boost/boost/context/detail/config.hpp

@@ -4,8 +4,8 @@
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
 
-#ifndef BOOST_CTX_DETAIL_CONFIG_H
-#define BOOST_CTX_DETAIL_CONFIG_H
+#ifndef BOOST_CONTEXT_DETAIL_CONFIG_H
+#define BOOST_CONTEXT_DETAIL_CONFIG_H
 
 #include <boost/config.hpp>
 #include <boost/detail/workaround.hpp>
@@ -39,4 +39,4 @@
 # include <boost/config/auto_link.hpp>
 #endif
 
-#endif // BOOST_CTX_DETAIL_CONFIG_H
+#endif // BOOST_CONTEXT_DETAIL_CONFIG_H

3party/boost/boost/context/detail/fcontext_arm.hpp

@@ -4,8 +4,10 @@
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
 
-#ifndef BOOST_CTX_DETAIL_FCONTEXT_ARM_H
-#define BOOST_CTX_DETAIL_FCONTEXT_ARM_H
+#ifndef BOOST_CONTEXT_DETAIL_FCONTEXT_ARM_H
+#define BOOST_CONTEXT_DETAIL_FCONTEXT_ARM_H
+
+#include <cstddef>
 
 #include <boost/config.hpp>
 #include <boost/cstdint.hpp>
@@ -17,7 +19,7 @@
 #endif
 
 namespace boost {
-namespace ctx {
+namespace context {
 
 extern "C" {
 
@@ -25,11 +27,11 @@ extern "C" {
 
 struct stack_t
 {
-    void    *   base;
-    void    *   limit;
+    void    *   sp;
+    std::size_t size;
 
     stack_t() :
-        base( 0), limit( 0)
+        sp( 0), size( 0)
     {}
 };
 
@@ -63,4 +65,4 @@ struct fcontext_t
 # include BOOST_ABI_SUFFIX
 #endif
 
-#endif // BOOST_CTX_DETAIL_FCONTEXT_ARM_H
+#endif // BOOST_CONTEXT_DETAIL_FCONTEXT_ARM_H

3party/boost/boost/context/detail/fcontext_i386.hpp

@@ -4,8 +4,8 @@
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
 
-#ifndef BOOST_CTX_DETAIL_FCONTEXT_I386H
-#define BOOST_CTX_DETAIL_FCONTEXT_I386H
+#ifndef BOOST_CONTEXT_DETAIL_FCONTEXT_I386H
+#define BOOST_CONTEXT_DETAIL_FCONTEXT_I386H
 
 #include <cstddef>
 
@@ -19,7 +19,7 @@
 #endif
 
 namespace boost {
-namespace ctx {
+namespace context {
 
 extern "C" {
 
@@ -27,20 +27,11 @@ extern "C" {
 
 struct stack_t
 {
-    void    *   base;
-    void    *   limit;
+    void            *   sp;
+    std::size_t         size;
 
     stack_t() :
-        base( 0), limit( 0)
-    {}
-};
-
-struct fp_t
-{
-    boost::uint32_t     fc_freg[2];
-
-    fp_t() :
-        fc_freg()
+        sp( 0), size( 0)
     {}
 };
 
@@ -48,12 +39,12 @@ struct fcontext_t
 {
     boost::uint32_t     fc_greg[6];
     stack_t             fc_stack;
-    fp_t                fc_fp;
+    boost::uint32_t     fc_freg[2];
 
     fcontext_t() :
         fc_greg(),
         fc_stack(),
-        fc_fp()
+        fc_freg()
     {}
 };
 
@@ -65,4 +56,4 @@ struct fcontext_t
 # include BOOST_ABI_SUFFIX
 #endif
 
-#endif // BOOST_CTX_DETAIL_FCONTEXT_I386_H
+#endif // BOOST_CONTEXT_DETAIL_FCONTEXT_I386_H

3party/boost/boost/context/detail/fcontext_i386_win.hpp

@@ -4,13 +4,15 @@
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
 
-#ifndef BOOST_CTX_DETAIL_FCONTEXT_I386H
-#define BOOST_CTX_DETAIL_FCONTEXT_I386H
+#ifndef BOOST_CONTEXT_DETAIL_FCONTEXT_I386H
+#define BOOST_CONTEXT_DETAIL_FCONTEXT_I386H
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1020)
 # pragma once
 #endif
 
+#include <cstddef>
+
 #include <boost/config.hpp>
 #include <boost/cstdint.hpp>
 
@@ -26,7 +28,7 @@
 #endif
 
 namespace boost {
-namespace ctx {
+namespace context {
 
 extern "C" {
 
@@ -34,11 +36,12 @@ extern "C" {
 
 struct stack_t
 {
-    void    *   base;
+    void    *   sp;
+    std::size_t size;
     void    *   limit;
 
     stack_t() :
-        base( 0), limit( 0)
+        sp( 0), size( 0), limit( 0)
     {}
 };
 
@@ -80,4 +83,4 @@ struct fcontext_t
 #pragma warning(pop)
 #endif
 
-#endif // BOOST_CTX_DETAIL_FCONTEXT_I386_H
+#endif // BOOST_CONTEXT_DETAIL_FCONTEXT_I386_H

3party/boost/boost/context/detail/fcontext_mips.hpp

@@ -4,8 +4,10 @@
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
 
-#ifndef BOOST_CTX_DETAIL_FCONTEXT_MIPS_H
-#define BOOST_CTX_DETAIL_FCONTEXT_MIPS_H
+#ifndef BOOST_CONTEXT_DETAIL_FCONTEXT_MIPS_H
+#define BOOST_CONTEXT_DETAIL_FCONTEXT_MIPS_H
+
+#include <cstddef>
 
 #include <boost/config.hpp>
 #include <boost/cstdint.hpp>
@@ -17,7 +19,7 @@
 #endif
 
 namespace boost {
-namespace ctx {
+namespace context {
 
 extern "C" {
 
@@ -27,11 +29,11 @@ extern "C" {
 
 struct stack_t
 {
-    void    *   base;
-    void    *   limit;
+    void    *   sp;
+    std::size_t size;
 
     stack_t() :
-        base( 0), limit( 0)
+        sp( 0), size( 0)
     {}
 };
 
@@ -46,7 +48,7 @@ struct fp_t
 
 struct fcontext_t
 {
-    boost::uint64_t     fc_greg[13];
+    boost::uint32_t     fc_greg[12];
     stack_t             fc_stack;
     fp_t                fc_fp;
 
@@ -65,4 +67,4 @@ struct fcontext_t
 # include BOOST_ABI_SUFFIX
 #endif
 
-#endif // BOOST_CTX_DETAIL_FCONTEXT_MIPS_H
+#endif // BOOST_CONTEXT_DETAIL_FCONTEXT_MIPS_H

3party/boost/boost/context/detail/fcontext_ppc.hpp

@@ -4,8 +4,10 @@
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
 
-#ifndef BOOST_CTX_DETAIL_FCONTEXT_PPC_H
-#define BOOST_CTX_DETAIL_FCONTEXT_PPC_H
+#ifndef BOOST_CONTEXT_DETAIL_FCONTEXT_PPC_H
+#define BOOST_CONTEXT_DETAIL_FCONTEXT_PPC_H
+
+#include <cstddef>
 
 #include <boost/config.hpp>
 #include <boost/cstdint.hpp>
@@ -17,7 +19,7 @@
 #endif
 
 namespace boost {
-namespace ctx {
+namespace context {
 
 extern "C" {
 
@@ -25,11 +27,11 @@ extern "C" {
 
 struct stack_t
 {
-    void    *   base;
-    void    *   limit;
+    void    *   sp;
+    std::size_t size;
 
     stack_t() :
-        base( 0), limit( 0)
+        sp( 0), size( 0)
     {}
 };
 
@@ -67,4 +69,4 @@ struct fcontext_t
 # include BOOST_ABI_SUFFIX
 #endif
 
-#endif // BOOST_CTX_DETAIL_FCONTEXT_PPC_H
+#endif // BOOST_CONTEXT_DETAIL_FCONTEXT_PPC_H

3party/boost/boost/context/detail/fcontext_x86_64.hpp

@@ -4,8 +4,10 @@
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
 
-#ifndef BOOST_CTX_DETAIL_FCONTEXT_X86_64_H
-#define BOOST_CTX_DETAIL_FCONTEXT_X86_64_H
+#ifndef BOOST_CONTEXT_DETAIL_FCONTEXT_X86_64_H
+#define BOOST_CONTEXT_DETAIL_FCONTEXT_X86_64_H
+
+#include <cstddef>
 
 #include <boost/config.hpp>
 #include <boost/cstdint.hpp>
@@ -17,7 +19,7 @@
 #endif
 
 namespace boost {
-namespace ctx {
+namespace context {
 
 extern "C" {
 
@@ -25,11 +27,11 @@ extern "C" {
 
 struct stack_t
 {
-    void    *   base;
-    void    *   limit;
+    void    *   sp;
+    std::size_t size;
 
     stack_t() :
-        base( 0), limit( 0)
+        sp( 0), size( 0)
     {}
 };
 
@@ -63,4 +65,4 @@ struct fcontext_t
 # include BOOST_ABI_SUFFIX
 #endif
 
-#endif // BOOST_CTX_DETAIL_FCONTEXT_X86_64_H
+#endif // BOOST_CONTEXT_DETAIL_FCONTEXT_X86_64_H

3party/boost/boost/context/detail/fcontext_x86_64_win.hpp

@@ -4,14 +4,15 @@
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
 
-#ifndef BOOST_CTX_DETAIL_FCONTEXT_X86_64_H
-#define BOOST_CTX_DETAIL_FCONTEXT_X86_64_H
+#ifndef BOOST_CONTEXT_DETAIL_FCONTEXT_X86_64_H
+#define BOOST_CONTEXT_DETAIL_FCONTEXT_X86_64_H
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1020)
 # pragma once
 #endif
 
-#include <boost/assert.hpp>
+#include <cstddef>
+
 #include <boost/config.hpp>
 #include <boost/cstdint.hpp>
 
@@ -27,7 +28,7 @@
 #endif
 
 namespace boost {
-namespace ctx {
+namespace context {
 
 extern "C" {
 
@@ -35,11 +36,12 @@ extern "C" {
 
 struct stack_t
 {
-    void    *   base;
+    void    *   sp;
+    std::size_t size;
     void    *   limit;
 
     stack_t() :
-        base( 0), limit( 0)
+        sp( 0), size( 0), limit( 0)
     {}
 };
 
@@ -87,4 +89,4 @@ struct fcontext_t
 #pragma warning(pop)
 #endif
 
-#endif // BOOST_CTX_DETAIL_FCONTEXT_X86_64_H
+#endif // BOOST_CONTEXT_DETAIL_FCONTEXT_X86_64_H

3party/boost/boost/context/fcontext.hpp

@@ -4,8 +4,8 @@
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
 
-#ifndef BOOST_CTX_FCONTEXT_H
-#define BOOST_CTX_FCONTEXT_H
+#ifndef BOOST_CONTEXT_FCONTEXT_H
+#define BOOST_CONTEXT_FCONTEXT_H
 
 #if defined(__PGI)
 #include <stdint.h>
@@ -60,7 +60,7 @@
 #endif
 
 namespace boost {
-namespace ctx {
+namespace context {
 namespace detail {
 
 extern "C" BOOST_CONTEXT_DECL void * BOOST_CONTEXT_CALLDECL align_stack( void * vp);
@@ -70,7 +70,7 @@ extern "C" BOOST_CONTEXT_DECL void * BOOST_CONTEXT_CALLDECL align_stack( void *
 extern "C" BOOST_CONTEXT_DECL
 intptr_t BOOST_CONTEXT_CALLDECL jump_fcontext( fcontext_t * ofc, fcontext_t const* nfc, intptr_t vp, bool preserve_fpu = true);
 extern "C" BOOST_CONTEXT_DECL
-void BOOST_CONTEXT_CALLDECL make_fcontext( fcontext_t * fc, void (* fn)( intptr_t) );
+fcontext_t * BOOST_CONTEXT_CALLDECL make_fcontext( void * sp, std::size_t size, void (* fn)( intptr_t) );
 
 }}
 
@@ -78,5 +78,5 @@ void BOOST_CONTEXT_CALLDECL make_fcontext( fcontext_t * fc, void (* fn)( intptr_
 # include BOOST_ABI_SUFFIX
 #endif
 
-#endif // BOOST_CTX_FCONTEXT_H
+#endif // BOOST_CONTEXT_FCONTEXT_H
 

3party/boost/boost/context/guarded_stack_allocator.hpp

@@ -0,0 +1,55 @@
+
+//          Copyright Oliver Kowalke 2009.
+// 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)
+
+#ifndef BOOST_CONTEXT_GUARDED_STACK_ALLOCATOR_H
+#define BOOST_CONTEXT_GUARDED_STACK_ALLOCATOR_H
+
+#include <boost/config.hpp>
+
+#if ! defined (BOOST_WINDOWS)
+extern "C" {
+#include <unistd.h>
+}
+#endif
+
+//#if defined (BOOST_WINDOWS) || _POSIX_C_SOURCE >= 200112L
+
+#include <cstddef>
+
+#include <boost/context/detail/config.hpp>
+
+#ifdef BOOST_HAS_ABI_HEADERS
+#  include BOOST_ABI_PREFIX
+#endif
+
+namespace boost {
+namespace context {
+
+class BOOST_CONTEXT_DECL guarded_stack_allocator
+{
+public:
+    static bool is_stack_unbound();
+
+    static std::size_t default_stacksize();
+
+    static std::size_t minimum_stacksize();
+
+    static std::size_t maximum_stacksize();
+
+    void * allocate( std::size_t) const;
+
+    void deallocate( void *, std::size_t) const;
+};
+
+}}
+
+#ifdef BOOST_HAS_ABI_HEADERS
+#  include BOOST_ABI_SUFFIX
+#endif
+
+//#endif
+
+#endif // BOOST_CONTEXT_GUARDED_STACK_ALLOCATOR_H

3party/boost/boost/context/simple_stack_allocator.hpp

@@ -0,0 +1,67 @@
+
+//          Copyright Oliver Kowalke 2009.
+// 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)
+
+#ifndef BOOST_CONTEXT_SIMPLE_STACK_ALLOCATOR_H
+#define BOOST_CONTEXT_SIMPLE_STACK_ALLOCATOR_H
+
+#include <cstddef>
+#include <cstdlib>
+#include <stdexcept>
+
+#include <boost/assert.hpp>
+#include <boost/config.hpp>
+
+#include <boost/context/detail/config.hpp>
+
+#ifdef BOOST_HAS_ABI_HEADERS
+#  include BOOST_ABI_PREFIX
+#endif
+
+namespace boost {
+namespace context {
+
+template< std::size_t Max, std::size_t Default, std::size_t Min >
+class simple_stack_allocator
+{
+public:
+    static std::size_t maximum_stacksize()
+    { return Max; }
+
+    static std::size_t default_stacksize()
+    { return Default; }
+
+    static std::size_t minimum_stacksize()
+    { return Min; }
+
+    void * allocate( std::size_t size) const
+    {
+        BOOST_ASSERT( minimum_stacksize() <= size);
+        BOOST_ASSERT( maximum_stacksize() >= size);
+
+        void * limit = std::calloc( size, sizeof( char) );
+        if ( ! limit) throw std::bad_alloc();
+
+        return static_cast< char * >( limit) + size;
+    }
+
+    void deallocate( void * vp, std::size_t size) const
+    {
+        BOOST_ASSERT( vp);
+        BOOST_ASSERT( minimum_stacksize() <= size);
+        BOOST_ASSERT( maximum_stacksize() >= size);
+
+        void * limit = static_cast< char * >( vp) - size;
+        std::free( limit);
+    }
+};
+
+}}
+
+#ifdef BOOST_HAS_ABI_HEADERS
+#  include BOOST_ABI_SUFFIX
+#endif
+
+#endif // BOOST_CONTEXT_SIMPLE_STACK_ALLOCATOR_H

3party/boost/boost/context/stack_utils.hpp

@@ -1,41 +0,0 @@
-
-//          Copyright Oliver Kowalke 2009.
-// 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)
-
-#ifndef BOOST_CTX_STACK_UTILS_H
-#define BOOST_CTX_STACK_UTILS_H
-
-#include <cstddef>
-
-#include <boost/config.hpp>
-
-#include <boost/context/detail/config.hpp>
-
-#ifdef BOOST_HAS_ABI_HEADERS
-# include BOOST_ABI_PREFIX
-#endif
-
-namespace boost {
-namespace ctx {
-
-BOOST_CONTEXT_DECL std::size_t default_stacksize();
-
-BOOST_CONTEXT_DECL std::size_t minimum_stacksize();
-
-BOOST_CONTEXT_DECL std::size_t maximum_stacksize();
-
-BOOST_CONTEXT_DECL std::size_t pagesize();
-
-BOOST_CONTEXT_DECL std::size_t page_count( std::size_t stacksize);
-
-BOOST_CONTEXT_DECL bool is_stack_unbound();
-
-}}
-
-#ifdef BOOST_HAS_ABI_HEADERS
-# include BOOST_ABI_SUFFIX
-#endif
-
-#endif // BOOST_CTX_STACK_UTILS_H

3party/boost/boost/context/utils.hpp

@@ -4,13 +4,21 @@
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
 
-#ifndef BOOST_CTX_STACK_ALLOCATOR_H
-#define BOOST_CTX_STACK_ALLOCATOR_H
-
-#include <cstddef>
+#ifndef BOOST_CONTEXT_UTILS_H
+#define BOOST_CONTEXT_UTILS_H
 
 #include <boost/config.hpp>
 
+#if ! defined (BOOST_WINDOWS)
+extern "C" {
+#include <unistd.h>
+}
+#endif
+
+//#if defined (BOOST_WINDOWS) || _POSIX_C_SOURCE >= 200112L
+
+#include <cstddef>
+
 #include <boost/context/detail/config.hpp>
 
 #ifdef BOOST_HAS_ABI_HEADERS
@@ -18,15 +26,9 @@
 #endif
 
 namespace boost {
-namespace ctx {
+namespace context {
 
-class BOOST_CONTEXT_DECL stack_allocator
-{
-public:
-    void * allocate( std::size_t) const;
-
-    void deallocate( void *, std::size_t) const;
-};
+BOOST_CONTEXT_DECL std::size_t pagesize();
 
 }}
 
@@ -34,4 +36,6 @@ public:
 #  include BOOST_ABI_SUFFIX
 #endif
 
-#endif // BOOST_CTX_STACK_ALLOCATOR_H
+//#endif
+
+#endif // BOOST_CONTEXT_UTILS_H

3party/boost/boost/date_time/c_time.hpp

@@ -6,7 +6,7 @@
  * Boost Software License, Version 1.0. (See accompanying
  * file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
  * Author: Jeff Garland, Bart Garst
- * $Date: 2012-07-27 11:15:55 -0700 (Fri, 27 Jul 2012) $
+ * $Date: 2012-09-22 09:04:10 -0700 (Sat, 22 Sep 2012) $
  */
 
 

3party/boost/boost/date_time/date.hpp

@@ -6,7 +6,7 @@
  * Boost Software License, Version 1.0. (See accompanying
  * file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
  * Author: Jeff Garland, Bart Garst
- * $Date: 2010-01-10 11:17:23 -0800 (Sun, 10 Jan 2010) $
+ * $Date: 2012-09-22 15:33:33 -0700 (Sat, 22 Sep 2012) $
  */
 
 #include <boost/operators.hpp>
@@ -191,8 +191,8 @@ namespace date_time {
       dates.  It is not exposed to users since that would require class
       users to understand the inner workings of the date class.
     */
-    explicit date(date_int_type days) : days_(days) {};
-    explicit date(date_rep_type days) : days_(days.as_number()) {};
+    explicit date(date_int_type days) : days_(days) {}
+    explicit date(date_rep_type days) : days_(days.as_number()) {}
     date_int_type days_;
 
   };

3party/boost/boost/date_time/date_duration.hpp

@@ -2,11 +2,11 @@
 #define DATE_TIME_DATE_DURATION__
 
 /* Copyright (c) 2002,2003 CrystalClear Software, Inc.
- * Use, modification and distribution is subject to the 
+ * Use, modification and distribution is subject to the
  * Boost Software License, Version 1.0. (See accompanying
  * file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
  * Author: Jeff Garland, Bart Garst
- * $Date: 2008-11-12 11:37:53 -0800 (Wed, 12 Nov 2008) $
+ * $Date: 2012-09-22 15:33:33 -0700 (Sat, 22 Sep 2012) $
  */
 
 
@@ -26,14 +26,14 @@ namespace date_time {
             , boost::subtractable1< date_duration< duration_rep_traits >
             , boost::dividable2< date_duration< duration_rep_traits >, int
             > > > > >
-  { 
+  {
   public:
     typedef typename duration_rep_traits::int_type duration_rep_type;
     typedef typename duration_rep_traits::impl_type duration_rep;
-    
+
     //! Construct from a day count
-    explicit date_duration(duration_rep day_count) : days_(day_count) {};
-    
+    explicit date_duration(duration_rep day_count) : days_(day_count) {}
+
     /*! construct from special_values - only works when
      * instantiated with duration_traits_adapted */
     date_duration(special_values sv) :
@@ -125,7 +125,7 @@ namespace date_time {
   {
     typedef long int_type;
     typedef long impl_type;
-    static int_type as_number(impl_type i) { return i; };
+    static int_type as_number(impl_type i) { return i; }
   };
 
   /*! Struct for instantiating date_duration <b>WITH</b> special values
@@ -135,9 +135,9 @@ namespace date_time {
   {
     typedef long int_type;
     typedef boost::date_time::int_adapter<long> impl_type;
-    static int_type as_number(impl_type i) { return i.as_number(); };
+    static int_type as_number(impl_type i) { return i.as_number(); }
   };
-  
+
 
 } } //namspace date_time
 

3party/boost/boost/date_time/date_facet.hpp

@@ -6,7 +6,7 @@
  * Boost Software License, Version 1.0. (See accompanying
  * file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
  * Author:  Martin Andrian, Jeff Garland, Bart Garst
- * $Date: 2009-06-04 04:40:18 -0700 (Thu, 04 Jun 2009) $
+ * $Date: 2012-09-30 16:25:22 -0700 (Sun, 30 Sep 2012) $
  */
 
 #include <locale>
@@ -208,7 +208,8 @@ namespace boost { namespace date_time {
       //  return do_put_special(next, a_ios, fill_char, d.as_special());
       //}
       //The following line of code required the date to support a to_tm function
-      std::tm dtm = {};
+      std::tm dtm;
+      std::memset(&dtm, 0, sizeof(dtm));
       dtm.tm_mon = m - 1;
       return do_put_tm(next, a_ios, fill_char, dtm, m_month_format);
     }
@@ -219,7 +220,8 @@ namespace boost { namespace date_time {
                 char_type fill_char,
                 const day_type& day) const
     {
-      std::tm dtm = {};
+      std::tm dtm;
+      std::memset(&dtm, 0, sizeof(dtm));
       dtm.tm_mday = day.as_number();
       char_type tmp[3] = {'%','d'};
       string_type temp_format(tmp);
@@ -235,7 +237,8 @@ namespace boost { namespace date_time {
       //  return do_put_special(next, a_ios, fill_char, d.as_special());
       //}
       //The following line of code required the date to support a to_tm function
-      std::tm dtm = {};
+      std::tm dtm;
+      std::memset(&dtm, 0, sizeof(dtm));
       dtm.tm_wday = dow;
       return do_put_tm(next, a_ios, fill_char, dtm, m_weekday_format);
     }

3party/boost/boost/date_time/date_formatting.hpp

@@ -6,7 +6,7 @@
  * Boost Software License, Version 1.0. (See accompanying
  * file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
  * Author: Jeff Garland, Bart Garst
- * $Date: 2012-07-27 11:15:55 -0700 (Fri, 27 Jul 2012) $
+ * $Date: 2012-09-30 16:25:22 -0700 (Sun, 30 Sep 2012) $
  */
 
 #include "boost/date_time/iso_format.hpp"
@@ -54,7 +54,9 @@ namespace date_time {
           os << std::setw(2) << std::setfill(os.widen('0')) << month.as_number();
           break;
         }
-     
+        default:
+          break;
+          
       }
       return os;
     } // format_month

3party/boost/boost/date_time/date_generators.hpp

@@ -2,11 +2,11 @@
 #define DATE_TIME_DATE_GENERATORS_HPP__
 
 /* Copyright (c) 2002,2003,2005 CrystalClear Software, Inc.
- * Use, modification and distribution is subject to the 
+ * Use, modification and distribution is subject to the
  * Boost Software License, Version 1.0. (See accompanying
  * file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
- * Author: Jeff Garland, Bart Garst 
- * $Date: 2008-11-12 11:37:53 -0800 (Wed, 12 Nov 2008) $
+ * Author: Jeff Garland, Bart Garst
+ * $Date: 2012-09-22 15:33:33 -0700 (Sat, 22 Sep 2012) $
  */
 
 /*! @file date_generators.hpp
@@ -34,16 +34,16 @@ namespace date_time {
   public:
     typedef typename date_type::calendar_type calendar_type;
     typedef typename calendar_type::year_type        year_type;
-    year_based_generator() {};
-    virtual ~year_based_generator() {};
+    year_based_generator() {}
+    virtual ~year_based_generator() {}
     virtual date_type get_date(year_type y) const = 0;
     //! Returns a string for use in a POSIX time_zone string
     virtual std::string to_string() const =0;
   };
-  
+
   //! Generates a date by applying the year to the given month and day.
   /*!
-    Example usage: 
+    Example usage:
     @code
     partial_date pd(1, Jan);
     partial_date pd2(70);
@@ -123,9 +123,9 @@ namespace date_time {
      //months are equal
      return (day_ < rhs.day_);
    }
-   
+
    // added for streaming purposes
-   month_type month() const 
+   month_type month() const
    {
      return month_;
    }
@@ -135,15 +135,15 @@ namespace date_time {
    }
 
    //! Returns string suitable for use in POSIX time zone string
-   /*! Returns string formatted with up to 3 digits: 
-    * Jan-01 == "0" 
+   /*! Returns string formatted with up to 3 digits:
+    * Jan-01 == "0"
     * Feb-29 == "58"
     * Dec-31 == "365" */
    virtual std::string to_string() const
    {
      std::ostringstream ss;
      date_type d(2004, month_, day_);
-     unsigned short c = d.day_of_year();     
+     unsigned short c = d.day_of_year();
      c--; // numbered 0-365 while day_of_year is 1 based...
      ss << c;
      return ss.str();
@@ -161,7 +161,7 @@ namespace date_time {
   /*! Based on the idea in Cal. Calc. for finding holidays that are
    *  the 'first Monday of September'. When instantiated with
    *  'fifth' kday of month, the result will be the last kday of month
-   *  which can be the fourth or fifth depending on the structure of 
+   *  which can be the fourth or fifth depending on the structure of
    *  the month.
    *
    *  The algorithm here basically guesses for the first
@@ -169,8 +169,8 @@ namespace date_time {
    *  type.  That is, if the first of the month is a Tuesday
    *  and it needs Wenesday then we simply increment by a day
    *  and then we can add the length of a week until we get
-   *  to the 'nth kday'.  There are probably more efficient 
-   *  algorithms based on using a mod 7, but this one works 
+   *  to the 'nth kday'.  There are probably more efficient
+   *  algorithms based on using a mod 7, but this one works
    *  reasonably well for basic applications.
    *  \ingroup date_alg
    */
@@ -233,7 +233,7 @@ namespace date_time {
     virtual std::string to_string() const
     {
      std::ostringstream ss;
-     ss << 'M' 
+     ss << 'M'
        << static_cast<int>(month_) << '.'
        << static_cast<int>(wn_) << '.'
        << static_cast<int>(dow_);
@@ -244,7 +244,7 @@ namespace date_time {
     week_num wn_;
     day_of_week_type dow_;
   };
-  
+
   //! Useful generator functor for finding holidays and daylight savings
   /*! Similar to nth_kday_of_month, but requires less paramters
    *  \ingroup date_alg
@@ -290,7 +290,7 @@ namespace date_time {
     virtual std::string to_string() const
     {
      std::ostringstream ss;
-     ss << 'M' 
+     ss << 'M'
        << static_cast<int>(month_) << '.'
        << 1 << '.'
        << static_cast<int>(dow_);
@@ -300,9 +300,9 @@ namespace date_time {
     month_type month_;
     day_of_week_type dow_;
   };
-  
-  
-  
+
+
+
   //! Calculate something like Last Sunday of January
   /*! Useful generator functor for finding holidays and daylight savings
    *  Get the last day of the month and then calculate the difference
@@ -351,7 +351,7 @@ namespace date_time {
     virtual std::string to_string() const
     {
       std::ostringstream ss;
-      ss << 'M' 
+      ss << 'M'
          << static_cast<int>(month_) << '.'
          << 5 << '.'
          << static_cast<int>(dow_);
@@ -361,8 +361,8 @@ namespace date_time {
     month_type month_;
     day_of_week_type dow_;
    };
-  
-  
+
+
   //! Calculate something like "First Sunday after Jan 1,2002
   /*! Date generator that takes a date and finds kday after
    *@code
@@ -400,7 +400,7 @@ namespace date_time {
   private:
     day_of_week_type dow_;
   };
-  
+
   //! Calculate something like "First Sunday before Jan 1,2002
   /*! Date generator that takes a date and finds kday after
    *@code
@@ -438,10 +438,10 @@ namespace date_time {
   private:
     day_of_week_type dow_;
   };
-  
+
   //! Calculates the number of days until the next weekday
   /*! Calculates the number of days until the next weekday.
-   * If the date given falls on a Sunday and the given weekday 
+   * If the date given falls on a Sunday and the given weekday
    * is Tuesday the result will be 2 days */
   template<typename date_type, class weekday_type>
   inline
@@ -458,8 +458,8 @@ namespace date_time {
 
   //! Calculates the number of days since the previous weekday
   /*! Calculates the number of days since the previous weekday
-   * If the date given falls on a Sunday and the given weekday 
-   * is Tuesday the result will be 5 days. The answer will be a positive 
+   * If the date given falls on a Sunday and the given weekday
+   * is Tuesday the result will be 5 days. The answer will be a positive
    * number because Tuesday is 5 days before Sunday, not -5 days before. */
   template<typename date_type, class weekday_type>
   inline
@@ -477,9 +477,9 @@ namespace date_time {
   }
 
   //! Generates a date object representing the date of the following weekday from the given date
-  /*! Generates a date object representing the date of the following 
-   * weekday from the given date. If the date given is 2004-May-9 
-   * (a Sunday) and the given weekday is Tuesday then the resulting date 
+  /*! Generates a date object representing the date of the following
+   * weekday from the given date. If the date given is 2004-May-9
+   * (a Sunday) and the given weekday is Tuesday then the resulting date
    * will be 2004-May-11. */
   template<class date_type, class weekday_type>
   inline
@@ -489,9 +489,9 @@ namespace date_time {
   }
 
   //! Generates a date object representing the date of the previous weekday from the given date
-  /*! Generates a date object representing the date of the previous 
-   * weekday from the given date. If the date given is 2004-May-9 
-   * (a Sunday) and the given weekday is Tuesday then the resulting date 
+  /*! Generates a date object representing the date of the previous
+   * weekday from the given date. If the date given is 2004-May-9
+   * (a Sunday) and the given weekday is Tuesday then the resulting date
    * will be 2004-May-4. */
   template<class date_type, class weekday_type>
   inline

3party/boost/boost/date_time/date_iterator.hpp

@@ -2,11 +2,11 @@
 #define DATE_ITERATOR_HPP___
 
 /* Copyright (c) 2002,2003 CrystalClear Software, Inc.
- * Use, modification and distribution is subject to the 
+ * Use, modification and distribution is subject to the
  * Boost Software License, Version 1.0. (See accompanying
  * file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
  * Author: Jeff Garland, Bart Garst
- * $Date: 2008-02-27 12:00:24 -0800 (Wed, 27 Feb 2008) $
+ * $Date: 2012-09-22 15:33:33 -0700 (Sat, 22 Sep 2012) $
  */
 
 #include <iterator>
@@ -32,7 +32,7 @@ namespace date_time {
   template<class date_type>
   class date_itr_base {
   // works, but benefit unclear at the moment
-  //   class date_itr_base : public std::iterator<std::input_iterator_tag, 
+  //   class date_itr_base : public std::iterator<std::input_iterator_tag,
   //                                             date_type, void, void, void>{
   public:
     typedef typename date_type::duration_type duration_type;
@@ -40,31 +40,31 @@ namespace date_time {
     typedef std::input_iterator_tag iterator_category;
 
     date_itr_base(date_type d) : current_(d) {}
-    virtual ~date_itr_base() {};
-    date_itr_base& operator++() 
+    virtual ~date_itr_base() {}
+    date_itr_base& operator++()
     {
       current_ = current_ + get_offset(current_);
       return *this;
     }
-    date_itr_base& operator--() 
+    date_itr_base& operator--()
     {
       current_ = current_ + get_neg_offset(current_);
       return *this;
     }
     virtual duration_type get_offset(const date_type& current) const=0;
     virtual duration_type get_neg_offset(const date_type& current) const=0;
-    date_type operator*() {return current_;};
-    date_type* operator->() {return &current_;};
+    date_type operator*() {return current_;}
+    date_type* operator->() {return &current_;}
     bool operator<  (const date_type& d) {return current_ < d;}
     bool operator<= (const date_type& d) {return current_ <= d;}
     bool operator>  (const date_type& d) {return current_ > d;}
     bool operator>= (const date_type& d) {return current_ >= d;}
     bool operator== (const date_type& d) {return current_ == d;}
-    bool operator!= (const date_type& d) {return current_ != d;}    
+    bool operator!= (const date_type& d) {return current_ != d;}
   private:
     date_type current_;
   };
-  
+
   //! Overrides the base date iterator providing hook for functors
   /*
    *  <b>offset_functor</b>
@@ -77,9 +77,9 @@ namespace date_time {
   class date_itr : public date_itr_base<date_type> {
   public:
     typedef typename date_type::duration_type duration_type;
-    date_itr(date_type d, int factor=1) : 
-      date_itr_base<date_type>(d), 
-      of_(factor) 
+    date_itr(date_type d, int factor=1) :
+      date_itr_base<date_type>(d),
+      of_(factor)
     {}
   private:
     virtual duration_type get_offset(const date_type& current) const
@@ -92,9 +92,9 @@ namespace date_time {
     }
     offset_functor of_;
   };
-  
 
-  
+
+
 } } //namespace date_time
 
 

3party/boost/boost/date_time/date_names_put.hpp

@@ -2,11 +2,11 @@
 #define DATE_TIME_DATE_NAMES_PUT_HPP___
 
 /* Copyright (c) 2002-2005 CrystalClear Software, Inc.
- * Use, modification and distribution is subject to the 
+ * Use, modification and distribution is subject to the
  * Boost Software License, Version 1.0. (See accompanying
  * file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
- * Author: Jeff Garland, Bart Garst 
- * $Date: 2008-02-27 12:00:24 -0800 (Wed, 27 Feb 2008) $
+ * Author: Jeff Garland, Bart Garst
+ * $Date: 2012-09-22 15:33:33 -0700 (Sat, 22 Sep 2012) $
  */
 
 
@@ -27,22 +27,22 @@ namespace date_time {
     //! Output facet base class for gregorian dates.
     /*! This class is a base class for date facets used to localize the
      *  names of months and the names of days in the week.
-     * 
+     *
      * Requirements of Config
-     *  - define an enumeration month_enum that enumerates the months. 
+     *  - define an enumeration month_enum that enumerates the months.
      *    The enumeration should be '1' based eg: Jan==1
      *  - define as_short_string and as_long_string
      *
      * (see langer & kreft p334).
-     * 
+     *
      */
     template<class Config,
-             class charT = char, 
+             class charT = char,
              class OutputIterator = std::ostreambuf_iterator<charT> >
     class date_names_put : public std::locale::facet
     {
     public:
-      date_names_put() {};
+      date_names_put() {}
       typedef OutputIterator iter_type;
       typedef typename Config::month_type month_type;
       typedef typename Config::month_enum month_enum;
@@ -118,7 +118,7 @@ namespace date_time {
         put_string(oitr, gm.as_short_string(c));
       }
       //! Default facet implementation uses month_type defaults
-      virtual void do_put_month_long(iter_type& oitr, 
+      virtual void do_put_month_long(iter_type& oitr,
                                      month_enum moy) const
       {
         month_type gm(moy);
@@ -160,7 +160,7 @@ namespace date_time {
         string_type s(separator); //put in '-'
         put_string(oitr, s);
       }
-      //! Default for date order 
+      //! Default for date order
       virtual ymd_order_spec do_date_order() const
       {
         return ymd_order_iso;
@@ -186,27 +186,27 @@ namespace date_time {
         }
       }
     };
-    
+
     template<class Config, class charT, class OutputIterator>
-    const typename date_names_put<Config, charT, OutputIterator>::char_type 
-    date_names_put<Config, charT, OutputIterator>::default_special_value_names[3][17] = { 
+    const typename date_names_put<Config, charT, OutputIterator>::char_type
+    date_names_put<Config, charT, OutputIterator>::default_special_value_names[3][17] = {
       {'n','o','t','-','a','-','d','a','t','e','-','t','i','m','e'},
       {'-','i','n','f','i','n','i','t','y'},
       {'+','i','n','f','i','n','i','t','y'} };
 
     template<class Config, class charT, class OutputIterator>
-    const typename date_names_put<Config, charT, OutputIterator>::char_type 
-    date_names_put<Config, charT, OutputIterator>::separator[2] = 
+    const typename date_names_put<Config, charT, OutputIterator>::char_type
+    date_names_put<Config, charT, OutputIterator>::separator[2] =
       {'-', '\0'} ;
-    
 
-    //! Generate storage location for a std::locale::id 
+
+    //! Generate storage location for a std::locale::id
     template<class Config, class charT, class OutputIterator>
     std::locale::id date_names_put<Config, charT, OutputIterator>::id;
 
     //! A date name output facet that takes an array of char* to define strings
     template<class Config,
-             class charT = char, 
+             class charT = char,
              class OutputIterator = std::ostreambuf_iterator<charT> >
     class all_date_names_put : public date_names_put<Config, charT, OutputIterator>
     {
@@ -230,29 +230,29 @@ namespace date_time {
         separator_char_[0] = separator_char;
         separator_char_[1] = '\0';
 
-      };
+      }
       typedef OutputIterator iter_type;
       typedef typename Config::month_enum month_enum;
       typedef typename Config::weekday_enum weekday_enum;
       typedef typename Config::special_value_enum special_value_enum;
 
-      const charT* const* get_short_month_names() const 
+      const charT* const* get_short_month_names() const
       {
         return month_short_names_;
       }
-      const charT* const* get_long_month_names() const 
+      const charT* const* get_long_month_names() const
       {
         return month_long_names_;
       }
-      const charT* const* get_special_value_names() const 
+      const charT* const* get_special_value_names() const
       {
         return special_value_names_;
       }
-      const charT* const* get_short_weekday_names()const  
+      const charT* const* get_short_weekday_names()const
       {
         return weekday_short_names_;
       }
-      const charT* const* get_long_weekday_names()const 
+      const charT* const* get_long_weekday_names()const
       {
         return weekday_long_names_;
       }
@@ -263,7 +263,7 @@ namespace date_time {
       {
         this->put_string(oitr, month_short_names_[moy-1]);
       }
-      //! Long month names 
+      //! Long month names
       virtual void do_put_month_long(iter_type& oitr, month_enum moy) const
       {
         this->put_string(oitr, month_long_names_[moy-1]);
@@ -310,7 +310,7 @@ namespace date_time {
       const charT* const* weekday_long_names_;
       charT separator_char_[2];
       ymd_order_spec order_spec_;
-      month_format_spec month_format_spec_;      
+      month_format_spec month_format_spec_;
     };
 
 } } //namespace boost::date_time

3party/boost/boost/date_time/date_parsing.hpp

@@ -6,7 +6,7 @@
  * Boost Software License, Version 1.0. (See accompanying
  * file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
  * Author: Jeff Garland, Bart Garst
- * $Date: 2009-06-04 01:24:49 -0700 (Thu, 04 Jun 2009) $
+ * $Date: 2012-09-30 16:25:22 -0700 (Sun, 30 Sep 2012) $
  */
 
 #include <string>
@@ -148,6 +148,7 @@ namespace date_time {
             day = boost::lexical_cast<unsigned short>(*beg);
             break;
           }
+          default: break;
         } //switch
       }
       return date_type(year, month, day);
@@ -180,6 +181,7 @@ namespace date_time {
         case 0: y = i; break;
         case 1: m = i; break;
         case 2: d = i; break;
+        default:       break;
         }
         pos++;
       }

3party/boost/boost/date_time/dst_rules.hpp

@@ -6,7 +6,7 @@
  * Boost Software License, Version 1.0. (See accompanying
  * file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
  * Author: Jeff Garland, Bart Garst
- * $Date: 2008-02-27 12:00:24 -0800 (Wed, 27 Feb 2008) $
+ * $Date: 2012-09-30 16:25:22 -0700 (Sun, 30 Sep 2012) $
  */
 
 /*! @file dst_rules.hpp
@@ -371,7 +371,7 @@ namespace boost {
         return is_not_in_dst;
       }
 
-      static bool is_dst_boundary_day(date_type d)
+      static bool is_dst_boundary_day(date_type /*d*/)
       {
         return false;
       }

3party/boost/boost/date_time/dst_transition_generators.hpp

@@ -18,7 +18,7 @@ namespace date_time {
     {
     public:
       typedef typename date_type::year_type year_type;
-      virtual ~dst_day_calc_rule() {};
+      virtual ~dst_day_calc_rule() {}
       virtual date_type start_day(year_type y) const=0;
       virtual std::string start_rule_as_string() const=0;
       virtual date_type end_day(year_type y) const=0;

3party/boost/boost/date_time/filetime_functions.hpp

@@ -6,7 +6,7 @@
  * Boost Software License, Version 1.0. (See accompanying
  * file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
  * Author: Jeff Garland, Bart Garst
- * $Date: 2012-07-27 11:15:55 -0700 (Fri, 27 Jul 2012) $
+ * $Date: 2012-09-22 09:04:10 -0700 (Sat, 22 Sep 2012) $
  */
 
 /*! @file filetime_functions.hpp

3party/boost/boost/date_time/format_date_parser.hpp

@@ -7,7 +7,7 @@
  * Boost Software License, Version 1.0. (See accompanying
  * file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
  * Author: Jeff Garland, Bart Garst
- * $Date: 2009-06-04 01:24:49 -0700 (Thu, 04 Jun 2009) $
+ * $Date: 2012-09-30 16:25:22 -0700 (Sun, 30 Sep 2012) $
  */
 
 
@@ -256,7 +256,6 @@ class format_date_parser
     
     // skip leading whitespace
     while(std::isspace(*sitr) && sitr != stream_end) { ++sitr; } 
-    charT current_char = *sitr;
 
     short year(0), month(0), day(0), day_of_year(0);// wkday(0); 
     /* Initialized the following to their minimum values. These intermediate 
@@ -290,7 +289,6 @@ class format_date_parser
               }
               wkday = mr.current_match;
               if (mr.has_remaining()) {
-                current_char = mr.last_char();
                 use_current_char = true;
               }
               break;
@@ -310,7 +308,6 @@ class format_date_parser
               }
               wkday = mr.current_match;
               if (mr.has_remaining()) {
-                current_char = mr.last_char();
                 use_current_char = true;
               }
               break;
@@ -326,7 +323,6 @@ class format_date_parser
               }
               t_month = month_type(mr.current_match);
               if (mr.has_remaining()) {
-                current_char = mr.last_char();
                 use_current_char = true;
               }
               break;
@@ -342,7 +338,6 @@ class format_date_parser
               }
               t_month = month_type(mr.current_match);
               if (mr.has_remaining()) {
-                current_char = mr.last_char();
                 use_current_char = true;
               }
               break;
@@ -438,7 +433,6 @@ class format_date_parser
         itr++;
         if (use_current_char) {
           use_current_char = false;
-          current_char = *sitr;
         }
         else {
           sitr++;

3party/boost/boost/date_time/gregorian/greg_serialize.hpp

@@ -6,7 +6,7 @@
  * Boost Software License, Version 1.0. (See accompanying
  * file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
  * Author: Jeff Garland, Bart Garst
- * $Date: 2012-07-27 11:15:55 -0700 (Fri, 27 Jul 2012) $
+ * $Date: 2012-09-30 16:25:22 -0700 (Sun, 30 Sep 2012) $
  */
 
 #include "boost/date_time/gregorian/gregorian_types.hpp"
@@ -88,7 +88,7 @@ void load(Archive & ar,
 
 //!override needed b/c no default constructor
 template<class Archive>
-inline void load_construct_data(Archive & ar, 
+inline void load_construct_data(Archive & /*ar*/, 
                                 ::boost::gregorian::date* dp, 
                                 const unsigned int /*file_version*/)
 {
@@ -117,7 +117,7 @@ void load(Archive & ar, gregorian::date_duration & dd, unsigned int /*version*/)
 }
 //!override needed b/c no default constructor
 template<class Archive>
-inline void load_construct_data(Archive & ar, gregorian::date_duration* dd, 
+inline void load_construct_data(Archive & /*ar*/, gregorian::date_duration* dd, 
                                 const unsigned int /*file_version*/)
 {
   ::new(dd) gregorian::date_duration(gregorian::not_a_date_time);
@@ -143,7 +143,7 @@ void load(Archive & ar, gregorian::date_duration::duration_rep & dr, unsigned in
 }
 //!override needed b/c no default constructor
 template<class Archive>
-inline void load_construct_data(Archive & ar, gregorian::date_duration::duration_rep* dr, 
+inline void load_construct_data(Archive & /*ar*/, gregorian::date_duration::duration_rep* dr, 
                                 const unsigned int /*file_version*/)
 {
   ::new(dr) gregorian::date_duration::duration_rep(0);
@@ -179,7 +179,7 @@ void load(Archive & ar, gregorian::date_period& dp, unsigned int /*version*/)
 }
 //!override needed b/c no default constructor
 template<class Archive>
-inline void load_construct_data(Archive & ar, gregorian::date_period* dp, 
+inline void load_construct_data(Archive & /*ar*/, gregorian::date_period* dp, 
                                 const unsigned int /*file_version*/)
 {
   gregorian::date d(gregorian::not_a_date_time);
@@ -207,7 +207,7 @@ void load(Archive & ar, gregorian::greg_year& gy, unsigned int /*version*/)
 }
 //!override needed b/c no default constructor
 template<class Archive>
-inline void load_construct_data(Archive & ar, gregorian::greg_year* gy, 
+inline void load_construct_data(Archive & /*ar*/, gregorian::greg_year* gy, 
                                 const unsigned int /*file_version*/)
 {
   ::new(gy) gregorian::greg_year(1900);
@@ -233,7 +233,7 @@ void load(Archive & ar, gregorian::greg_month& gm, unsigned int /*version*/)
 }
 //!override needed b/c no default constructor
 template<class Archive>
-inline void load_construct_data(Archive & ar, gregorian::greg_month* gm, 
+inline void load_construct_data(Archive & /*ar*/, gregorian::greg_month* gm, 
                                 const unsigned int /*file_version*/)
 {
   ::new(gm) gregorian::greg_month(1);
@@ -259,7 +259,7 @@ void load(Archive & ar, gregorian::greg_day& gd, unsigned int /*version*/)
 }
 //!override needed b/c no default constructor
 template<class Archive>
-inline void load_construct_data(Archive & ar, gregorian::greg_day* gd, 
+inline void load_construct_data(Archive & /*ar*/, gregorian::greg_day* gd, 
                                 const unsigned int /*file_version*/)
 {
   ::new(gd) gregorian::greg_day(1);
@@ -285,7 +285,7 @@ void load(Archive & ar, gregorian::greg_weekday& gd, unsigned int /*version*/)
 }
 //!override needed b/c no default constructor
 template<class Archive>
-inline void load_construct_data(Archive & ar, gregorian::greg_weekday* gd, 
+inline void load_construct_data(Archive & /*ar*/, gregorian::greg_weekday* gd, 
                                 const unsigned int /*file_version*/)
 {
   ::new(gd) gregorian::greg_weekday(1);
@@ -323,7 +323,7 @@ void load(Archive & ar, gregorian::partial_date& pd, unsigned int /*version*/)
 }
 //!override needed b/c no default constructor
 template<class Archive>
-inline void load_construct_data(Archive & ar, gregorian::partial_date* pd, 
+inline void load_construct_data(Archive & /*ar*/, gregorian::partial_date* pd, 
                                 const unsigned int /*file_version*/)
 {
   gregorian::greg_month gm(1);
@@ -366,7 +366,7 @@ void load(Archive & ar, gregorian::nth_kday_of_month& nkd, unsigned int /*versio
 }
 //!override needed b/c no default constructor
 template<class Archive>
-inline void load_construct_data(Archive & ar, 
+inline void load_construct_data(Archive & /*ar*/, 
                                 gregorian::nth_kday_of_month* nkd, 
                                 const unsigned int /*file_version*/)
 {
@@ -406,7 +406,7 @@ void load(Archive & ar, gregorian::first_kday_of_month& fkd, unsigned int /*vers
 }
 //!override needed b/c no default constructor
 template<class Archive>
-inline void load_construct_data(Archive & ar, 
+inline void load_construct_data(Archive & /*ar*/, 
                                 gregorian::first_kday_of_month* fkd, 
                                 const unsigned int /*file_version*/)
 {
@@ -445,7 +445,7 @@ void load(Archive & ar, gregorian::last_kday_of_month& lkd, unsigned int /*versi
 }
 //!override needed b/c no default constructor
 template<class Archive>
-inline void load_construct_data(Archive & ar, 
+inline void load_construct_data(Archive & /*ar*/, 
                                 gregorian::last_kday_of_month* lkd, 
                                 const unsigned int /*file_version*/)
 {
@@ -474,7 +474,7 @@ void load(Archive & ar, gregorian::first_kday_before& fkdb, unsigned int /*versi
 }
 //!override needed b/c no default constructor
 template<class Archive>
-inline void load_construct_data(Archive & ar, 
+inline void load_construct_data(Archive & /*ar*/, 
                                 gregorian::first_kday_before* fkdb, 
                                 const unsigned int /*file_version*/)
 {
@@ -503,7 +503,7 @@ void load(Archive & ar, gregorian::first_kday_after& fkda, unsigned int /*versio
 }
 //!override needed b/c no default constructor
 template<class Archive>
-inline void load_construct_data(Archive & ar, 
+inline void load_construct_data(Archive & /*ar*/, 
                                 gregorian::first_kday_after* fkda, 
                                 const unsigned int /*file_version*/)
 {

3party/boost/boost/date_time/gregorian_calendar.ipp

@@ -3,7 +3,7 @@
  * Boost Software License, Version 1.0. (See accompanying
  * file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
  * Author: Jeff Garland, Bart Garst
- * $Date: 2012-07-27 11:15:55 -0700 (Fri, 27 Jul 2012) $
+ * $Date: 2012-09-22 09:04:10 -0700 (Sat, 22 Sep 2012) $
  */
 
 #ifndef NO_BOOST_DATE_TIME_INLINE

3party/boost/boost/date_time/local_time/custom_time_zone.hpp

@@ -2,10 +2,10 @@
 #define LOCAL_TIME_CUSTOM_TIME_ZONE_HPP__
 
 /* Copyright (c) 2003-2005 CrystalClear Software, Inc.
- * Subject to the Boost Software License, Version 1.0. 
+ * Subject to the Boost Software License, Version 1.0.
  * (See accompanying file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
  * Author: Jeff Garland, Bart Garst
- * $Date: 2008-02-27 12:00:24 -0800 (Wed, 27 Feb 2008) $
+ * $Date: 2012-09-22 15:33:33 -0700 (Sat, 22 Sep 2012) $
  */
 
 #include "boost/date_time/time_zone_base.hpp"
@@ -34,8 +34,8 @@ namespace local_time {
     typedef typename base_type::stringstream_type stringstream_type;
     typedef date_time::time_zone_names_base<CharT> time_zone_names;
     typedef CharT char_type;
-    
-    custom_time_zone_base(const time_zone_names& zone_names,   
+
+    custom_time_zone_base(const time_zone_names& zone_names,
                      const time_duration_type& utc_offset,
                      const dst_adjustment_offsets& dst_shift,
                      boost::shared_ptr<dst_calc_rule> calc_rule) :
@@ -43,8 +43,8 @@ namespace local_time {
       base_utc_offset_(utc_offset),
       dst_offsets_(dst_shift),
       dst_calc_rules_(calc_rule)
-    {};
-    virtual ~custom_time_zone_base() {};
+    {}
+    virtual ~custom_time_zone_base() {}
     virtual string_type dst_zone_abbrev() const
     {
       return zone_names_.dst_zone_abbrev();

3party/boost/boost/date_time/local_time/local_date_time.hpp

@@ -5,7 +5,7 @@
  * Subject to the Boost Software License, Version 1.0.
  * (See accompanying file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
  * Author: Jeff Garland, Bart Garst
- * $Date: 2010-01-10 11:17:23 -0800 (Sun, 10 Jan 2010) $
+ * $Date: 2012-09-22 15:33:33 -0700 (Sat, 22 Sep 2012) $
  */
 
 #include <string>
@@ -208,7 +208,7 @@ namespace local_time {
     }
 
     //! Simple destructor, releases time zone if last referrer
-    ~local_date_time_base() {};
+    ~local_date_time_base() {}
 
     //! Copy constructor
     local_date_time_base(const local_date_time_base& rhs) :

3party/boost/boost/date_time/local_time/posix_time_zone.hpp

@@ -5,7 +5,7 @@
  * Subject to the Boost Software License, Version 1.0. (See accompanying
  * file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
  * Author: Jeff Garland, Bart Garst
- * $Date: 2010-06-10 10:24:38 -0700 (Thu, 10 Jun 2010) $
+ * $Date: 2012-09-22 15:33:33 -0700 (Sat, 22 Sep 2012) $
  */
 
 #include <string>
@@ -115,7 +115,7 @@ namespace local_time{
         calc_rules(dst_begin, dst_end);
       }
     }
-    virtual ~posix_time_zone_base() {};
+    virtual ~posix_time_zone_base() {}
     //!String for the zone when not in daylight savings (eg: EST)
     virtual string_type std_zone_abbrev()const
     {

3party/boost/boost/date_time/period_formatter.hpp

@@ -7,7 +7,7 @@
  * Boost Software License, Version 1.0. (See accompanying
  * file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
  * Author: Jeff Garland, Bart Garst
- * $Date: 2008-02-27 12:00:24 -0800 (Wed, 27 Feb 2008) $
+ * $Date: 2012-09-22 15:33:33 -0700 (Sat, 22 Sep 2012) $
  */
 
 
@@ -114,10 +114,10 @@ namespace boost { namespace date_time {
     {
       m_range_option = option;
     }
-    void delimiter_strings(const string_type& separator,
-                           const string_type& start_delim,
-                           const string_type& open_end_delim,
-                           const string_type& closed_end_delim)
+    void delimiter_strings(const string_type& ,
+                           const string_type& ,
+                           const string_type& ,
+                           const string_type& )
     {
       m_period_separator;
       m_period_start_delimeter;

3party/boost/boost/date_time/posix_time/posix_time_config.hpp

@@ -6,7 +6,7 @@
  * Boost Software License, Version 1.0. (See accompanying
  * file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
  * Author: Jeff Garland, Bart Garst
- * $Date: 2009-06-04 04:52:28 -0700 (Thu, 04 Jun 2009) $
+ * $Date: 2012-10-10 12:05:03 -0700 (Wed, 10 Oct 2012) $
  */
 
 #include <cstdlib> //for MCW 7.2 std::abs(long long)
@@ -81,7 +81,7 @@ namespace posix_time {
     {}
     //Give duration access to ticks constructor -- hide from users
     friend class date_time::time_duration<time_duration, time_res_traits>;
-  private:
+  protected:
     explicit time_duration(impl_type tick_count) :
       date_time::time_duration<time_duration, time_res_traits>(tick_count)
     {}

3party/boost/boost/date_time/posix_time/time_serialize.hpp

@@ -6,7 +6,7 @@
  * Boost Software License, Version 1.0. (See accompanying
  * file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
  * Author: Jeff Garland, Bart Garst
- * $Date: 2012-07-27 11:15:55 -0700 (Fri, 27 Jul 2012) $
+ * $Date: 2012-09-30 16:25:22 -0700 (Sun, 30 Sep 2012) $
  */
 
 #include "boost/date_time/posix_time/posix_time.hpp"
@@ -184,7 +184,7 @@ void load(Archive & ar,
 
 //!override needed b/c no default constructor
 template<class Archive>
-inline void load_construct_data(Archive & ar, 
+inline void load_construct_data(Archive & /*ar*/, 
                                 boost::posix_time::time_period* tp, 
                                 const unsigned int /*file_version*/)
 {

3party/boost/boost/date_time/strings_from_facet.hpp

@@ -6,7 +6,7 @@
  * Boost Software License, Version 1.0. (See accompanying
  * file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
  * Author: Jeff Garland
- * $Date: 2012-07-27 11:15:55 -0700 (Fri, 27 Jul 2012) $
+ * $Date: 2012-09-22 09:04:10 -0700 (Sat, 22 Sep 2012) $
  */
 
 #include <sstream>

3party/boost/boost/date_time/time_duration.hpp

@@ -2,15 +2,16 @@
 #define DATE_TIME_TIME_DURATION_HPP___
 
 /* Copyright (c) 2002,2003 CrystalClear Software, Inc.
- * Use, modification and distribution is subject to the 
+ * Use, modification and distribution is subject to the
  * Boost Software License, Version 1.0. (See accompanying
  * file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
  * Author: Jeff Garland, Bart Garst
- * $Date: 2009-06-04 01:24:49 -0700 (Thu, 04 Jun 2009) $
+ * $Date: 2012-10-10 12:05:03 -0700 (Wed, 10 Oct 2012) $
  */
 
 #include <boost/cstdint.hpp>
 #include <boost/operators.hpp>
+#include <boost/static_assert.hpp>
 #include <boost/date_time/time_defs.hpp>
 #include <boost/date_time/special_defs.hpp>
 #include <boost/date_time/compiler_config.hpp>
@@ -179,7 +180,7 @@ namespace date_time {
       return duration_type(ticks_);
     }
     //! Division operations on a duration with an integer.
-    duration_type operator/=(int divisor) 
+    duration_type operator/=(int divisor)
     {
       ticks_ = ticks_ / divisor;
       return duration_type(ticks_);
@@ -251,7 +252,7 @@ namespace date_time {
     }
 
   protected:
-    explicit time_duration(impl_type in) : ticks_(in) {};
+    explicit time_duration(impl_type in) : ticks_(in) {}
     impl_type ticks_;
   };
 
@@ -265,10 +266,20 @@ namespace date_time {
   class subsecond_duration : public base_duration
   {
   public:
+    typedef typename base_duration::impl_type impl_type;
     typedef typename base_duration::traits_type traits_type;
+
+  private:
+    // To avoid integer overflow we precompute the duration resolution conversion coefficient (ticket #3471)
+    BOOST_STATIC_ASSERT_MSG((traits_type::ticks_per_second >= frac_of_second ? traits_type::ticks_per_second % frac_of_second : frac_of_second % traits_type::ticks_per_second) == 0,\
+      "The base duration resolution must be a multiple of the subsecond duration resolution");
+    BOOST_STATIC_CONSTANT(boost::int64_t, adjustment_ratio = (traits_type::ticks_per_second >= frac_of_second ? traits_type::ticks_per_second / frac_of_second : frac_of_second / traits_type::ticks_per_second));
+
+  public:
     explicit subsecond_duration(boost::int64_t ss) :
-      base_duration(0,0,0,ss*traits_type::res_adjust()/frac_of_second)
-    {}
+      base_duration(impl_type(traits_type::ticks_per_second >= frac_of_second ? ss * adjustment_ratio : ss / adjustment_ratio))
+    {
+    }
   };
 
 

3party/boost/boost/date_time/time_facet.hpp

@@ -7,7 +7,7 @@
  * Boost Software License, Version 1.0. (See accompanying
  * file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
  * Author:  Martin Andrian, Jeff Garland, Bart Garst
- * $Date: 2012-07-27 11:15:55 -0700 (Fri, 27 Jul 2012) $
+ * $Date: 2012-09-22 09:04:10 -0700 (Sat, 22 Sep 2012) $
  */
 
 #include <cctype>

3party/boost/boost/date_time/time_iterator.hpp

@@ -2,50 +2,50 @@
 #define DATE_TIME_TIME_ITERATOR_HPP___
 
 /* Copyright (c) 2002,2003 CrystalClear Software, Inc.
- * Use, modification and distribution is subject to the 
+ * Use, modification and distribution is subject to the
  * Boost Software License, Version 1.0. (See accompanying
  * file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
  * Author: Jeff Garland, Bart Garst
- * $Date: 2008-02-27 12:00:24 -0800 (Wed, 27 Feb 2008) $
+ * $Date: 2012-09-22 15:33:33 -0700 (Sat, 22 Sep 2012) $
  */
 
 
 namespace boost {
 namespace date_time {
-  
+
 
   //! Simple time iterator skeleton class
   template<class time_type>
   class time_itr {
   public:
     typedef typename time_type::time_duration_type time_duration_type;
-    time_itr(time_type t, time_duration_type d) : current_(t), offset_(d) {};
-    time_itr& operator++() 
+    time_itr(time_type t, time_duration_type d) : current_(t), offset_(d) {}
+    time_itr& operator++()
     {
       current_ = current_ + offset_;
       return *this;
     }
-    time_itr& operator--() 
+    time_itr& operator--()
     {
       current_ = current_ - offset_;
       return *this;
     }
-    time_type operator*() {return current_;};
-    time_type* operator->() {return &current_;};
-    bool operator<  (const time_type& t) {return current_ < t;};
-    bool operator<= (const time_type& t) {return current_ <= t;};
-    bool operator!=  (const time_type& t) {return current_ != t;};
-    bool operator== (const time_type& t) {return current_ == t;};
-    bool operator>  (const time_type& t) {return current_ > t;};
-    bool operator>= (const time_type& t) {return current_ >= t;};
-    
+    time_type operator*() {return current_;}
+    time_type* operator->() {return &current_;}
+    bool operator<  (const time_type& t) {return current_ < t;}
+    bool operator<= (const time_type& t) {return current_ <= t;}
+    bool operator!=  (const time_type& t) {return current_ != t;}
+    bool operator== (const time_type& t) {return current_ == t;}
+    bool operator>  (const time_type& t) {return current_ > t;}
+    bool operator>= (const time_type& t) {return current_ >= t;}
+
   private:
     time_type current_;
     time_duration_type offset_;
   };
-  
 
-  
+
+
 } }//namespace date_time
 
 

3party/boost/boost/date_time/time_parsing.hpp

@@ -6,7 +6,7 @@
  * Boost Software License, Version 1.0. (See accompanying
  * file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
  * Author: Jeff Garland, Bart Garst
- * $Date: 2008-02-27 12:00:24 -0800 (Wed, 27 Feb 2008) $
+ * $Date: 2012-10-10 12:05:03 -0700 (Wed, 10 Oct 2012) $
  */
 
 #include "boost/tokenizer.hpp"
@@ -116,6 +116,7 @@ namespace date_time {
         
         break;
       }
+      default: break;
       }//switch
       pos++;
     }
@@ -153,9 +154,10 @@ namespace date_time {
         std::string& first,
         std::string& second)
   {
-    int sep_pos = static_cast<int>(s.find(sep));
+    std::string::size_type sep_pos = s.find(sep);
     first = s.substr(0,sep_pos);
-    second = s.substr(sep_pos+1);
+    if (sep_pos!=std::string::npos)
+        second = s.substr(sep_pos+1);
     return true;
   }
 
@@ -280,6 +282,7 @@ namespace date_time {
             
             break;
           }
+          default: break;
       };
       pos++;
     }

3party/boost/boost/date_time/time_zone_base.hpp

@@ -2,10 +2,10 @@
 #define _DATE_TIME_TIME_ZONE_BASE__
 
 /* Copyright (c) 2003-2005 CrystalClear Software, Inc.
- * Subject to the Boost Software License, Version 1.0. 
+ * Subject to the Boost Software License, Version 1.0.
  * (See accompanying file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
  * Author: Jeff Garland, Bart Garst
- * $Date: 2008-02-27 12:00:24 -0800 (Wed, 27 Feb 2008) $
+ * $Date: 2012-09-22 15:33:33 -0700 (Sat, 22 Sep 2012) $
  */
 
 
@@ -26,9 +26,9 @@ namespace date_time {
    *  would be to convert from POSIX timezone strings.  Regardless of
    *  the construction technique, this is the interface that these
    *  time zone types must provide.
-   * 
+   *
    * Note that this class is intended to be used as a shared
-   * resource (hence the derivation from boost::counted_base.  
+   * resource (hence the derivation from boost::counted_base.
    */
   template<typename time_type, typename CharT>
   class time_zone_base  {
@@ -39,8 +39,8 @@ namespace date_time {
     typedef typename time_type::date_type::year_type year_type;
     typedef typename time_type::time_duration_type time_duration_type;
 
-    time_zone_base() {};
-    virtual ~time_zone_base() {};
+    time_zone_base() {}
+    virtual ~time_zone_base() {}
     //!String for the timezone when in daylight savings (eg: EDT)
     virtual string_type dst_zone_abbrev() const=0;
     //!String for the zone when not in daylight savings (eg: EST)
@@ -61,9 +61,9 @@ namespace date_time {
     virtual time_duration_type dst_offset() const=0;
     //! Returns a POSIX time_zone string for this object
     virtual string_type to_posix_string() const =0;
-    
+
   private:
-    
+
   };
 
 
@@ -82,7 +82,7 @@ namespace date_time {
       dst_start_offset_(dst_start_offset),
       dst_end_offset_(dst_end_offset)
     {}
-    
+
     //! Amount DST adjusts the clock eg: plus one hour
     time_duration_type dst_adjust_;
     //! Time past midnight on start transition day that dst starts