Add abstract_clock, manual_clock, chrono_io

Conflicts:
	src/beast/Builds/VisualStudio2012/beast.vcxproj.filters

src/beast/Builds/VisualStudio2012/beast.vcxproj

@@ -88,7 +88,11 @@
     <ClInclude Include="..\..\beast\Boost.h" />
     <ClInclude Include="..\..\beast\boost\ErrorCode.h" />
     <ClInclude Include="..\..\beast\ByteOrder.h" />
+    <ClInclude Include="..\..\beast\chrono\chrono_io.h" />
     <ClInclude Include="..\..\beast\chrono\CPUMeter.h" />
+    <ClInclude Include="..\..\beast\chrono\abstract_clock.h" />
+    <ClInclude Include="..\..\beast\chrono\manual_clock.h" />
+    <ClInclude Include="..\..\beast\chrono\ratio_io.h" />
     <ClInclude Include="..\..\beast\chrono\RelativeTime.h" />
     <ClInclude Include="..\..\beast\chrono\ScopedTimeInterval.h" />
     <ClInclude Include="..\..\beast\Config.h" />
@@ -402,12 +406,24 @@
     </ClCompile>
     <ClCompile Include="..\..\beast\boost\Boost.cpp" />
     <ClCompile Include="..\..\beast\chrono\Chrono.cpp" />
+    <ClCompile Include="..\..\beast\chrono\impl\chrono_io.cpp">
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|x64'">true</ExcludedFromBuild>
+    </ClCompile>
     <ClCompile Include="..\..\beast\chrono\impl\CPUMeter.cpp">
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|x64'">true</ExcludedFromBuild>
     </ClCompile>
+    <ClCompile Include="..\..\beast\chrono\impl\abstract_clock.cpp">
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|x64'">true</ExcludedFromBuild>
+    </ClCompile>
     <ClCompile Include="..\..\beast\chrono\impl\RelativeTime.cpp">
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">true</ExcludedFromBuild>

src/beast/Builds/VisualStudio2012/beast.vcxproj.filters

@@ -1227,6 +1227,18 @@
     <ClInclude Include="..\..\beast\crypto\UnsignedIntegerCalc.h">
       <Filter>beast\crypto</Filter>
     </ClInclude>
+    <ClInclude Include="..\..\beast\chrono\abstract_clock.h">
+      <Filter>beast\chrono</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\beast\chrono\manual_clock.h">
+      <Filter>beast\chrono</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\beast\chrono\ratio_io.h">
+      <Filter>beast\chrono</Filter>
+    </ClInclude>
+    <ClInclude Include="..\..\beast\chrono\chrono_io.h">
+      <Filter>beast\chrono</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="..\..\modules\beast_core\containers\DynamicObject.cpp">
@@ -1778,6 +1790,12 @@
     <ClCompile Include="..\..\beast\insight\impl\Hook.cpp">
       <Filter>beast\insight\impl</Filter>
     </ClCompile>
+    <ClCompile Include="..\..\beast\chrono\impl\abstract_clock.cpp">
+      <Filter>beast\chrono\impl</Filter>
+    </ClCompile>
+    <ClCompile Include="..\..\beast\chrono\impl\chrono_io.cpp">
+      <Filter>beast\chrono\impl</Filter>
+    </ClCompile>
     <ClCompile Include="..\..\beast\crypto\impl\BinaryEncoding.cpp">
       <Filter>beast\crypto\impl</Filter>
     </ClCompile>

src/beast/beast/Chrono.h

@@ -20,6 +20,11 @@
 #ifndef BEAST_CHRONO_H_INCLUDED
 #define BEAST_CHRONO_H_INCLUDED
 
+#include "chrono/abstract_clock.h"
+#include "chrono/chrono_io.h"
+#include "chrono/manual_clock.h"
+#include "chrono/ratio_io.h"
+
 #include "chrono/CPUMeter.h"
 #include "chrono/RelativeTime.h"
 #include "chrono/ScopedTimeInterval.h"

src/beast/beast/chrono/Chrono.cpp

@@ -19,5 +19,11 @@
 
 #include "BeastConfig.h"
 
