mirror of
https://github.com/XRPLF/rippled.git
synced 2025-11-20 02:55:50 +00:00
623 lines
13 KiB
C++
623 lines
13 KiB
C++
//------------------------------------------------------------------------------
|
|
/*
|
|
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
|