passenger 5.1.12 → 5.2.0

data/src/cxx_supportlib/vendor-modified/boost/chrono/io/duration_io.hpp

@@ -0,0 +1,295 @@
+//  (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/duration.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 <boost/detail/no_exceptions_support.hpp>
+#include <boost/type_traits/is_integral.hpp>
+#include <boost/type_traits/is_floating_point.hpp>
+#include <locale>
+#include <iostream>
+#include <sstream>
+
+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))
+      {
+      }
+
+      /**
+       * 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 new_value @c duration_style to set.
+       */
+      duration_style_io_saver(state_type &s, aspect_type new_value) :
+        s_save_(s), a_save_(get_duration_style(s))
+      {
+        set_duration_style(s, 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:
+      duration_style_io_saver& operator=(duration_style_io_saver const& rhs) ;
+
+      state_type& s_save_;
+      aspect_type a_save_;
+    };
+
+    template <class Rep>
+    struct duration_put_enabled
+      : integral_constant<bool,
+          is_integral<Rep>::value || is_floating_point<Rep>::value
+        >
+     {};
+
+
+    /**
+     * 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>
+    typename boost::enable_if_c< ! duration_put_enabled<Rep>::value, std::basic_ostream<CharT, Traits>& >::type
+    operator<<(std::basic_ostream<CharT, Traits>& os, const duration<Rep, Period>& d)
+    {
+      std::basic_ostringstream<CharT, Traits> ostr;
+      ostr << d.count();
+      duration<int, Period> dd(0);
+      bool failed = false;
+      BOOST_TRY
+      {
+        std::ios_base::iostate err = std::ios_base::goodbit;
+        BOOST_TRY
+        {
+          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(), dd, ostr.str().c_str()) .failed())
+              {
+                err = std::ios_base::badbit;
+              }
+            }
+            else if (std::use_facet<duration_put<CharT> >(os.getloc()) .put(os, os, os.fill(), dd, ostr.str().c_str()) .failed())
+            {
+              err = std::ios_base::badbit;
+            }
+            os.width(0);
+          }
+        }
+        BOOST_CATCH(...)
+        {
+          bool flag = false;
+          BOOST_TRY
+          {
+            os.setstate(std::ios_base::failbit);
+          }
+          BOOST_CATCH (std::ios_base::failure )
+          {
+            flag = true;
+          }
+          BOOST_CATCH_END
+          if (flag) throw;
+        }
+        BOOST_CATCH_END
+        if (err) os.setstate(err);
+        return os;
+      }
+      BOOST_CATCH(...)
+      {
+        failed = true;
+      }
+      BOOST_CATCH_END
+      if (failed) os.setstate(std::ios_base::failbit | std::ios_base::badbit);
+      return os;
+
+    }
+
+    template <class CharT, class Traits, class Rep, class Period>
+    typename boost::enable_if_c< duration_put_enabled<Rep>::value, std::basic_ostream<CharT, Traits>& >::type
+    operator<<(std::basic_ostream<CharT, Traits>& os, const duration<Rep, Period>& d)
+    {
+      bool failed = false;
+      BOOST_TRY
+      {
+        std::ios_base::iostate err = std::ios_base::goodbit;
+        BOOST_TRY
+        {
+          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);
+          }
+        }
+        BOOST_CATCH(...)
+        {
+          bool flag = false;
+          BOOST_TRY
+          {
+            os.setstate(std::ios_base::failbit);
+          }
+          BOOST_CATCH (std::ios_base::failure )
+          {
+            flag = true;
+          }
+          BOOST_CATCH_END
+          if (flag) throw;
+        }
+        BOOST_CATCH_END
+        if (err) os.setstate(err);
+        return os;
+      }
+      BOOST_CATCH(...)
+      {
+        failed = true;
+      }
+      BOOST_CATCH_END
+      if (failed) os.setstate(std::ios_base::failbit | std::ios_base::badbit);
+      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;
+
+      BOOST_TRY
+      {
+        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);
+          }
+        }
+      }
+      BOOST_CATCH (...)
+      {
+        bool flag = false;
+        BOOST_TRY
+        {
+          is.setstate(std::ios_base::failbit);
+        }
+        BOOST_CATCH (std::ios_base::failure )
+        {
+          flag = true;
+        }
+        BOOST_CATCH_END
+        if (flag) { BOOST_RETHROW }
+      }
+      BOOST_CATCH_END
+      if (err) is.setstate(err);
+      return is;
+    }
+
+  } // chrono
+
+}
+
+#endif  // header

data/src/cxx_supportlib/vendor-modified/boost/chrono/io/duration_put.hpp

@@ -0,0 +1,317 @@
+//  (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/chrono/process_cpu_clocks.hpp>
+#include <boost/assert.hpp>
+#include <locale>
+
+namespace boost
+{
+  namespace chrono
+  {
+
+    namespace detail
+    {
+      template <class T>
+      struct propagate {
+        typedef T type;
+      };
+      template <>
+      struct propagate<boost::int_least32_t> {
+        typedef boost::int_least64_t type;
+      };
+    }
+    /**
+     * @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 char_type* val = 0) 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, val);
+        }
+        else
+        {
+          duration_units_default<CharT> facet;
+          return put(facet, s, ios, fill, d, pattern, pat_end, val);
+        }
+      }
+
+      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 char_type* val = 0) 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, val);
+              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 char_type* val = 0) 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(), val);
+        }
+        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(), val);
+        }
+      }
+
+      /**
+       *
+       * @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 char_type* val = 0) const
+      {
+        if (val)
+        {
+          while (*val) {
+            *s = *val;
+            s++; val++;
+          }
+          return s;
+        }
+        return std::use_facet<std::num_put<CharT, iter_type> >(ios.getloc()).put(s, ios, fill,
+            static_cast<typename detail::propagate<Rep>::type> (d.count()));
+      }
+
+      template <typename Rep, typename Period>
+      iter_type put_value(iter_type s, std::ios_base& ios, char_type fill, duration<process_times<Rep>, Period> const& d, const char_type* = 0) const
+      {
+        *s++ = CharT('{');
+        s = put_value(s, ios, fill, process_real_cpu_clock::duration(d.count().real));
+        *s++ = CharT(';');
+        s = put_value(s, ios, fill, process_user_cpu_clock::duration(d.count().user));
+        *s++ = CharT(';');
+        s = put_value(s, ios, fill, process_system_cpu_clock::duration(d.count().system));
+        *s++ = CharT('}');
+        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 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;
+      }
+      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<process_times<Rep>, Period> const& d) const
+      {
+        duration<Rep,Period> real(d.count().real);
+        if (facet.template is_named_unit<Period>()) {
+          string_type str = facet.get_unit(get_duration_style(ios), real);
+          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), real);
+          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