+#include "../Config.h"
+#include "../../modules/beast_core/beast_core.h" // for UnitTest
+
+#include "impl/abstract_clock.cpp"
+#include "impl/chrono_io.cpp"
+
 #include "impl/CPUMeter.cpp"
 #include "impl/RelativeTime.cpp"

src/beast/beast/chrono/abstract_clock.h

@@ -0,0 +1,166 @@
+//------------------------------------------------------------------------------
+/*
+    This file is part of Beast: https://github.com/vinniefalco/Beast
+    Copyright 2013, Vinnie Falco <vinnie.falco@gmail.com>
+
+    Permission to use, copy, modify, and/or distribute this software for any
+    purpose  with  or without fee is hereby granted, provided that the above
+    copyright notice and this permission notice appear in all copies.
+
+    THE  SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+    WITH  REGARD  TO  THIS  SOFTWARE  INCLUDING  ALL  IMPLIED  WARRANTIES  OF
+    MERCHANTABILITY  AND  FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+    ANY  SPECIAL ,  DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+    WHATSOEVER  RESULTING  FROM  LOSS  OF USE, DATA OR PROFITS, WHETHER IN AN
+    ACTION  OF  CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+//==============================================================================
+
+#ifndef BEAST_CHRONO_ABSTRACT_CLOCK_H_INCLUDED
+#define BEAST_CHRONO_ABSTRACT_CLOCK_H_INCLUDED
+
+#include <chrono>
+
+#include "chrono_io.h"
+
+namespace beast {
+
+/** Abstract interface to a clock.
+
+    The abstract clock interface allows a dependency injection to take
+    place so that the choice of implementation can be made at run-time
+    instead of compile time. The trade-off is that the Duration used to
+    represent the clock must be chosen at compile time and cannot be
+    changed. This includes both the choice of representation (integers
+    for example) and the period in ticks corresponding to one second.
+
+    Example:
+
+    @code
+
+    struct Implementation
+    {
+        abstract_clock <std::chrono::seconds>& m_clock;
+
+        // Dependency injection
+        //
+        explicit Implementation (
+            abstract_clock <std::chrono::seconds>& clock)
+            : m_clock (clock)
+        {
+        }
+    };
+
+    @endcode
+
+    @tparam The length of time, in seconds, corresponding to one tick.
+*/
+template <class Duration>
+class abstract_clock
+{
+public:
+    typedef typename Duration::rep rep;
+    typedef typename Duration::period period;
+    typedef Duration duration;
+    typedef std::chrono::time_point <
+        abstract_clock, duration> time_point;
+
+    virtual ~abstract_clock () { }
+
+    /** Returns `true` if this is a steady clock. */
+    virtual bool is_steady () const = 0;
+
+    /** Returns the current time. */
+    virtual time_point now () = 0;
+
+    /** Convert the specified time point to a string. */
+    /** @{ */
+    virtual std::string to_string (time_point const& tp) = 0;
+
+    template <class Duration2>
+    std::string to_string (
+        std::chrono::time_point <abstract_clock, Duration2> const& tp)
+    {
+        return to_string (
+            std::chrono::time_point_cast <Duration> (tp));
+    }
+    /** @} */
+
+    /** Returning elapsed ticks since the epoch. */
+    rep elapsed ()
+    {
+        return now().time_since_epoch().count();
+    }
+};
+
+//------------------------------------------------------------------------------
+
+namespace detail {
+
+template <class TrivialClock, class Duration>
+struct basic_abstract_clock_wrapper : public abstract_clock <Duration>
+{
+    using typename abstract_clock <Duration>::duration;
+    using typename abstract_clock <Duration>::time_point;
+
+    bool is_steady () const
+    {
+        return TrivialClock::is_steady;
+    }
+
+    time_point now ()
+    {
+        return time_point (duration (
+            std::chrono::duration_cast <duration> (
+                TrivialClock::now().time_since_epoch ()).count ()));
+    }
+};
+
+template <class TrivialClock, class Duration>
+struct abstract_clock_wrapper
+    : public basic_abstract_clock_wrapper <TrivialClock, Duration>
+{
+       // generic conversion displays the duration
+    std::string to_string (typename basic_abstract_clock_wrapper <
+        TrivialClock, Duration>::time_point const& tp)
+    {
+        std::stringstream ss;
+        ss << tp.time_since_epoch();
+        return ss.str ();
+    }
+};
+
+/*
+template <class Duration>
+struct abstract_clock_wrapper <std::chrono::system_clock, Duration>
+    : public basic_abstract_clock_wrapper <std::chrono::system_clock, Duration>
+{
+    typedef std::chrono::system_clock clock_type;
+    std::string to_string (time_point const& tp)
+    {
+        std::stringstream ss;
+        ss << clock_type::time_point (tp.time_since_epoch ());
+        return ss.str ();
+    }
+};
+*/
+
+}
+
+//------------------------------------------------------------------------------
+
+/** Retrieve a discrete clock for a type implementing the Clock concept.
+    The interface is created as an object with static storage duration.
+*/
+template <class TrivialClock, class Duration>
+abstract_clock <Duration>& get_abstract_clock ()
+{
+    static detail::abstract_clock_wrapper <
+        TrivialClock, Duration> clock;
+    return clock;
+}
+
+}
+
+#endif

