ceph/src/boost/libs/ratio/include/boost/ratio/detail/ratio_io.hpp

   1 //  ratio_io
   2 //
   3 //  (C) Copyright Howard Hinnant
   4 //  (C) Copyright 2010 Vicente J. Botet Escriba
   5 //  Use, modification and distribution are subject to the Boost Software License,
   6 //  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
   7 //  http://www.boost.org/LICENSE_1_0.txt).
   8 //
   9 // This code was adapted by Vicente from Howard Hinnant's experimental work
  10 // on chrono i/o under lvm/libc++ to Boost
  11
  12 #ifndef BOOST_RATIO_DETAIL_RATIO_IO_HPP
  13 #define BOOST_RATIO_DETAIL_RATIO_IO_HPP
  14
  15 /*
  16
  17     ratio_io synopsis
  18
  19 #include <ratio>
  20 #include <string>
  21
  22 namespace boost
  23 {
  24
  25 template <class Ratio, class CharT>
  26 struct ratio_string
  27 {
  28     static basic_string<CharT> short_name();
  29     static basic_string<CharT> long_name();
  30 };
  31
  32 }  // boost
  33
  34 */
  35
  36 #include <boost/config.hpp>
  37 #include <boost/ratio/ratio.hpp>
  38 #include <boost/type_traits/integral_constant.hpp>
  39 #include <string>
  40 #include <sstream>
  41
  42 #if defined(BOOST_NO_CXX11_UNICODE_LITERALS) || defined(BOOST_NO_CXX11_CHAR16_T) || defined(BOOST_NO_CXX11_CHAR32_T) || defined(BOOST_NO_CXX11_U16STRING) || defined(BOOST_NO_CXX11_U32STRING)
  43 #if defined BOOST_RATIO_HAS_UNICODE_SUPPORT
  44 #undef BOOST_RATIO_HAS_UNICODE_SUPPORT
  45 #endif
  46 #else
  47 #define BOOST_RATIO_HAS_UNICODE_SUPPORT 1
  48 #endif
  49
  50 namespace boost {
  51
  52 //template <class Ratio>
  53 //struct ratio_string_is_localizable : false_type {};
  54 //template <class Ratio>
  55 //struct ratio_string_id : integral_constant<int,0> {};
  56
  57 template <class Ratio, class CharT>
  58 struct ratio_string
  59 {
  60     static std::basic_string<CharT> short_name() {return long_name();}
  61     static std::basic_string<CharT> long_name();
  62     static std::basic_string<CharT> symbol() {return short_name();}
  63     static std::basic_string<CharT> prefix() {return long_name();}
  64 };
  65
  66 template <class Ratio, class CharT>
  67 std::basic_string<CharT>
  68 ratio_string<Ratio, CharT>::long_name()
  69 {
  70     std::basic_ostringstream<CharT> os;
  71     os << CharT('[') << Ratio::num << CharT('/')
  72                         << Ratio::den << CharT(']');
  73     return os.str();
  74 }
  75
  76 #ifdef BOOST_RATIO_HAS_STATIC_STRING
  77 namespace ratio_detail {
  78 template <class Ratio, class CharT>
  79 struct ratio_string_static
  80 {
  81     static std::string short_name() {
  82         return std::basic_string<CharT>(
  83                 static_string::c_str<
  84                         typename ratio_static_string<Ratio, CharT>::short_name
  85                     >::value);
  86     }
  87     static std::string long_name()  {
  88         return std::basic_string<CharT>(
  89                 static_string::c_str<
  90                     typename ratio_static_string<Ratio, CharT>::long_name
  91                 >::value);
  92     }
  93     static std::basic_string<CharT> symbol() {return short_name();}
  94     static std::basic_string<CharT> prefix() {return long_name();}
  95 };
  96 }
  97 #endif
  98 // atto
  99 //template <>
 100 //struct ratio_string_is_localizable<atto> : true_type {};
 101 //
 102 //template <>
 103 //struct ratio_string_id<atto> : integral_constant<int,-18> {};
 104
 105 #ifdef BOOST_RATIO_HAS_STATIC_STRING
 106 template <typename CharT>
 107 struct ratio_string<atto, CharT> :
 108     ratio_detail::ratio_string_static<atto,CharT>
 109 {};
 110
 111 #else
 112 template <>
 113 struct ratio_string<atto, char>
 114 {
 115     static std::string short_name() {return std::string(1, 'a');}
 116     static std::string long_name()  {return std::string("atto");}
 117     static std::string symbol() {return short_name();}
 118     static std::string prefix() {return long_name();}
 119 };
 120
 121 #if BOOST_RATIO_HAS_UNICODE_SUPPORT
 122
 123 template <>
 124 struct ratio_string<atto, char16_t>
 125 {
 126     static std::u16string short_name() {return std::u16string(1, u'a');}
 127     static std::u16string long_name()  {return std::u16string(u"atto");}
 128     static std::u16string symbol() {return short_name();}
 129     static std::u16string prefix() {return long_name();}
 130 };
 131
 132 template <>
 133 struct ratio_string<atto, char32_t>
 134 {
 135     static std::u32string short_name() {return std::u32string(1, U'a');}
 136     static std::u32string long_name()  {return std::u32string(U"atto");}
 137     static std::u32string symbol() {return short_name();}
 138     static std::u32string prefix() {return long_name();}
 139 };
 140
 141 #endif
 142
 143 #ifndef BOOST_NO_STD_WSTRING
 144 template <>
 145 struct ratio_string<atto, wchar_t>
 146 {
 147     static std::wstring short_name() {return std::wstring(1, L'a');}
 148     static std::wstring long_name()  {return std::wstring(L"atto");}
 149     static std::wstring symbol() {return short_name();}
 150     static std::wstring prefix() {return long_name();}
 151 };
 152 #endif
 153 #endif
 154
 155 // femto
 156
 157 //template <>
 158 //struct ratio_string_is_localizable<femto> : true_type {};
 159 //
 160 //template <>
 161 //struct ratio_string_id<femto> : integral_constant<int,-15> {};
 162
 163 #ifdef BOOST_RATIO_HAS_STATIC_STRING
 164 template <typename CharT>
 165 struct ratio_string<femto, CharT> :
 166     ratio_detail::ratio_string_static<femto,CharT>
 167 {};
 168
 169 #else
 170
 171 template <>
 172 struct ratio_string<femto, char>
 173 {
 174     static std::string short_name() {return std::string(1, 'f');}
 175     static std::string long_name()  {return std::string("femto");}
 176     static std::string symbol() {return short_name();}
 177     static std::string prefix() {return long_name();}
 178 };
 179
 180 #if BOOST_RATIO_HAS_UNICODE_SUPPORT
 181
 182 template <>
 183 struct ratio_string<femto, char16_t>
 184 {
 185     static std::u16string short_name() {return std::u16string(1, u'f');}
 186     static std::u16string long_name()  {return std::u16string(u"femto");}
 187     static std::u16string symbol() {return short_name();}
 188     static std::u16string prefix() {return long_name();}
 189 };
 190
 191 template <>
 192 struct ratio_string<femto, char32_t>
 193 {
 194     static std::u32string short_name() {return std::u32string(1, U'f');}
 195     static std::u32string long_name()  {return std::u32string(U"femto");}
 196     static std::u32string symbol() {return short_name();}
 197     static std::u32string prefix() {return long_name();}
 198 };
 199
 200 #endif
 201
 202 #ifndef BOOST_NO_STD_WSTRING
 203 template <>
 204 struct ratio_string<femto, wchar_t>
 205 {
 206     static std::wstring short_name() {return std::wstring(1, L'f');}
 207     static std::wstring long_name()  {return std::wstring(L"femto");}
 208     static std::wstring symbol() {return short_name();}
 209     static std::wstring prefix() {return long_name();}
 210 };
 211 #endif
 212 #endif
 213
 214 // pico
 215
 216 //template <>
 217 //struct ratio_string_is_localizable<pico> : true_type {};
 218 //
 219 //template <>
 220 //struct ratio_string_id<pico> : integral_constant<int,-12> {};
 221
 222 #ifdef BOOST_RATIO_HAS_STATIC_STRING
 223 template <typename CharT>
 224 struct ratio_string<pico, CharT> :
 225     ratio_detail::ratio_string_static<pico,CharT>
 226 {};
 227
 228 #else
 229 template <>
 230 struct ratio_string<pico, char>
 231 {
 232     static std::string short_name() {return std::string(1, 'p');}
 233     static std::string long_name()  {return std::string("pico");}
 234     static std::string symbol() {return short_name();}
 235     static std::string prefix() {return long_name();}
 236 };
 237
 238 #if BOOST_RATIO_HAS_UNICODE_SUPPORT
 239
 240 template <>
 241 struct ratio_string<pico, char16_t>
 242 {
 243     static std::u16string short_name() {return std::u16string(1, u'p');}
 244     static std::u16string long_name()  {return std::u16string(u"pico");}
 245     static std::u16string symbol() {return short_name();}
 246     static std::u16string prefix() {return long_name();}
 247 };
 248
 249 template <>
 250 struct ratio_string<pico, char32_t>
 251 {
 252     static std::u32string short_name() {return std::u32string(1, U'p');}
 253     static std::u32string long_name()  {return std::u32string(U"pico");}
 254     static std::u32string symbol() {return short_name();}
 255     static std::u32string prefix() {return long_name();}
 256 };
 257
 258 #endif
 259
 260 #ifndef BOOST_NO_STD_WSTRING
 261 template <>
 262 struct ratio_string<pico, wchar_t>
 263 {
 264     static std::wstring short_name() {return std::wstring(1, L'p');}
 265     static std::wstring long_name()  {return std::wstring(L"pico");}
 266     static std::wstring symbol() {return short_name();}
 267     static std::wstring prefix() {return long_name();}
 268 };
 269 #endif
 270 #endif
 271
 272 // nano
 273
 274 //template <>
 275 //struct ratio_string_is_localizable<nano> : true_type {};
 276 //
 277 //template <>
 278 //struct ratio_string_id<nano> : integral_constant<int,-9> {};
 279
 280 #ifdef BOOST_RATIO_HAS_STATIC_STRING
 281 template <typename CharT>
 282 struct ratio_string<nano, CharT> :
 283     ratio_detail::ratio_string_static<nano,CharT>
 284 {};
 285
 286 #else
 287 template <>
 288 struct ratio_string<nano, char>
 289 {
 290     static std::string short_name() {return std::string(1, 'n');}
 291     static std::string long_name()  {return std::string("nano");}
 292     static std::string symbol() {return short_name();}
 293     static std::string prefix() {return long_name();}
 294 };
 295
 296 #if BOOST_RATIO_HAS_UNICODE_SUPPORT
 297
 298 template <>
 299 struct ratio_string<nano, char16_t>
 300 {
 301     static std::u16string short_name() {return std::u16string(1, u'n');}
 302     static std::u16string long_name()  {return std::u16string(u"nano");}
 303     static std::u16string symbol() {return short_name();}
 304     static std::u16string prefix() {return long_name();}
 305 };
 306
 307 template <>
 308 struct ratio_string<nano, char32_t>
 309 {
 310     static std::u32string short_name() {return std::u32string(1, U'n');}
 311     static std::u32string long_name()  {return std::u32string(U"nano");}
 312     static std::u32string symbol() {return short_name();}
 313     static std::u32string prefix() {return long_name();}
 314 };
 315
 316 #endif
 317
 318 #ifndef BOOST_NO_STD_WSTRING
 319 template <>
 320 struct ratio_string<nano, wchar_t>
 321 {
 322     static std::wstring short_name() {return std::wstring(1, L'n');}
 323     static std::wstring long_name()  {return std::wstring(L"nano");}
 324     static std::wstring symbol() {return short_name();}
 325     static std::wstring prefix() {return long_name();}
 326 };
 327 #endif
 328 #endif
 329
 330 // micro
 331
 332 //template <>
 333 //struct ratio_string_is_localizable<micro> : true_type {};
 334 //
 335 //template <>
 336 //struct ratio_string_id<micro> : integral_constant<int,-6> {};
 337
 338 #ifdef BOOST_RATIO_HAS_STATIC_STRING
 339 template <typename CharT>
 340 struct ratio_string<micro, CharT> :
 341     ratio_detail::ratio_string_static<micro,CharT>
 342 {};
 343
 344 #else
 345 template <>
 346 struct ratio_string<micro, char>
 347 {
 348     static std::string short_name() {return std::string("\xC2\xB5");}
 349     static std::string long_name()  {return std::string("micro");}
 350     static std::string symbol() {return short_name();}
 351     static std::string prefix() {return long_name();}
 352 };
 353
 354 #if BOOST_RATIO_HAS_UNICODE_SUPPORT
 355
 356 template <>
 357 struct ratio_string<micro, char16_t>
 358 {
 359     static std::u16string short_name() {return std::u16string(1, u'\xB5');}
 360     static std::u16string long_name()  {return std::u16string(u"micro");}
 361     static std::u16string symbol() {return short_name();}
 362     static std::u16string prefix() {return long_name();}
 363 };
 364
 365 template <>
 366 struct ratio_string<micro, char32_t>
 367 {
 368     static std::u32string short_name() {return std::u32string(1, U'\xB5');}
 369     static std::u32string long_name()  {return std::u32string(U"micro");}
 370     static std::u32string symbol() {return short_name();}
 371     static std::u32string prefix() {return long_name();}
 372 };
 373
 374 #endif
 375
 376 #ifndef BOOST_NO_STD_WSTRING
 377 template <>
 378 struct ratio_string<micro, wchar_t>
 379 {
 380     static std::wstring short_name() {return std::wstring(1, L'\xB5');}
 381     static std::wstring long_name()  {return std::wstring(L"micro");}
 382     static std::wstring symbol() {return short_name();}
 383     static std::wstring prefix() {return long_name();}
 384 };
 385 #endif
 386 #endif
 387
 388 // milli
 389
 390 //template <>
 391 //struct ratio_string_is_localizable<milli> : true_type {};
 392 //
 393 //template <>
 394 //struct ratio_string_id<milli> : integral_constant<int,-3> {};
 395
 396 #ifdef BOOST_RATIO_HAS_STATIC_STRING
 397 template <typename CharT>
 398 struct ratio_string<milli, CharT> :
 399     ratio_detail::ratio_string_static<milli,CharT>
 400 {};
 401
 402 #else
 403 template <>
 404 struct ratio_string<milli, char>
 405 {
 406     static std::string short_name() {return std::string(1, 'm');}
 407     static std::string long_name()  {return std::string("milli");}
 408     static std::string symbol() {return short_name();}
 409     static std::string prefix() {return long_name();}
 410 };
 411
 412 #if BOOST_RATIO_HAS_UNICODE_SUPPORT
 413
 414 template <>
 415 struct ratio_string<milli, char16_t>
 416 {
 417     static std::u16string short_name() {return std::u16string(1, u'm');}
 418     static std::u16string long_name()  {return std::u16string(u"milli");}
 419     static std::u16string symbol() {return short_name();}
 420     static std::u16string prefix() {return long_name();}
 421 };
 422
 423 template <>
 424 struct ratio_string<milli, char32_t>
 425 {
 426     static std::u32string short_name() {return std::u32string(1, U'm');}
 427     static std::u32string long_name()  {return std::u32string(U"milli");}
 428     static std::u32string symbol() {return short_name();}
 429     static std::u32string prefix() {return long_name();}
 430 };
 431
 432 #endif
 433
 434 #ifndef BOOST_NO_STD_WSTRING
 435 template <>
 436 struct ratio_string<milli, wchar_t>
 437 {
 438     static std::wstring short_name() {return std::wstring(1, L'm');}
 439     static std::wstring long_name()  {return std::wstring(L"milli");}
 440     static std::wstring symbol() {return short_name();}
 441     static std::wstring prefix() {return long_name();}
 442 };
 443 #endif
 444 #endif
 445
 446 // centi
 447
 448 //template <>
 449 //struct ratio_string_is_localizable<centi> : true_type {};
 450 //
 451 //template <>
 452 //struct ratio_string_id<centi> : integral_constant<int,-2> {};
 453
 454 #ifdef BOOST_RATIO_HAS_STATIC_STRING
 455 template <typename CharT>
 456 struct ratio_string<centi, CharT> :
 457     ratio_detail::ratio_string_static<centi,CharT>
 458 {};
 459
 460 #else
 461 template <>
 462 struct ratio_string<centi, char>
 463 {
 464     static std::string short_name() {return std::string(1, 'c');}
 465     static std::string long_name()  {return std::string("centi");}
 466     static std::string symbol() {return short_name();}
 467     static std::string prefix() {return long_name();}
 468 };
 469
 470 #if BOOST_RATIO_HAS_UNICODE_SUPPORT
 471
 472 template <>
 473 struct ratio_string<centi, char16_t>
 474 {
 475     static std::u16string short_name() {return std::u16string(1, u'c');}
 476     static std::u16string long_name()  {return std::u16string(u"centi");}
 477     static std::u16string symbol() {return short_name();}
 478     static std::u16string prefix() {return long_name();}
 479 };
 480
 481 template <>
 482 struct ratio_string<centi, char32_t>
 483 {
 484     static std::u32string short_name() {return std::u32string(1, U'c');}
 485     static std::u32string long_name()  {return std::u32string(U"centi");}
 486     static std::u32string symbol() {return short_name();}
 487     static std::u32string prefix() {return long_name();}
 488 };
 489
 490 #endif
 491
 492 #ifndef BOOST_NO_STD_WSTRING
 493 template <>
 494 struct ratio_string<centi, wchar_t>
 495 {
 496     static std::wstring short_name() {return std::wstring(1, L'c');}
 497     static std::wstring long_name()  {return std::wstring(L"centi");}
 498     static std::wstring symbol() {return short_name();}
 499     static std::wstring prefix() {return long_name();}
 500 };
 501 #endif
 502 #endif
 503
 504 // deci
 505
 506 //template <>
 507 //struct ratio_string_is_localizable<deci> : true_type {};
 508 //
 509 //template <>
 510 //struct ratio_string_id<deci> : integral_constant<int,-1> {};
 511
 512 #ifdef BOOST_RATIO_HAS_STATIC_STRING
 513 template <typename CharT>
 514 struct ratio_string<deci, CharT> :
 515     ratio_detail::ratio_string_static<deci,CharT>
 516 {};
 517
 518 #else
 519
 520 template <>
 521 struct ratio_string<deci, char>
 522 {
 523     static std::string short_name() {return std::string(1, 'd');}
 524     static std::string long_name()  {return std::string("deci");}
 525     static std::string symbol() {return short_name();}
 526     static std::string prefix() {return long_name();}
 527 };
 528
 529 #if BOOST_RATIO_HAS_UNICODE_SUPPORT
 530
 531 template <>
 532 struct ratio_string<deci, char16_t>
 533 {
 534     static std::u16string short_name() {return std::u16string(1, u'd');}
 535     static std::u16string long_name()  {return std::u16string(u"deci");}
 536     static std::u16string symbol() {return short_name();}
 537     static std::u16string prefix() {return long_name();}
 538 };
 539
 540 template <>
 541 struct ratio_string<deci, char32_t>
 542 {
 543     static std::u32string short_name() {return std::u32string(1, U'd');}
 544     static std::u32string long_name()  {return std::u32string(U"deci");}
 545     static std::u32string symbol() {return short_name();}
 546     static std::u32string prefix() {return long_name();}
 547 };
 548
 549 #endif
 550
 551 #ifndef BOOST_NO_STD_WSTRING
 552 template <>
 553 struct ratio_string<deci, wchar_t>
 554 {
 555     static std::wstring short_name() {return std::wstring(1, L'd');}
 556     static std::wstring long_name()  {return std::wstring(L"deci");}
 557     static std::wstring symbol() {return short_name();}
 558     static std::wstring prefix() {return long_name();}
 559 };
 560 #endif
 561 #endif
 562
 563 // unit
 564
 565 //template <>
 566 //struct ratio_string_is_localizable<ratio<1> > : true_type {};
 567 //
 568 //template <>
 569 //struct ratio_string_id<ratio<1> > : integral_constant<int,0> {};
 570 // deca
 571
 572 //template <>
 573 //struct ratio_string_is_localizable<deca> : true_type {};
 574 //
 575 //template <>
 576 //struct ratio_string_id<deca> : integral_constant<int,1> {};
 577
 578 #ifdef BOOST_RATIO_HAS_STATIC_STRING
 579 template <typename CharT>
 580 struct ratio_string<deca, CharT> :
 581     ratio_detail::ratio_string_static<deca,CharT>
 582 {};
 583
 584 #else
 585 template <>
 586 struct ratio_string<deca, char>
 587 {
 588     static std::string short_name() {return std::string("da");}
 589     static std::string long_name()  {return std::string("deca");}
 590     static std::string symbol() {return short_name();}
 591     static std::string prefix() {return long_name();}
 592 };
 593
 594 #if BOOST_RATIO_HAS_UNICODE_SUPPORT
 595
 596 template <>
 597 struct ratio_string<deca, char16_t>
 598 {
 599     static std::u16string short_name() {return std::u16string(u"da");}
 600     static std::u16string long_name()  {return std::u16string(u"deca");}
 601     static std::u16string symbol() {return short_name();}
 602     static std::u16string prefix() {return long_name();}
 603 };
 604
 605 template <>
 606 struct ratio_string<deca, char32_t>
 607 {
 608     static std::u32string short_name() {return std::u32string(U"da");}
 609     static std::u32string long_name()  {return std::u32string(U"deca");}
 610     static std::u32string symbol() {return short_name();}
 611     static std::u32string prefix() {return long_name();}
 612 };
 613
 614 #endif
 615
 616 #ifndef BOOST_NO_STD_WSTRING
 617 template <>
 618 struct ratio_string<deca, wchar_t>
 619 {
 620     static std::wstring short_name() {return std::wstring(L"da");}
 621     static std::wstring long_name()  {return std::wstring(L"deca");}
 622     static std::wstring symbol() {return short_name();}
 623     static std::wstring prefix() {return long_name();}
 624 };
 625 #endif
 626 #endif
 627
 628 // hecto
 629
 630 //template <>
 631 //struct ratio_string_is_localizable<hecto> : true_type {};
 632 //
 633 //template <>
 634 //struct ratio_string_id<hecto> : integral_constant<int,2> {};
 635
 636
 637 #ifdef BOOST_RATIO_HAS_STATIC_STRING
 638 template <typename CharT>
 639 struct ratio_string<hecto, CharT> :
 640     ratio_detail::ratio_string_static<hecto,CharT>
 641 {};
 642
 643 #else
 644 template <>
 645 struct ratio_string<hecto, char>
 646 {
 647     static std::string short_name() {return std::string(1, 'h');}
 648     static std::string long_name()  {return std::string("hecto");}
 649     static std::string symbol() {return short_name();}
 650     static std::string prefix() {return long_name();}
 651 };
 652
 653 #if BOOST_RATIO_HAS_UNICODE_SUPPORT
 654
 655 template <>
 656 struct ratio_string<hecto, char16_t>
 657 {
 658     static std::u16string short_name() {return std::u16string(1, u'h');}
 659     static std::u16string long_name()  {return std::u16string(u"hecto");}
 660     static std::u16string symbol() {return short_name();}
 661     static std::u16string prefix() {return long_name();}
 662 };
 663
 664 template <>
 665 struct ratio_string<hecto, char32_t>
 666 {
 667     static std::u32string short_name() {return std::u32string(1, U'h');}
 668     static std::u32string long_name()  {return std::u32string(U"hecto");}
 669     static std::u32string symbol() {return short_name();}
 670     static std::u32string prefix() {return long_name();}
 671 };
 672
 673 #endif
 674
 675 #ifndef BOOST_NO_STD_WSTRING
 676 template <>
 677 struct ratio_string<hecto, wchar_t>
 678 {
 679     static std::wstring short_name() {return std::wstring(1, L'h');}
 680     static std::wstring long_name()  {return std::wstring(L"hecto");}
 681     static std::wstring symbol() {return short_name();}
 682     static std::wstring prefix() {return long_name();}
 683 };
 684 #endif
 685 #endif
 686
 687 // kilo
 688
 689 //template <>
 690 //struct ratio_string_is_localizable<kilo> : true_type {};
 691 //
 692 //template <>
 693 //struct ratio_string_id<kilo> : integral_constant<int,3> {};
 694
 695 #ifdef BOOST_RATIO_HAS_STATIC_STRING
 696 template <typename CharT>
 697 struct ratio_string<kilo, CharT> :
 698     ratio_detail::ratio_string_static<kilo,CharT>
 699 {};
 700
 701 #else
 702 template <>
 703 struct ratio_string<kilo, char>
 704 {
 705     static std::string short_name() {return std::string(1, 'k');}
 706     static std::string long_name()  {return std::string("kilo");}
 707     static std::string symbol() {return short_name();}
 708     static std::string prefix() {return long_name();}
 709 };
 710
 711 #if BOOST_RATIO_HAS_UNICODE_SUPPORT
 712
 713 template <>
 714 struct ratio_string<kilo, char16_t>
 715 {
 716     static std::u16string short_name() {return std::u16string(1, u'k');}
 717     static std::u16string long_name()  {return std::u16string(u"kilo");}
 718     static std::u16string symbol() {return short_name();}
 719     static std::u16string prefix() {return long_name();}
 720 };
 721
 722 template <>
 723 struct ratio_string<kilo, char32_t>
 724 {
 725     static std::u32string short_name() {return std::u32string(1, U'k');}
 726     static std::u32string long_name()  {return std::u32string(U"kilo");}
 727     static std::u32string symbol() {return short_name();}
 728     static std::u32string prefix() {return long_name();}
 729 };
 730
 731 #endif
 732
 733 #ifndef BOOST_NO_STD_WSTRING
 734 template <>
 735 struct ratio_string<kilo, wchar_t>
 736 {
 737     static std::wstring short_name() {return std::wstring(1, L'k');}
 738     static std::wstring long_name()  {return std::wstring(L"kilo");}
 739     static std::wstring symbol() {return short_name();}
 740     static std::wstring prefix() {return long_name();}
 741 };
 742 #endif
 743 #endif
 744
 745 // mega
 746
 747 //template <>
 748 //struct ratio_string_is_localizable<mega> : true_type {};
 749 //
 750 //template <>
 751 //struct ratio_string_id<mega> : integral_constant<int,6> {};
 752
 753 #ifdef BOOST_RATIO_HAS_STATIC_STRING
 754 template <typename CharT>
 755 struct ratio_string<mega, CharT> :
 756     ratio_detail::ratio_string_static<mega,CharT>
 757 {};
 758
 759 #else
 760
 761 template <>
 762 struct ratio_string<mega, char>
 763 {
 764     static std::string short_name() {return std::string(1, 'M');}
 765     static std::string long_name()  {return std::string("mega");}
 766     static std::string symbol() {return short_name();}
 767     static std::string prefix() {return long_name();}
 768 };
 769
 770 #if BOOST_RATIO_HAS_UNICODE_SUPPORT
 771
 772 template <>
 773 struct ratio_string<mega, char16_t>
 774 {
 775     static std::u16string short_name() {return std::u16string(1, u'M');}
 776     static std::u16string long_name()  {return std::u16string(u"mega");}
 777     static std::u16string symbol() {return short_name();}
 778     static std::u16string prefix() {return long_name();}
 779 };
 780
 781 template <>
 782 struct ratio_string<mega, char32_t>
 783 {
 784     static std::u32string short_name() {return std::u32string(1, U'M');}
 785     static std::u32string long_name()  {return std::u32string(U"mega");}
 786     static std::u32string symbol() {return short_name();}
 787     static std::u32string prefix() {return long_name();}
 788 };
 789
 790 #endif
 791
 792 #ifndef BOOST_NO_STD_WSTRING
 793 template <>
 794 struct ratio_string<mega, wchar_t>
 795 {
 796     static std::wstring short_name() {return std::wstring(1, L'M');}
 797     static std::wstring long_name()  {return std::wstring(L"mega");}
 798     static std::wstring symbol() {return short_name();}
 799     static std::wstring prefix() {return long_name();}
 800 };
 801 #endif
 802 #endif
 803
 804 // giga
 805
 806 //template <>
 807 //struct ratio_string_is_localizable<giga> : true_type {};
 808 //
 809 //template <>
 810 //struct ratio_string_id<giga> : integral_constant<int,9> {};
 811
 812 #ifdef BOOST_RATIO_HAS_STATIC_STRING
 813 template <typename CharT>
 814 struct ratio_string<giga, CharT> :
 815     ratio_detail::ratio_string_static<giga,CharT>
 816 {};
 817
 818 #else
 819
 820 template <>
 821 struct ratio_string<giga, char>
 822 {
 823     static std::string short_name() {return std::string(1, 'G');}
 824     static std::string long_name()  {return std::string("giga");}
 825     static std::string symbol() {return short_name();}
 826     static std::string prefix() {return long_name();}
 827 };
 828
 829 #if BOOST_RATIO_HAS_UNICODE_SUPPORT
 830
 831 template <>
 832 struct ratio_string<giga, char16_t>
 833 {
 834     static std::u16string short_name() {return std::u16string(1, u'G');}
 835     static std::u16string long_name()  {return std::u16string(u"giga");}
 836     static std::u16string symbol() {return short_name();}
 837     static std::u16string prefix() {return long_name();}
 838 };
 839
 840 template <>
 841 struct ratio_string<giga, char32_t>
 842 {
 843     static std::u32string short_name() {return std::u32string(1, U'G');}
 844     static std::u32string long_name()  {return std::u32string(U"giga");}
 845     static std::u32string symbol() {return short_name();}
 846     static std::u32string prefix() {return long_name();}
 847 };
 848
 849 #endif
 850
 851 #ifndef BOOST_NO_STD_WSTRING
 852 template <>
 853 struct ratio_string<giga, wchar_t>
 854 {
 855     static std::wstring short_name() {return std::wstring(1, L'G');}
 856     static std::wstring long_name()  {return std::wstring(L"giga");}
 857     static std::wstring symbol() {return short_name();}
 858     static std::wstring prefix() {return long_name();}
 859 };
 860 #endif
 861 #endif
 862
 863 // tera
 864
 865 //template <>
 866 //struct ratio_string_is_localizable<tera> : true_type {};
 867 //
 868 //template <>
 869 //struct ratio_string_id<tera> : integral_constant<int,12> {};
 870
 871 #ifdef BOOST_RATIO_HAS_STATIC_STRING
 872 template <typename CharT>
 873 struct ratio_string<tera, CharT> :
 874     ratio_detail::ratio_string_static<tera,CharT>
 875 {};
 876
 877 #else
 878 template <>
 879 struct ratio_string<tera, char>
 880 {
 881     static std::string short_name() {return std::string(1, 'T');}
 882     static std::string long_name()  {return std::string("tera");}
 883     static std::string symbol() {return short_name();}
 884     static std::string prefix() {return long_name();}
 885 };
 886
 887 #if BOOST_RATIO_HAS_UNICODE_SUPPORT
 888
 889 template <>
 890 struct ratio_string<tera, char16_t>
 891 {
 892     static std::u16string short_name() {return std::u16string(1, u'T');}
 893     static std::u16string long_name()  {return std::u16string(u"tera");}
 894     static std::u16string symbol() {return short_name();}
 895     static std::u16string prefix() {return long_name();}
 896 };
 897
 898 template <>
 899 struct ratio_string<tera, char32_t>
 900 {
 901     static std::u32string short_name() {return std::u32string(1, U'T');}
 902     static std::u32string long_name()  {return std::u32string(U"tera");}
 903     static std::u32string symbol() {return short_name();}
 904     static std::u32string prefix() {return long_name();}
 905 };
 906
 907 #endif
 908
 909 #ifndef BOOST_NO_STD_WSTRING
 910 template <>
 911 struct ratio_string<tera, wchar_t>
 912 {
 913     static std::wstring short_name() {return std::wstring(1, L'T');}
 914     static std::wstring long_name()  {return std::wstring(L"tera");}
 915     static std::wstring symbol() {return short_name();}
 916     static std::wstring prefix() {return long_name();}
 917 };
 918 #endif
 919 #endif
 920
 921 // peta
 922
 923 //template <>
 924 //struct ratio_string_is_localizable<peta> : true_type {};
 925 //
 926 //template <>
 927 //struct ratio_string_id<peta> : integral_constant<int,15> {};
 928
 929
 930 #ifdef BOOST_RATIO_HAS_STATIC_STRING
 931 template <typename CharT>
 932 struct ratio_string<peta, CharT> :
 933     ratio_detail::ratio_string_static<peta,CharT>
 934 {};
 935
 936 #else
 937 template <>
 938 struct ratio_string<peta, char>
 939 {
 940     static std::string short_name() {return std::string(1, 'P');}
 941     static std::string long_name()  {return std::string("peta");}
 942     static std::string symbol() {return short_name();}
 943     static std::string prefix() {return long_name();}
 944 };
 945
 946 #if BOOST_RATIO_HAS_UNICODE_SUPPORT
 947
 948 template <>
 949 struct ratio_string<peta, char16_t>
 950 {
 951     static std::u16string short_name() {return std::u16string(1, u'P');}
 952     static std::u16string long_name()  {return std::u16string(u"peta");}
 953     static std::u16string symbol() {return short_name();}
 954     static std::u16string prefix() {return long_name();}
 955 };
 956
 957 template <>
 958 struct ratio_string<peta, char32_t>
 959 {
 960     static std::u32string short_name() {return std::u32string(1, U'P');}
 961     static std::u32string long_name()  {return std::u32string(U"peta");}
 962     static std::u32string symbol() {return short_name();}
 963     static std::u32string prefix() {return long_name();}
 964 };
 965
 966 #endif
 967
 968 #ifndef BOOST_NO_STD_WSTRING
 969 template <>
 970 struct ratio_string<peta, wchar_t>
 971 {
 972     static std::wstring short_name() {return std::wstring(1, L'P');}
 973     static std::wstring long_name()  {return std::wstring(L"peta");}
 974     static std::wstring symbol() {return short_name();}
 975     static std::wstring prefix() {return long_name();}
 976 };
 977 #endif
 978 #endif
 979
 980 // exa
 981
 982 //template <>
 983 //struct ratio_string_is_localizable<exa> : true_type {};
 984 //
 985 //template <>
 986 //struct ratio_string_id<exa> : integral_constant<int,18> {};
 987
 988 #ifdef BOOST_RATIO_HAS_STATIC_STRING
 989 template <typename CharT>
 990 struct ratio_string<exa, CharT> :
 991     ratio_detail::ratio_string_static<exa,CharT>
 992 {};
 993
 994 #else
 995 template <>
 996 struct ratio_string<exa, char>
 997 {
 998     static std::string short_name() {return std::string(1, 'E');}
 999     static std::string long_name()  {return std::string("exa");}
1000     static std::string symbol() {return short_name();}
1001     static std::string prefix() {return long_name();}
1002 };
1003
1004 #if BOOST_RATIO_HAS_UNICODE_SUPPORT
1005
1006 template <>
1007 struct ratio_string<exa, char16_t>
1008 {
1009     static std::u16string short_name() {return std::u16string(1, u'E');}
1010     static std::u16string long_name()  {return std::u16string(u"exa");}
1011     static std::u16string symbol() {return short_name();}
1012     static std::u16string prefix() {return long_name();}
1013 };
1014
1015 template <>
1016 struct ratio_string<exa, char32_t>
1017 {
1018     static std::u32string short_name() {return std::u32string(1, U'E');}
1019     static std::u32string long_name()  {return std::u32string(U"exa");}
1020     static std::u32string symbol() {return short_name();}
1021     static std::u32string prefix() {return long_name();}
1022 };
1023
1024 #endif
1025
1026 #ifndef BOOST_NO_STD_WSTRING
1027 template <>
1028 struct ratio_string<exa, wchar_t>
1029 {
1030     static std::wstring short_name() {return std::wstring(1, L'E');}
1031     static std::wstring long_name()  {return std::wstring(L"exa");}
1032     static std::wstring symbol() {return short_name();}
1033     static std::wstring prefix() {return long_name();}
1034 };
1035 #endif
1036 #endif
1037
1038 #ifdef BOOST_RATIO_EXTENSIONS
1039
1040 #ifdef BOOST_RATIO_HAS_STATIC_STRING
1041 template <typename CharT>
1042 struct ratio_string<kibi, CharT> :
1043     ratio_detail::ratio_string_static<kibi,CharT>
1044 {};
1045
1046 #else
1047 template <>
1048 struct ratio_string<kibi, char>
1049 {
1050     static std::string short_name() {return std::string("Ki");}
1051     static std::string long_name()  {return std::string("kibi");}
1052     static std::string symbol() {return short_name();}
1053     static std::string prefix() {return long_name();}
1054 };
1055
1056 #if BOOST_RATIO_HAS_UNICODE_SUPPORT
1057
1058 template <>
1059 struct ratio_string<kibi, char16_t>
1060 {
1061     static std::u16string short_name() {return std::u16string(u"Ki");}
1062     static std::u16string long_name()  {return std::u16string(u"kibi");}
1063     static std::u16string symbol() {return short_name();}
1064     static std::u16string prefix() {return long_name();}
1065 };
1066
1067 template <>
1068 struct ratio_string<kibi, char32_t>
1069 {
1070     static std::u32string short_name() {return std::u32string(U"Ki");}
1071     static std::u32string long_name()  {return std::u32string(U"kibi");}
1072     static std::u32string symbol() {return short_name();}
1073     static std::u32string prefix() {return long_name();}
1074 };
1075
1076 #endif
1077
1078 #ifndef BOOST_NO_STD_WSTRING
1079 template <>
1080 struct ratio_string<kibi, wchar_t>
1081 {
1082     static std::wstring short_name() {return std::wstring(L"Ki");}
1083     static std::wstring long_name()  {return std::wstring(L"kibi");}
1084     static std::wstring symbol() {return short_name();}
1085     static std::wstring prefix() {return long_name();}
1086 };
1087 #endif
1088 #endif
1089
1090 #ifdef BOOST_RATIO_HAS_STATIC_STRING
1091 template <typename CharT>
1092 struct ratio_string<mebi, CharT> :
1093     ratio_detail::ratio_string_static<mebi,CharT>
1094 {};
1095
1096 #else
1097 template <>
1098 struct ratio_string<mebi, char>
1099 {
1100     static std::string short_name() {return std::string("Mi");}
1101     static std::string long_name()  {return std::string("mebi");}
1102     static std::string symbol() {return short_name();}
1103     static std::string prefix() {return long_name();}
1104 };
1105
1106 #if BOOST_RATIO_HAS_UNICODE_SUPPORT
1107
1108 template <>
1109 struct ratio_string<mebi, char16_t>
1110 {
1111     static std::u16string short_name() {return std::u16string(u"Mi");}
1112     static std::u16string long_name()  {return std::u16string(u"mebi");}
1113     static std::u16string symbol() {return short_name();}
1114     static std::u16string prefix() {return long_name();}
1115 };
1116
1117 template <>
1118 struct ratio_string<mebi, char32_t>
1119 {
1120     static std::u32string short_name() {return std::u32string(U"Mi");}
1121     static std::u32string long_name()  {return std::u32string(U"mebi");}
1122     static std::u32string symbol() {return short_name();}
1123     static std::u32string prefix() {return long_name();}
1124 };
1125
1126 #endif
1127
1128 #ifndef BOOST_NO_STD_WSTRING
1129 template <>
1130 struct ratio_string<mebi, wchar_t>
1131 {
1132     static std::wstring short_name() {return std::wstring(L"Mi");}
1133     static std::wstring long_name()  {return std::wstring(L"mebi");}
1134     static std::wstring symbol() {return short_name();}
1135     static std::wstring prefix() {return long_name();}
1136 };
1137 #endif
1138 #endif
1139
1140 #ifdef BOOST_RATIO_HAS_STATIC_STRING
1141 template <typename CharT>
1142 struct ratio_string<gibi, CharT> :
1143     ratio_detail::ratio_string_static<gibi,CharT>
1144 {};
1145
1146 #else
1147 template <>
1148 struct ratio_string<gibi, char>
1149 {
1150     static std::string short_name() {return std::string("Gi");}
1151     static std::string long_name()  {return std::string("gibi");}
1152     static std::string symbol() {return short_name();}
1153     static std::string prefix() {return long_name();}
1154 };
1155
1156 #if BOOST_RATIO_HAS_UNICODE_SUPPORT
1157
1158 template <>
1159 struct ratio_string<gibi, char16_t>
1160 {
1161     static std::u16string short_name() {return std::u16string(u"Gi");}
1162     static std::u16string long_name()  {return std::u16string(u"gibi");}
1163     static std::u16string symbol() {return short_name();}
1164     static std::u16string prefix() {return long_name();}
1165 };
1166
1167 template <>
1168 struct ratio_string<gibi, char32_t>
1169 {
1170     static std::u32string short_name() {return std::u32string(U"Gi");}
1171     static std::u32string long_name()  {return std::u32string(U"gibi");}
1172     static std::u32string symbol() {return short_name();}
1173     static std::u32string prefix() {return long_name();}
1174 };
1175
1176 #endif
1177
1178 #ifndef BOOST_NO_STD_WSTRING
1179 template <>
1180 struct ratio_string<gibi, wchar_t>
1181 {
1182     static std::wstring short_name() {return std::wstring(L"Gi");}
1183     static std::wstring long_name()  {return std::wstring(L"gibi");}
1184     static std::wstring symbol() {return short_name();}
1185     static std::wstring prefix() {return long_name();}
1186 };
1187 #endif
1188 #endif
1189
1190 #ifdef BOOST_RATIO_HAS_STATIC_STRING
1191 template <typename CharT>
1192 struct ratio_string<tebi, CharT> :
1193     ratio_detail::ratio_string_static<tebi,CharT>
1194 {};
1195
1196 #else
1197 template <>
1198 struct ratio_string<tebi, char>
1199 {
1200     static std::string short_name() {return std::string("Ti");}
1201     static std::string long_name()  {return std::string("tebi");}
1202     static std::string symbol() {return short_name();}
1203     static std::string prefix() {return long_name();}
1204 };
1205
1206 #if BOOST_RATIO_HAS_UNICODE_SUPPORT
1207
1208 template <>
1209 struct ratio_string<tebi, char16_t>
1210 {
1211     static std::u16string short_name() {return std::u16string(u"Ti");}
1212     static std::u16string long_name()  {return std::u16string(u"tebi");}
1213     static std::u16string symbol() {return short_name();}
1214     static std::u16string prefix() {return long_name();}
1215 };
1216
1217 template <>
1218 struct ratio_string<tebi, char32_t>
1219 {
1220     static std::u32string short_name() {return std::u32string(U"Ti");}
1221     static std::u32string long_name()  {return std::u32string(U"tebi");}
1222     static std::u32string symbol() {return short_name();}
1223     static std::u32string prefix() {return long_name();}
1224 };
1225
1226 #endif
1227
1228 #ifndef BOOST_NO_STD_WSTRING
1229 template <>
1230 struct ratio_string<tebi, wchar_t>
1231 {
1232     static std::wstring short_name() {return std::wstring(L"Ti");}
1233     static std::wstring long_name()  {return std::wstring(L"tebi");}
1234     static std::wstring symbol() {return short_name();}
1235     static std::wstring prefix() {return long_name();}
1236 };
1237 #endif
1238 #endif
1239
1240 #ifdef BOOST_RATIO_HAS_STATIC_STRING
1241 template <typename CharT>
1242 struct ratio_string<pebi, CharT> :
1243     ratio_detail::ratio_string_static<pebi,CharT>
1244 {};
1245
1246 #else
1247 template <>
1248 struct ratio_string<pebi, char>
1249 {
1250     static std::string short_name() {return std::string("Pi");}
1251     static std::string long_name()  {return std::string("pebi");}
1252     static std::string symbol() {return short_name();}
1253     static std::string prefix() {return long_name();}
1254 };
1255
1256 #if BOOST_RATIO_HAS_UNICODE_SUPPORT
1257
1258 template <>
1259 struct ratio_string<pebi, char16_t>
1260 {
1261     static std::u16string short_name() {return std::u16string(u"Pi");}
1262     static std::u16string long_name()  {return std::u16string(u"pebi");}
1263     static std::u16string symbol() {return short_name();}
1264     static std::u16string prefix() {return long_name();}
1265 };
1266
1267 template <>
1268 struct ratio_string<pebi, char32_t>
1269 {
1270     static std::u32string short_name() {return std::u32string(U"Pi");}
1271     static std::u32string long_name()  {return std::u32string(U"pebi");}
1272     static std::u32string symbol() {return short_name();}
1273     static std::u32string prefix() {return long_name();}
1274 };
1275
1276 #endif
1277
1278 #ifndef BOOST_NO_STD_WSTRING
1279 template <>
1280 struct ratio_string<pebi, wchar_t>
1281 {
1282     static std::wstring short_name() {return std::wstring(L"Pi");}
1283     static std::wstring long_name()  {return std::wstring(L"pebi");}
1284     static std::wstring symbol() {return short_name();}
1285     static std::wstring prefix() {return long_name();}
1286 };
1287 #endif
1288 #endif
1289
1290 #ifdef BOOST_RATIO_HAS_STATIC_STRING
1291 template <typename CharT>
1292 struct ratio_string<exbi, CharT> :
1293     ratio_detail::ratio_string_static<exbi,CharT>
1294 {};
1295
1296 #else
1297 template <>
1298 struct ratio_string<exbi, char>
1299 {
1300     static std::string short_name() {return std::string("Ei");}
1301     static std::string long_name()  {return std::string("exbi");}
1302     static std::string symbol() {return short_name();}
1303     static std::string prefix() {return long_name();}
1304 };
1305
1306 #if BOOST_RATIO_HAS_UNICODE_SUPPORT
1307
1308 template <>
1309 struct ratio_string<exbi, char16_t>
1310 {
1311     static std::u16string short_name() {return std::u16string(u"Ei");}
1312     static std::u16string long_name()  {return std::u16string(u"exbi");}
1313     static std::u16string symbol() {return short_name();}
1314     static std::u16string prefix() {return long_name();}
1315 };
1316
1317 template <>
1318 struct ratio_string<exbi, char32_t>
1319 {
1320     static std::u32string short_name() {return std::u32string(U"Ei");}
1321     static std::u32string long_name()  {return std::u32string(U"exbi");}
1322     static std::u32string symbol() {return short_name();}
1323     static std::u32string prefix() {return long_name();}
1324 };
1325
1326 #endif
1327
1328 #ifndef BOOST_NO_STD_WSTRING
1329 template <>
1330 struct ratio_string<exbi, wchar_t>
1331 {
1332     static std::wstring short_name() {return std::wstring(L"Ei");}
1333     static std::wstring long_name()  {return std::wstring(L"exbi");}
1334     static std::wstring symbol() {return short_name();}
1335     static std::wstring prefix() {return long_name();}
1336 };
1337 #endif
1338 #endif
1339 #endif
1340 }
1341
1342 #endif  // BOOST_RATIO_RATIO_IO_HPP