src/beast/beast/chrono/impl/abstract_clock.cpp

@@ -0,0 +1,106 @@
+//------------------------------------------------------------------------------
+/*
+    This file is part of Beast: https://github.com/vinniefalco/Beast
+    Copyright 2013, Vinnie Falco <vinnie.falco@gmail.com>
+
+    Permission to use, copy, modify, and/or distribute this software for any
+    purpose  with  or without fee is hereby granted, provided that the above
+    copyright notice and this permission notice appear in all copies.
+
+    THE  SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+    WITH  REGARD  TO  THIS  SOFTWARE  INCLUDING  ALL  IMPLIED  WARRANTIES  OF
+    MERCHANTABILITY  AND  FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+    ANY  SPECIAL ,  DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+    WHATSOEVER  RESULTING  FROM  LOSS  OF USE, DATA OR PROFITS, WHETHER IN AN
+    ACTION  OF  CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+//==============================================================================
+
+#include "../abstract_clock.h"
+#include "../manual_clock.h"
+
+#include <thread>
+
+#include <string>
+#include <sstream>
+
+namespace beast {
+
+template <class CharT, class Traits, class Duration1, class Duration2>
+std::basic_ostream <CharT, Traits>& operator<< (
+    std::basic_ostream<CharT, Traits>& os, std::chrono::time_point <
+        abstract_clock <Duration1>, Duration2> const& tp)
+{
+    return os;
+}
+
+class abstract_clock_tests : public UnitTest
+{
+public:
+    void test (abstract_clock <std::chrono::seconds>& c)
+    {
+        {
+            auto const t1 (c.now ());
+            std::this_thread::sleep_for (
+                std::chrono::milliseconds (1500));
+            auto const t2 (c.now ());
+
+            std::stringstream ss;
+            ss <<
+                "t1= " << c.to_string (t1) <<
+                ", t2= " << c.to_string (t2) <<
+                ", elapsed= " << (t2 - t1);
+            logMessage (ss.str());
+        }
+    }
+
+    void test_manual ()
+    {
+        typedef manual_clock <std::chrono::seconds> clock_type;
+        clock_type c;
+
+        std::stringstream ss;
+
+        ss << "now() = " << c.to_string (c.now ()) << std::endl;
+
+        c.set (clock_type::time_point (std::chrono::seconds (1)));
+        ss << "now() = " << c.to_string (c.now ()) << std::endl;
+
+        c.set (clock_type::time_point (std::chrono::seconds (2)));
+        ss << "now() = " << c.to_string (c.now ()) << std::endl;
+
+        logMessage (ss.str());
+    }
+
+    void runTest ()
+    {
+        beginTestCase ("Syntax");
+
+        logMessage ("steady_clock");
+        test (get_abstract_clock <std::chrono::steady_clock,
+            std::chrono::seconds> ());
+
+        logMessage ("system_clock");
+        test (get_abstract_clock <std::chrono::system_clock,
+            std::chrono::seconds> ());
+
+        logMessage ("high_resolution_clock");
+        test (get_abstract_clock <std::chrono::high_resolution_clock,
+            std::chrono::seconds> ());
+
+        logMessage ("manual_clock");
+        test_manual ();
+
+        pass ();
+    }
+
+    abstract_clock_tests ()
+        : UnitTest ("abstract_clock", "beast", runManual)
+    {
+    }
+};
+
+static abstract_clock_tests abstract_clock_tests_;
+
+}

src/beast/beast/chrono/impl/chrono_io.cpp

@@ -0,0 +1,41 @@
+//------------------------------------------------------------------------------
+/*
+    This file is part of Beast: https://github.com/vinniefalco/Beast
+    Copyright 2013, Vinnie Falco <vinnie.falco@gmail.com>
+
+    Permission to use, copy, modify, and/or distribute this software for any
+    purpose  with  or without fee is hereby granted, provided that the above
+    copyright notice and this permission notice appear in all copies.
+
+    THE  SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+    WITH  REGARD  TO  THIS  SOFTWARE  INCLUDING  ALL  IMPLIED  WARRANTIES  OF
+    MERCHANTABILITY  AND  FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+    ANY  SPECIAL ,  DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+    WHATSOEVER  RESULTING  FROM  LOSS  OF USE, DATA OR PROFITS, WHETHER IN AN
+    ACTION  OF  CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+//==============================================================================
+
+//  chrono_io
+//
+//  (C) Copyright Howard Hinnant
+//  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).
+
+#include "../chrono_io.h"
+
+//_LIBCPP_BEGIN_NAMESPACE_STD
+namespace std {
+
+namespace chrono
+{
+
+locale::id
+durationpunct::id;
+
+}  // chrono
+
+//_LIBCPP_END_NAMESPACE_STD
+}

src/beast/beast/chrono/manual_clock.h

@@ -0,0 +1,92 @@
+//------------------------------------------------------------------------------
+/*
+    This file is part of Beast: https://github.com/vinniefalco/Beast
+    Copyright 2013, Vinnie Falco <vinnie.falco@gmail.com>
+
+    Permission to use, copy, modify, and/or distribute this software for any
+    purpose  with  or without fee is hereby granted, provided that the above
+    copyright notice and this permission notice appear in all copies.
+
+    THE  SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+    WITH  REGARD  TO  THIS  SOFTWARE  INCLUDING  ALL  IMPLIED  WARRANTIES  OF
+    MERCHANTABILITY  AND  FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+    ANY  SPECIAL ,  DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+    WHATSOEVER  RESULTING  FROM  LOSS  OF USE, DATA OR PROFITS, WHETHER IN AN
+    ACTION  OF  CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+//==============================================================================
+
+#ifndef BEAST_CHRONO_MANUAL_CLOCK_H_INCLUDED
+#define BEAST_CHRONO_MANUAL_CLOCK_H_INCLUDED
+
+#include "abstract_clock.h"
+
+namespace beast {
+
+/** Manual clock implementation.
+    This concrete class implements the @ref abstract_clock interface and
+    allows the time to be advanced manually, mainly for the purpose of
+    providing a clock in unit tests.
+    @tparam The length of time, in seconds, corresponding to one tick.
+*/
+template <class Duration, bool IsSteady = true>
+class manual_clock : public abstract_clock <Duration>
+{
+public:
+    using typename abstract_clock <Duration>::rep;
+    using typename abstract_clock <Duration>::duration;
+    using typename abstract_clock <Duration>::time_point;
+
+    explicit manual_clock (time_point const& t = time_point (Duration (0)))
+        : m_now (t)
+    {
+    }
+
+    bool is_steady () const
+    {
+        return IsSteady;
+    }
+
+    time_point now ()
+    {
+        return m_now;
+    }
+
+    std::string to_string (time_point const& tp)
+    {
+        std::stringstream ss;
+        ss << tp.time_since_epoch() << " from start";
+        return ss.str ();
+    }
+
+    /** Set the current time of the manual clock.
+        Precondition:
+            ! IsSteady || t > now()
+    */
+    void set (time_point const& t)
+    {
+        //if (IsSteady)
+        m_now = t;
+    }
+
+    /** Convenience for setting the time using a duration in @ref rep units. */
+    void set (rep v)
+    {
+        set (time_point (duration (v)));
+    }
+
+    /** Convenience for advancing the clock by one. */
+    manual_clock& operator++ ()
+    {
+        m_now += duration (1);
+        return *this;
+    }
+
+private:
+    time_point m_now;
+};
+
+}
+
+#endif

src/beast/beast/chrono/ratio_io.h

@@ -0,0 +1,622 @@
+//------------------------------------------------------------------------------
+/*
+    This file is part of Beast: https://github.com/vinniefalco/Beast
+    Copyright 2013, Vinnie Falco <vinnie.falco@gmail.com>
+
+    Permission to use, copy, modify, and/or distribute this software for any
+    purpose  with  or without fee is hereby granted, provided that the above
+    copyright notice and this permission notice appear in all copies.
+
+    THE  SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+    WITH  REGARD  TO  THIS  SOFTWARE  INCLUDING  ALL  IMPLIED  WARRANTIES  OF
+    MERCHANTABILITY  AND  FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+    ANY  SPECIAL ,  DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+    WHATSOEVER  RESULTING  FROM  LOSS  OF USE, DATA OR PROFITS, WHETHER IN AN
+    ACTION  OF  CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+//==============================================================================
+
+//  ratio_io
+//
+//  (C) Copyright Howard Hinnant
+//  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 BEAST_CHRONO_RATIO_IO_H_INCLUDED
+#define BEAST_CHRONO_RATIO_IO_H_INCLUDED
+
+/*
+
+    ratio_io synopsis
+
+#include <ratio>
+#include <string>
+
+namespace std
+{
+
+template <class Ratio, class charT>
+struct ratio_string
+{
+    static basic_string<charT> symbol();
+    static basic_string<charT> prefix();
+};
+
+}  // std
+
+*/
+
+#include <ratio>
+#include <string>
+#include <sstream>
+
+//_LIBCPP_BEGIN_NAMESPACE_STD
+namespace std {
+
+template <class _Ratio, class _CharT>
+struct ratio_string
+{
+    static basic_string<_CharT> symbol() {return prefix();}
+    static basic_string<_CharT> prefix();
+};
+
+template <class _Ratio, class _CharT>
+basic_string<_CharT>
+ratio_string<_Ratio, _CharT>::prefix()
+{
+    basic_ostringstream<_CharT> __os;
+    __os << _CharT('[') << _Ratio::num << _CharT('/')
+                        << _Ratio::den << _CharT(']');
+    return __os.str();
+}
+
+// atto
+
+template <>
+struct ratio_string<atto, char>
+{
+    static string symbol() {return string(1, 'a');}
+    static string prefix()  {return string("atto");}
+};
+
+#if HAS_UNICODE_SUPPORT
+
+template <>
+struct ratio_string<atto, char16_t>
+{
+    static u16string symbol() {return u16string(1, u'a');}
+    static u16string prefix()  {return u16string(u"atto");}
+};
+
+template <>
+struct ratio_string<atto, char32_t>
+{
+    static u32string symbol() {return u32string(1, U'a');}
+    static u32string prefix()  {return u32string(U"atto");}
+};
+
+#endif
+
+template <>
+struct ratio_string<atto, wchar_t>
+{
+    static wstring symbol() {return wstring(1, L'a');}
+    static wstring prefix()  {return wstring(L"atto");}
+};
+
+// femto
+
+template <>
+struct ratio_string<femto, char>
+{
+    static string symbol() {return string(1, 'f');}
+    static string prefix()  {return string("femto");}
+};
+
+#if HAS_UNICODE_SUPPORT
+
+template <>
+struct ratio_string<femto, char16_t>
+{
+    static u16string symbol() {return u16string(1, u'f');}
+    static u16string prefix()  {return u16string(u"femto");}
+};
+
+template <>
+struct ratio_string<femto, char32_t>
+{
+    static u32string symbol() {return u32string(1, U'f');}
+    static u32string prefix()  {return u32string(U"femto");}
+};
+
+#endif
+
+template <>
+struct ratio_string<femto, wchar_t>
+{
+    static wstring symbol() {return wstring(1, L'f');}
+    static wstring prefix()  {return wstring(L"femto");}
+};
+
+// pico
+
+template <>
+struct ratio_string<pico, char>
+{
+    static string symbol() {return string(1, 'p');}
+    static string prefix()  {return string("pico");}
+};
+
+#if HAS_UNICODE_SUPPORT
+
+template <>
+struct ratio_string<pico, char16_t>
+{
+    static u16string symbol() {return u16string(1, u'p');}
+    static u16string prefix()  {return u16string(u"pico");}
+};
+
+template <>
+struct ratio_string<pico, char32_t>
+{
+    static u32string symbol() {return u32string(1, U'p');}
+    static u32string prefix()  {return u32string(U"pico");}
+};
+
+#endif
+
+template <>
+struct ratio_string<pico, wchar_t>
+{
+    static wstring symbol() {return wstring(1, L'p');}
+    static wstring prefix()  {return wstring(L"pico");}
+};
+
+// nano
+
+template <>
+struct ratio_string<nano, char>
+{
+    static string symbol() {return string(1, 'n');}
+    static string prefix()  {return string("nano");}
+};
+
+#if HAS_UNICODE_SUPPORT
+
+template <>
+struct ratio_string<nano, char16_t>
+{
+    static u16string symbol() {return u16string(1, u'n');}
+    static u16string prefix()  {return u16string(u"nano");}
+};
+
+template <>
+struct ratio_string<nano, char32_t>
+{
+    static u32string symbol() {return u32string(1, U'n');}
+    static u32string prefix()  {return u32string(U"nano");}
+};
+
+#endif
+
+template <>
+struct ratio_string<nano, wchar_t>
+{
+    static wstring symbol() {return wstring(1, L'n');}
+    static wstring prefix()  {return wstring(L"nano");}
+};
+
+// micro
+
+template <>
+struct ratio_string<micro, char>
+{
+    static string symbol() {return string("\xC2\xB5");}
+    static string prefix()  {return string("micro");}
+};
+
+#if HAS_UNICODE_SUPPORT
+
+template <>
+struct ratio_string<micro, char16_t>
+{
+    static u16string symbol() {return u16string(1, u'\xB5');}
+    static u16string prefix()  {return u16string(u"micro");}
+};
+
+template <>
+struct ratio_string<micro, char32_t>
+{
+    static u32string symbol() {return u32string(1, U'\xB5');}
+    static u32string prefix()  {return u32string(U"micro");}
+};
+
+#endif
+
+template <>
+struct ratio_string<micro, wchar_t>
+{
+    static wstring symbol() {return wstring(1, L'\xB5');}
+    static wstring prefix()  {return wstring(L"micro");}
+};
+
+// milli
+
+template <>
+struct ratio_string<milli, char>
+{
+    static string symbol() {return string(1, 'm');}
+    static string prefix()  {return string("milli");}
+};
+
+#if HAS_UNICODE_SUPPORT
+
+template <>
+struct ratio_string<milli, char16_t>
+{
+    static u16string symbol() {return u16string(1, u'm');}
+    static u16string prefix()  {return u16string(u"milli");}
+};
+
+template <>
+struct ratio_string<milli, char32_t>
+{
+    static u32string symbol() {return u32string(1, U'm');}
+    static u32string prefix()  {return u32string(U"milli");}
+};
+
+#endif
+
+template <>
+struct ratio_string<milli, wchar_t>
+{
+    static wstring symbol() {return wstring(1, L'm');}
+    static wstring prefix()  {return wstring(L"milli");}
+};
+
+// centi
+
+template <>
+struct ratio_string<centi, char>
+{
+    static string symbol() {return string(1, 'c');}
+    static string prefix()  {return string("centi");}
+};
+
+#if HAS_UNICODE_SUPPORT
+
+template <>
+struct ratio_string<centi, char16_t>
+{
+    static u16string symbol() {return u16string(1, u'c');}
+    static u16string prefix()  {return u16string(u"centi");}
+};
+
+template <>
+struct ratio_string<centi, char32_t>
+{
+    static u32string symbol() {return u32string(1, U'c');}
+    static u32string prefix()  {return u32string(U"centi");}
+};
+
+#endif
+
+template <>
+struct ratio_string<centi, wchar_t>
+{
+    static wstring symbol() {return wstring(1, L'c');}
+    static wstring prefix()  {return wstring(L"centi");}
+};
+
+// deci
+
+template <>
+struct ratio_string<deci, char>
+{
+    static string symbol() {return string(1, 'd');}
+    static string prefix()  {return string("deci");}
+};
+
+#if HAS_UNICODE_SUPPORT
+
+template <>
+struct ratio_string<deci, char16_t>
+{
+    static u16string symbol() {return u16string(1, u'd');}
+    static u16string prefix()  {return u16string(u"deci");}
+};
+
+template <>
+struct ratio_string<deci, char32_t>
+{
+    static u32string symbol() {return u32string(1, U'd');}
+    static u32string prefix()  {return u32string(U"deci");}
+};
+
+#endif
+
+template <>
+struct ratio_string<deci, wchar_t>
+{
+    static wstring symbol() {return wstring(1, L'd');}
+    static wstring prefix()  {return wstring(L"deci");}
+};
+
+// deca
+
+template <>
+struct ratio_string<deca, char>
+{
+    static string symbol() {return string("da");}
+    static string prefix()  {return string("deca");}
+};
+
+#if HAS_UNICODE_SUPPORT
+
+template <>
+struct ratio_string<deca, char16_t>
+{
+    static u16string symbol() {return u16string(u"da");}
+    static u16string prefix()  {return u16string(u"deca");}
+};
+
+template <>
+struct ratio_string<deca, char32_t>
+{
+    static u32string symbol() {return u32string(U"da");}
+    static u32string prefix()  {return u32string(U"deca");}
+};
+
+#endif
+
+template <>
+struct ratio_string<deca, wchar_t>
+{
+    static wstring symbol() {return wstring(L"da");}
+    static wstring prefix()  {return wstring(L"deca");}
+};
+
+// hecto
+
+template <>
+struct ratio_string<hecto, char>
+{
+    static string symbol() {return string(1, 'h');}
+    static string prefix()  {return string("hecto");}
+};
+
+#if HAS_UNICODE_SUPPORT
+
+template <>
+struct ratio_string<hecto, char16_t>
+{
+    static u16string symbol() {return u16string(1, u'h');}
+    static u16string prefix()  {return u16string(u"hecto");}
+};
+
+template <>
+struct ratio_string<hecto, char32_t>
+{
+    static u32string symbol() {return u32string(1, U'h');}
+    static u32string prefix()  {return u32string(U"hecto");}
+};
+
+#endif
+
+template <>
+struct ratio_string<hecto, wchar_t>
+{
+    static wstring symbol() {return wstring(1, L'h');}
+    static wstring prefix()  {return wstring(L"hecto");}
+};
+
+// kilo
+
+template <>
+struct ratio_string<kilo, char>
+{
+    static string symbol() {return string(1, 'k');}
+    static string prefix()  {return string("kilo");}
+};
+
+#if HAS_UNICODE_SUPPORT
+
+template <>
+struct ratio_string<kilo, char16_t>
+{
+    static u16string symbol() {return u16string(1, u'k');}
+    static u16string prefix()  {return u16string(u"kilo");}
+};
+
+template <>
+struct ratio_string<kilo, char32_t>
+{
+    static u32string symbol() {return u32string(1, U'k');}
+    static u32string prefix()  {return u32string(U"kilo");}
+};
+
+#endif
+
+template <>
+struct ratio_string<kilo, wchar_t>
+{
+    static wstring symbol() {return wstring(1, L'k');}
+    static wstring prefix()  {return wstring(L"kilo");}
+};
+
+// mega
+
+template <>
+struct ratio_string<mega, char>
+{
+    static string symbol() {return string(1, 'M');}
+    static string prefix()  {return string("mega");}
+};
+
+#if HAS_UNICODE_SUPPORT
+
+template <>
+struct ratio_string<mega, char16_t>
+{
+    static u16string symbol() {return u16string(1, u'M');}
+    static u16string prefix()  {return u16string(u"mega");}
+};
+
+template <>
+struct ratio_string<mega, char32_t>
+{
+    static u32string symbol() {return u32string(1, U'M');}
+    static u32string prefix()  {return u32string(U"mega");}
+};
+
+#endif
+
+template <>
+struct ratio_string<mega, wchar_t>
+{
+    static wstring symbol() {return wstring(1, L'M');}
+    static wstring prefix()  {return wstring(L"mega");}
+};
+
+// giga
+
+template <>
+struct ratio_string<giga, char>
+{
+    static string symbol() {return string(1, 'G');}
+    static string prefix()  {return string("giga");}
+};
+
+#if HAS_UNICODE_SUPPORT
+
+template <>
+struct ratio_string<giga, char16_t>
+{
+    static u16string symbol() {return u16string(1, u'G');}
+    static u16string prefix()  {return u16string(u"giga");}
+};
+
+template <>
+struct ratio_string<giga, char32_t>
+{
+    static u32string symbol() {return u32string(1, U'G');}
+    static u32string prefix()  {return u32string(U"giga");}
+};
+
+#endif
+
+template <>
+struct ratio_string<giga, wchar_t>
+{
+    static wstring symbol() {return wstring(1, L'G');}
+    static wstring prefix()  {return wstring(L"giga");}
+};
+
+// tera
+
+template <>
+struct ratio_string<tera, char>
+{
+    static string symbol() {return string(1, 'T');}
+    static string prefix()  {return string("tera");}
+};
+
+#if HAS_UNICODE_SUPPORT
+
+template <>
+struct ratio_string<tera, char16_t>
+{
+    static u16string symbol() {return u16string(1, u'T');}
+    static u16string prefix()  {return u16string(u"tera");}
+};
+
+template <>
+struct ratio_string<tera, char32_t>
+{
+    static u32string symbol() {return u32string(1, U'T');}
+    static u32string prefix()  {return u32string(U"tera");}
+};
+
+#endif
+
+template <>
+struct ratio_string<tera, wchar_t>
+{
+    static wstring symbol() {return wstring(1, L'T');}
+    static wstring prefix()  {return wstring(L"tera");}
+};
+
+// peta
+
+template <>
+struct ratio_string<peta, char>
+{
+    static string symbol() {return string(1, 'P');}
+    static string prefix()  {return string("peta");}
+};
+
+#if HAS_UNICODE_SUPPORT
+
+template <>
+struct ratio_string<peta, char16_t>
+{
+    static u16string symbol() {return u16string(1, u'P');}
+    static u16string prefix()  {return u16string(u"peta");}
+};
+
+template <>
+struct ratio_string<peta, char32_t>
+{
+    static u32string symbol() {return u32string(1, U'P');}
+    static u32string prefix()  {return u32string(U"peta");}
+};
+
+#endif
+
+template <>
+struct ratio_string<peta, wchar_t>
+{
+    static wstring symbol() {return wstring(1, L'P');}
+    static wstring prefix()  {return wstring(L"peta");}
+};
+
+// exa
+
+template <>
+struct ratio_string<exa, char>
+{
+    static string symbol() {return string(1, 'E');}
+    static string prefix()  {return string("exa");}
+};
+
+#if HAS_UNICODE_SUPPORT
+
+template <>
+struct ratio_string<exa, char16_t>
+{
+    static u16string symbol() {return u16string(1, u'E');}
+    static u16string prefix()  {return u16string(u"exa");}
+};
+
+template <>
+struct ratio_string<exa, char32_t>
+{
+    static u32string symbol() {return u32string(1, U'E');}
+    static u32string prefix()  {return u32string(U"exa");}
+};
+
+#endif
+
+template <>
+struct ratio_string<exa, wchar_t>
+{
+    static wstring symbol() {return wstring(1, L'E');}
+    static wstring prefix()  {return wstring(L"exa");}
+};
+
+//_LIBCPP_END_NAMESPACE_STD
+}
+
+#endif  // _RATIO_IO