ceph/src/boost/boost/ratio/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_RATIO_IO_HPP
  13 #define BOOST_RATIO_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> prefix();
  29     static basic_string<CharT> symbol();
  30 };
  31
  32 }  // boost
  33
  34 */
  35 #include <boost/ratio/config.hpp>
  36
  37 #ifdef BOOST_RATIO_PROVIDES_DEPRECATED_FEATURES_SINCE_V2_0_0
  38 #include <boost/ratio/detail/ratio_io.hpp>
  39 #else
  40
  41 #include <boost/config.hpp>
  42 #include <boost/ratio/ratio.hpp>
  43 #include <boost/type_traits/integral_constant.hpp>
  44 #include <string>
  45 #include <sstream>
  46
  47
  48 #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)
  49 #if defined BOOST_RATIO_HAS_UNICODE_SUPPORT
  50 #undef BOOST_RATIO_HAS_UNICODE_SUPPORT
  51 #endif
  52 #else
  53 #define BOOST_RATIO_HAS_UNICODE_SUPPORT 1
  54 #endif
  55
  56 namespace boost {
  57
  58 //template <class Ratio>
  59 //struct ratio_string_is_localizable : false_type {};
  60 //template <class Ratio>
  61 //struct ratio_string_id : integral_constant<int,0> {};
  62
  63 template <class Ratio, class CharT>
  64 struct ratio_string
  65 {
  66     static std::basic_string<CharT> symbol() {return prefix();}
  67     static std::basic_string<CharT> prefix();
  68 };
  69
  70 template <class Ratio, class CharT>
  71 std::basic_string<CharT>
  72 ratio_string<Ratio, CharT>::prefix()
  73 {
  74     std::basic_ostringstream<CharT> os;
  75     os << CharT('[') << Ratio::num << CharT('/')
  76                         << Ratio::den << CharT(']');
  77     return os.str();
  78 }
  79
  80 #ifdef BOOST_RATIO_HAS_STATIC_STRING
  81 namespace ratio_detail {
  82 template <class Ratio, class CharT>
  83 struct ratio_string_static
  84 {
  85     static std::string symbol() {
  86         return std::basic_string<CharT>(
  87                 static_string::c_str<
  88                         typename ratio_static_string<Ratio, CharT>::symbol
  89                     >::value);
  90     }
  91     static std::string prefix()  {
  92         return std::basic_string<CharT>(
  93                 static_string::c_str<
  94                     typename ratio_static_string<Ratio, CharT>::prefix
  95                 >::value);
  96     }
  97 };
  98 }
  99 #endif
 100 // atto
 101 //template <>
 102 //struct ratio_string_is_localizable<atto> : true_type {};
 103 //
 104 //template <>
 105 //struct ratio_string_id<atto> : integral_constant<int,-18> {};
 106
 107 #ifdef BOOST_RATIO_HAS_STATIC_STRING
 108 template <typename CharT>
 109 struct ratio_string<atto, CharT> :
 110     ratio_detail::ratio_string_static<atto,CharT>
 111 {};
 112
 113 #else
 114 template <>
 115 struct ratio_string<atto, char>
 116 {
 117     static std::string symbol() {return std::string(1, 'a');}
 118     static std::string prefix()  {return std::string("atto");}
 119 };
 120
 121 #if defined BOOST_RATIO_HAS_UNICODE_SUPPORT
 122
 123 template <>
 124 struct ratio_string<atto, char16_t>
 125 {
 126     static std::u16string symbol() {return std::u16string(1, u'a');}
 127     static std::u16string prefix()  {return std::u16string(u"atto");}
 128 };
 129
 130 template <>
 131 struct ratio_string<atto, char32_t>
 132 {
 133     static std::u32string symbol() {return std::u32string(1, U'a');}
 134     static std::u32string prefix()  {return std::u32string(U"atto");}
 135 };
 136
 137 #endif
 138
 139 #ifndef BOOST_NO_STD_WSTRING
 140 template <>
 141 struct ratio_string<atto, wchar_t>
 142 {
 143     static std::wstring symbol() {return std::wstring(1, L'a');}
 144     static std::wstring prefix()  {return std::wstring(L"atto");}
 145 };
 146 #endif
 147 #endif
 148
 149 // femto
 150
 151 #ifdef BOOST_RATIO_HAS_STATIC_STRING
 152 template <typename CharT>
 153 struct ratio_string<femto, CharT> :
 154     ratio_detail::ratio_string_static<femto,CharT>
 155 {};
 156
 157 #else
 158
 159 template <>
 160 struct ratio_string<femto, char>
 161 {
 162     static std::string symbol() {return std::string(1, 'f');}
 163     static std::string prefix()  {return std::string("femto");}
 164 };
 165
 166 #if defined BOOST_RATIO_HAS_UNICODE_SUPPORT
 167
 168 template <>
 169 struct ratio_string<femto, char16_t>
 170 {
 171     static std::u16string symbol() {return std::u16string(1, u'f');}
 172     static std::u16string prefix()  {return std::u16string(u"femto");}
 173 };
 174
 175 template <>
 176 struct ratio_string<femto, char32_t>
 177 {
 178     static std::u32string symbol() {return std::u32string(1, U'f');}
 179     static std::u32string prefix()  {return std::u32string(U"femto");}
 180 };
 181
 182 #endif
 183
 184 #ifndef BOOST_NO_STD_WSTRING
 185 template <>
 186 struct ratio_string<femto, wchar_t>
 187 {
 188     static std::wstring symbol() {return std::wstring(1, L'f');}
 189     static std::wstring prefix()  {return std::wstring(L"femto");}
 190 };
 191 #endif
 192 #endif
 193
 194 // pico
 195
 196 #ifdef BOOST_RATIO_HAS_STATIC_STRING
 197 template <typename CharT>
 198 struct ratio_string<pico, CharT> :
 199     ratio_detail::ratio_string_static<pico,CharT>
 200 {};
 201
 202 #else
 203 template <>
 204 struct ratio_string<pico, char>
 205 {
 206     static std::string symbol() {return std::string(1, 'p');}
 207     static std::string prefix()  {return std::string("pico");}
 208 };
 209
 210 #if defined BOOST_RATIO_HAS_UNICODE_SUPPORT
 211
 212 template <>
 213 struct ratio_string<pico, char16_t>
 214 {
 215     static std::u16string symbol() {return std::u16string(1, u'p');}
 216     static std::u16string prefix()  {return std::u16string(u"pico");}
 217 };
 218
 219 template <>
 220 struct ratio_string<pico, char32_t>
 221 {
 222     static std::u32string symbol() {return std::u32string(1, U'p');}
 223     static std::u32string prefix()  {return std::u32string(U"pico");}
 224 };
 225
 226 #endif
 227
 228 #ifndef BOOST_NO_STD_WSTRING
 229 template <>
 230 struct ratio_string<pico, wchar_t>
 231 {
 232     static std::wstring symbol() {return std::wstring(1, L'p');}
 233     static std::wstring prefix()  {return std::wstring(L"pico");}
 234 };
 235 #endif
 236 #endif
 237
 238 // nano
 239
 240 #ifdef BOOST_RATIO_HAS_STATIC_STRING
 241 template <typename CharT>
 242 struct ratio_string<nano, CharT> :
 243     ratio_detail::ratio_string_static<nano,CharT>
 244 {};
 245
 246 #else
 247 template <>
 248 struct ratio_string<nano, char>
 249 {
 250     static std::string symbol() {return std::string(1, 'n');}
 251     static std::string prefix()  {return std::string("nano");}
 252 };
 253
 254 #if defined BOOST_RATIO_HAS_UNICODE_SUPPORT
 255
 256 template <>
 257 struct ratio_string<nano, char16_t>
 258 {
 259     static std::u16string symbol() {return std::u16string(1, u'n');}
 260     static std::u16string prefix()  {return std::u16string(u"nano");}
 261 };
 262
 263 template <>
 264 struct ratio_string<nano, char32_t>
 265 {
 266     static std::u32string symbol() {return std::u32string(1, U'n');}
 267     static std::u32string prefix()  {return std::u32string(U"nano");}
 268 };
 269
 270 #endif
 271
 272 #ifndef BOOST_NO_STD_WSTRING
 273 template <>
 274 struct ratio_string<nano, wchar_t>
 275 {
 276     static std::wstring symbol() {return std::wstring(1, L'n');}
 277     static std::wstring prefix()  {return std::wstring(L"nano");}
 278 };
 279 #endif
 280 #endif
 281
 282 // micro
 283
 284 #ifdef BOOST_RATIO_HAS_STATIC_STRING
 285 template <typename CharT>
 286 struct ratio_string<micro, CharT> :
 287     ratio_detail::ratio_string_static<micro,CharT>
 288 {};
 289
 290 #else
 291 template <>
 292 struct ratio_string<micro, char>
 293 {
 294     static std::string symbol() {return std::string("\xC2\xB5");}
 295     static std::string prefix()  {return std::string("micro");}
 296 };
 297
 298 #if defined BOOST_RATIO_HAS_UNICODE_SUPPORT
 299
 300 template <>
 301 struct ratio_string<micro, char16_t>
 302 {
 303     static std::u16string symbol() {return std::u16string(1, u'\xB5');}
 304     static std::u16string prefix()  {return std::u16string(u"micro");}
 305 };
 306
 307 template <>
 308 struct ratio_string<micro, char32_t>
 309 {
 310     static std::u32string symbol() {return std::u32string(1, U'\xB5');}
 311     static std::u32string prefix()  {return std::u32string(U"micro");}
 312 };
 313
 314 #endif
 315
 316 #ifndef BOOST_NO_STD_WSTRING
 317 template <>
 318 struct ratio_string<micro, wchar_t>
 319 {
 320     static std::wstring symbol() {return std::wstring(1, L'\xB5');}
 321     static std::wstring prefix()  {return std::wstring(L"micro");}
 322 };
 323 #endif
 324 #endif
 325
 326 // milli
 327
 328 #ifdef BOOST_RATIO_HAS_STATIC_STRING
 329 template <typename CharT>
 330 struct ratio_string<milli, CharT> :
 331     ratio_detail::ratio_string_static<milli,CharT>
 332 {};
 333
 334 #else
 335 template <>
 336 struct ratio_string<milli, char>
 337 {
 338     static std::string symbol() {return std::string(1, 'm');}
 339     static std::string prefix()  {return std::string("milli");}
 340 };
 341
 342 #if defined BOOST_RATIO_HAS_UNICODE_SUPPORT
 343
 344 template <>
 345 struct ratio_string<milli, char16_t>
 346 {
 347     static std::u16string symbol() {return std::u16string(1, u'm');}
 348     static std::u16string prefix()  {return std::u16string(u"milli");}
 349 };
 350
 351 template <>
 352 struct ratio_string<milli, char32_t>
 353 {
 354     static std::u32string symbol() {return std::u32string(1, U'm');}
 355     static std::u32string prefix()  {return std::u32string(U"milli");}
 356 };
 357
 358 #endif
 359
 360 #ifndef BOOST_NO_STD_WSTRING
 361 template <>
 362 struct ratio_string<milli, wchar_t>
 363 {
 364     static std::wstring symbol() {return std::wstring(1, L'm');}
 365     static std::wstring prefix()  {return std::wstring(L"milli");}
 366 };
 367 #endif
 368 #endif
 369
 370 // centi
 371
 372 #ifdef BOOST_RATIO_HAS_STATIC_STRING
 373 template <typename CharT>
 374 struct ratio_string<centi, CharT> :
 375     ratio_detail::ratio_string_static<centi,CharT>
 376 {};
 377
 378 #else
 379 template <>
 380 struct ratio_string<centi, char>
 381 {
 382     static std::string symbol() {return std::string(1, 'c');}
 383     static std::string prefix()  {return std::string("centi");}
 384 };
 385
 386 #if defined BOOST_RATIO_HAS_UNICODE_SUPPORT
 387
 388 template <>
 389 struct ratio_string<centi, char16_t>
 390 {
 391     static std::u16string symbol() {return std::u16string(1, u'c');}
 392     static std::u16string prefix()  {return std::u16string(u"centi");}
 393 };
 394
 395 template <>
 396 struct ratio_string<centi, char32_t>
 397 {
 398     static std::u32string symbol() {return std::u32string(1, U'c');}
 399     static std::u32string prefix()  {return std::u32string(U"centi");}
 400 };
 401
 402 #endif
 403
 404 #ifndef BOOST_NO_STD_WSTRING
 405 template <>
 406 struct ratio_string<centi, wchar_t>
 407 {
 408     static std::wstring symbol() {return std::wstring(1, L'c');}
 409     static std::wstring prefix()  {return std::wstring(L"centi");}
 410 };
 411 #endif
 412 #endif
 413
 414 // deci
 415
 416 #ifdef BOOST_RATIO_HAS_STATIC_STRING
 417 template <typename CharT>
 418 struct ratio_string<deci, CharT> :
 419     ratio_detail::ratio_string_static<deci,CharT>
 420 {};
 421
 422 #else
 423
 424 template <>
 425 struct ratio_string<deci, char>
 426 {
 427     static std::string symbol() {return std::string(1, 'd');}
 428     static std::string prefix()  {return std::string("deci");}
 429 };
 430
 431 #if defined BOOST_RATIO_HAS_UNICODE_SUPPORT
 432
 433 template <>
 434 struct ratio_string<deci, char16_t>
 435 {
 436     static std::u16string symbol() {return std::u16string(1, u'd');}
 437     static std::u16string prefix()  {return std::u16string(u"deci");}
 438 };
 439
 440 template <>
 441 struct ratio_string<deci, char32_t>
 442 {
 443     static std::u32string symbol() {return std::u32string(1, U'd');}
 444     static std::u32string prefix()  {return std::u32string(U"deci");}
 445 };
 446
 447 #endif
 448
 449 #ifndef BOOST_NO_STD_WSTRING
 450 template <>
 451 struct ratio_string<deci, wchar_t>
 452 {
 453     static std::wstring symbol() {return std::wstring(1, L'd');}
 454     static std::wstring prefix()  {return std::wstring(L"deci");}
 455 };
 456 #endif
 457 #endif
 458
 459 // unit
 460
 461 // deca
 462
 463
 464 #ifdef BOOST_RATIO_HAS_STATIC_STRING
 465 template <typename CharT>
 466 struct ratio_string<deca, CharT> :
 467     ratio_detail::ratio_string_static<deca,CharT>
 468 {};
 469
 470 #else
 471 template <>
 472 struct ratio_string<deca, char>
 473 {
 474     static std::string symbol() {return std::string("da");}
 475     static std::string prefix()  {return std::string("deca");}
 476 };
 477
 478 #if defined BOOST_RATIO_HAS_UNICODE_SUPPORT
 479
 480 template <>
 481 struct ratio_string<deca, char16_t>
 482 {
 483     static std::u16string symbol() {return std::u16string(u"da");}
 484     static std::u16string prefix()  {return std::u16string(u"deca");}
 485 };
 486
 487 template <>
 488 struct ratio_string<deca, char32_t>
 489 {
 490     static std::u32string symbol() {return std::u32string(U"da");}
 491     static std::u32string prefix()  {return std::u32string(U"deca");}
 492 };
 493
 494 #endif
 495
 496 #ifndef BOOST_NO_STD_WSTRING
 497 template <>
 498 struct ratio_string<deca, wchar_t>
 499 {
 500     static std::wstring symbol() {return std::wstring(L"da");}
 501     static std::wstring prefix()  {return std::wstring(L"deca");}
 502 };
 503 #endif
 504 #endif
 505
 506 // hecto
 507
 508 #ifdef BOOST_RATIO_HAS_STATIC_STRING
 509 template <typename CharT>
 510 struct ratio_string<hecto, CharT> :
 511     ratio_detail::ratio_string_static<hecto,CharT>
 512 {};
 513
 514 #else
 515 template <>
 516 struct ratio_string<hecto, char>
 517 {
 518     static std::string symbol() {return std::string(1, 'h');}
 519     static std::string prefix()  {return std::string("hecto");}
 520 };
 521
 522 #if defined BOOST_RATIO_HAS_UNICODE_SUPPORT
 523
 524 template <>
 525 struct ratio_string<hecto, char16_t>
 526 {
 527     static std::u16string symbol() {return std::u16string(1, u'h');}
 528     static std::u16string prefix()  {return std::u16string(u"hecto");}
 529 };
 530
 531 template <>
 532 struct ratio_string<hecto, char32_t>
 533 {
 534     static std::u32string symbol() {return std::u32string(1, U'h');}
 535     static std::u32string prefix()  {return std::u32string(U"hecto");}
 536 };
 537
 538 #endif
 539
 540 #ifndef BOOST_NO_STD_WSTRING
 541 template <>
 542 struct ratio_string<hecto, wchar_t>
 543 {
 544     static std::wstring symbol() {return std::wstring(1, L'h');}
 545     static std::wstring prefix()  {return std::wstring(L"hecto");}
 546 };
 547 #endif
 548 #endif
 549
 550 // kilo
 551
 552 #ifdef BOOST_RATIO_HAS_STATIC_STRING
 553 template <typename CharT>
 554 struct ratio_string<kilo, CharT> :
 555     ratio_detail::ratio_string_static<kilo,CharT>
 556 {};
 557
 558 #else
 559 template <>
 560 struct ratio_string<kilo, char>
 561 {
 562     static std::string symbol() {return std::string(1, 'k');}
 563     static std::string prefix()  {return std::string("kilo");}
 564 };
 565
 566 #if defined BOOST_RATIO_HAS_UNICODE_SUPPORT
 567
 568 template <>
 569 struct ratio_string<kilo, char16_t>
 570 {
 571     static std::u16string symbol() {return std::u16string(1, u'k');}
 572     static std::u16string prefix()  {return std::u16string(u"kilo");}
 573 };
 574
 575 template <>
 576 struct ratio_string<kilo, char32_t>
 577 {
 578     static std::u32string symbol() {return std::u32string(1, U'k');}
 579     static std::u32string prefix()  {return std::u32string(U"kilo");}
 580 };
 581
 582 #endif
 583
 584 #ifndef BOOST_NO_STD_WSTRING
 585 template <>
 586 struct ratio_string<kilo, wchar_t>
 587 {
 588     static std::wstring symbol() {return std::wstring(1, L'k');}
 589     static std::wstring prefix()  {return std::wstring(L"kilo");}
 590 };
 591 #endif
 592 #endif
 593
 594 // mega
 595
 596 #ifdef BOOST_RATIO_HAS_STATIC_STRING
 597 template <typename CharT>
 598 struct ratio_string<mega, CharT> :
 599     ratio_detail::ratio_string_static<mega,CharT>
 600 {};
 601
 602 #else
 603
 604 template <>
 605 struct ratio_string<mega, char>
 606 {
 607     static std::string symbol() {return std::string(1, 'M');}
 608     static std::string prefix()  {return std::string("mega");}
 609 };
 610
 611 #if defined BOOST_RATIO_HAS_UNICODE_SUPPORT
 612
 613 template <>
 614 struct ratio_string<mega, char16_t>
 615 {
 616     static std::u16string symbol() {return std::u16string(1, u'M');}
 617     static std::u16string prefix()  {return std::u16string(u"mega");}
 618 };
 619
 620 template <>
 621 struct ratio_string<mega, char32_t>
 622 {
 623     static std::u32string symbol() {return std::u32string(1, U'M');}
 624     static std::u32string prefix()  {return std::u32string(U"mega");}
 625 };
 626
 627 #endif
 628
 629 #ifndef BOOST_NO_STD_WSTRING
 630 template <>
 631 struct ratio_string<mega, wchar_t>
 632 {
 633     static std::wstring symbol() {return std::wstring(1, L'M');}
 634     static std::wstring prefix()  {return std::wstring(L"mega");}
 635 };
 636 #endif
 637 #endif
 638
 639 // giga
 640
 641 #ifdef BOOST_RATIO_HAS_STATIC_STRING
 642 template <typename CharT>
 643 struct ratio_string<giga, CharT> :
 644     ratio_detail::ratio_string_static<giga,CharT>
 645 {};
 646
 647 #else
 648
 649 template <>
 650 struct ratio_string<giga, char>
 651 {
 652     static std::string symbol() {return std::string(1, 'G');}
 653     static std::string prefix()  {return std::string("giga");}
 654 };
 655
 656 #if defined BOOST_RATIO_HAS_UNICODE_SUPPORT
 657
 658 template <>
 659 struct ratio_string<giga, char16_t>
 660 {
 661     static std::u16string symbol() {return std::u16string(1, u'G');}
 662     static std::u16string prefix()  {return std::u16string(u"giga");}
 663 };
 664
 665 template <>
 666 struct ratio_string<giga, char32_t>
 667 {
 668     static std::u32string symbol() {return std::u32string(1, U'G');}
 669     static std::u32string prefix()  {return std::u32string(U"giga");}
 670 };
 671
 672 #endif
 673
 674 #ifndef BOOST_NO_STD_WSTRING
 675 template <>
 676 struct ratio_string<giga, wchar_t>
 677 {
 678     static std::wstring symbol() {return std::wstring(1, L'G');}
 679     static std::wstring prefix()  {return std::wstring(L"giga");}
 680 };
 681 #endif
 682 #endif
 683
 684 // tera
 685
 686 //template <>
 687 #ifdef BOOST_RATIO_HAS_STATIC_STRING
 688 template <typename CharT>
 689 struct ratio_string<tera, CharT> :
 690     ratio_detail::ratio_string_static<tera,CharT>
 691 {};
 692
 693 #else
 694 template <>
 695 struct ratio_string<tera, char>
 696 {
 697     static std::string symbol() {return std::string(1, 'T');}
 698     static std::string prefix()  {return std::string("tera");}
 699 };
 700
 701 #if defined BOOST_RATIO_HAS_UNICODE_SUPPORT
 702
 703 template <>
 704 struct ratio_string<tera, char16_t>
 705 {
 706     static std::u16string symbol() {return std::u16string(1, u'T');}
 707     static std::u16string prefix()  {return std::u16string(u"tera");}
 708 };
 709
 710 template <>
 711 struct ratio_string<tera, char32_t>
 712 {
 713     static std::u32string symbol() {return std::u32string(1, U'T');}
 714     static std::u32string prefix()  {return std::u32string(U"tera");}
 715 };
 716
 717 #endif
 718
 719 #ifndef BOOST_NO_STD_WSTRING
 720 template <>
 721 struct ratio_string<tera, wchar_t>
 722 {
 723     static std::wstring symbol() {return std::wstring(1, L'T');}
 724     static std::wstring prefix()  {return std::wstring(L"tera");}
 725 };
 726 #endif
 727 #endif
 728
 729 // peta
 730
 731 #ifdef BOOST_RATIO_HAS_STATIC_STRING
 732 template <typename CharT>
 733 struct ratio_string<peta, CharT> :
 734     ratio_detail::ratio_string_static<peta,CharT>
 735 {};
 736
 737 #else
 738 template <>
 739 struct ratio_string<peta, char>
 740 {
 741     static std::string symbol() {return std::string(1, 'P');}
 742     static std::string prefix()  {return std::string("peta");}
 743 };
 744
 745 #if defined BOOST_RATIO_HAS_UNICODE_SUPPORT
 746
 747 template <>
 748 struct ratio_string<peta, char16_t>
 749 {
 750     static std::u16string symbol() {return std::u16string(1, u'P');}
 751     static std::u16string prefix()  {return std::u16string(u"peta");}
 752 };
 753
 754 template <>
 755 struct ratio_string<peta, char32_t>
 756 {
 757     static std::u32string symbol() {return std::u32string(1, U'P');}
 758     static std::u32string prefix()  {return std::u32string(U"peta");}
 759 };
 760
 761 #endif
 762
 763 #ifndef BOOST_NO_STD_WSTRING
 764 template <>
 765 struct ratio_string<peta, wchar_t>
 766 {
 767     static std::wstring symbol() {return std::wstring(1, L'P');}
 768     static std::wstring prefix()  {return std::wstring(L"peta");}
 769 };
 770 #endif
 771 #endif
 772
 773 // exa
 774
 775 #ifdef BOOST_RATIO_HAS_STATIC_STRING
 776 template <typename CharT>
 777 struct ratio_string<exa, CharT> :
 778     ratio_detail::ratio_string_static<exa,CharT>
 779 {};
 780
 781 #else
 782 template <>
 783 struct ratio_string<exa, char>
 784 {
 785     static std::string symbol() {return std::string(1, 'E');}
 786     static std::string prefix()  {return std::string("exa");}
 787 };
 788
 789 #if defined BOOST_RATIO_HAS_UNICODE_SUPPORT
 790
 791 template <>
 792 struct ratio_string<exa, char16_t>
 793 {
 794     static std::u16string symbol() {return std::u16string(1, u'E');}
 795     static std::u16string prefix()  {return std::u16string(u"exa");}
 796 };
 797
 798 template <>
 799 struct ratio_string<exa, char32_t>
 800 {
 801     static std::u32string symbol() {return std::u32string(1, U'E');}
 802     static std::u32string prefix()  {return std::u32string(U"exa");}
 803 };
 804
 805 #endif
 806
 807 #ifndef BOOST_NO_STD_WSTRING
 808 template <>
 809 struct ratio_string<exa, wchar_t>
 810 {
 811     static std::wstring symbol() {return std::wstring(1, L'E');}
 812     static std::wstring prefix()  {return std::wstring(L"exa");}
 813 };
 814 #endif
 815 #endif
 816
 817
 818 #ifdef BOOST_RATIO_EXTENSIONS
 819
 820 #ifdef BOOST_RATIO_HAS_STATIC_STRING
 821 template <typename CharT>
 822 struct ratio_string<kibi, CharT> :
 823     ratio_detail::ratio_string_static<kibi,CharT>
 824 {};
 825
 826 #else
 827 template <>
 828 struct ratio_string<kibi, char>
 829 {
 830     static std::string symbol() {return std::string("Ki");}
 831     static std::string prefix()  {return std::string("kibi");}
 832 };
 833
 834 #if BOOST_RATIO_HAS_UNICODE_SUPPORT
 835
 836 template <>
 837 struct ratio_string<kibi, char16_t>
 838 {
 839     static std::u16string symbol() {return std::u16string(u"Ki");}
 840     static std::u16string prefix()  {return std::u16string(u"kibi");}
 841 };
 842
 843 template <>
 844 struct ratio_string<kibi, char32_t>
 845 {
 846     static std::u32string symbol() {return std::u32string(U"Ki");}
 847     static std::u32string prefix()  {return std::u32string(U"kibi");}
 848 };
 849
 850 #endif
 851
 852 #ifndef BOOST_NO_STD_WSTRING
 853 template <>
 854 struct ratio_string<kibi, wchar_t>
 855 {
 856     static std::wstring symbol() {return std::wstring(L"Ki");}
 857     static std::wstring prefix()  {return std::wstring(L"kibi");}
 858 };
 859 #endif
 860 #endif
 861
 862 #ifdef BOOST_RATIO_HAS_STATIC_STRING
 863 template <typename CharT>
 864 struct ratio_string<mebi, CharT> :
 865     ratio_detail::ratio_string_static<mebi,CharT>
 866 {};
 867
 868 #else
 869 template <>
 870 struct ratio_string<mebi, char>
 871 {
 872     static std::string symbol() {return std::string("Mi");}
 873     static std::string prefix()  {return std::string("mebi");}
 874 };
 875
 876 #if BOOST_RATIO_HAS_UNICODE_SUPPORT
 877
 878 template <>
 879 struct ratio_string<mebi, char16_t>
 880 {
 881     static std::u16string symbol() {return std::u16string(u"Mi");}
 882     static std::u16string prefix()  {return std::u16string(u"mebi");}
 883 };
 884
 885 template <>
 886 struct ratio_string<mebi, char32_t>
 887 {
 888     static std::u32string symbol() {return std::u32string(U"Mi");}
 889     static std::u32string prefix()  {return std::u32string(U"mebi");}
 890 };
 891
 892 #endif
 893
 894 #ifndef BOOST_NO_STD_WSTRING
 895 template <>
 896 struct ratio_string<mebi, wchar_t>
 897 {
 898     static std::wstring symbol() {return std::wstring(L"Mi");}
 899     static std::wstring prefix()  {return std::wstring(L"mebi");}
 900 };
 901 #endif
 902 #endif
 903
 904 #ifdef BOOST_RATIO_HAS_STATIC_STRING
 905 template <typename CharT>
 906 struct ratio_string<gibi, CharT> :
 907     ratio_detail::ratio_string_static<gibi,CharT>
 908 {};
 909
 910 #else
 911 template <>
 912 struct ratio_string<gibi, char>
 913 {
 914     static std::string symbol() {return std::string("Gi");}
 915     static std::string prefix()  {return std::string("gibi");}
 916 };
 917
 918 #if BOOST_RATIO_HAS_UNICODE_SUPPORT
 919
 920 template <>
 921 struct ratio_string<gibi, char16_t>
 922 {
 923     static std::u16string symbol() {return std::u16string(u"Gi");}
 924     static std::u16string prefix()  {return std::u16string(u"gibi");}
 925 };
 926
 927 template <>
 928 struct ratio_string<gibi, char32_t>
 929 {
 930     static std::u32string symbol() {return std::u32string(U"Gi");}
 931     static std::u32string prefix()  {return std::u32string(U"gibi");}
 932 };
 933
 934 #endif
 935
 936 #ifndef BOOST_NO_STD_WSTRING
 937 template <>
 938 struct ratio_string<gibi, wchar_t>
 939 {
 940     static std::wstring symbol() {return std::wstring(L"Gi");}
 941     static std::wstring prefix()  {return std::wstring(L"gibi");}
 942 };
 943 #endif
 944 #endif
 945
 946 #ifdef BOOST_RATIO_HAS_STATIC_STRING
 947 template <typename CharT>
 948 struct ratio_string<tebi, CharT> :
 949     ratio_detail::ratio_string_static<tebi,CharT>
 950 {};
 951
 952 #else
 953 template <>
 954 struct ratio_string<tebi, char>
 955 {
 956     static std::string symbol() {return std::string("Ti");}
 957     static std::string prefix()  {return std::string("tebi");}
 958 };
 959
 960 #if BOOST_RATIO_HAS_UNICODE_SUPPORT
 961
 962 template <>
 963 struct ratio_string<tebi, char16_t>
 964 {
 965     static std::u16string symbol() {return std::u16string(u"Ti");}
 966     static std::u16string prefix()  {return std::u16string(u"tebi");}
 967 };
 968
 969 template <>
 970 struct ratio_string<tebi, char32_t>
 971 {
 972     static std::u32string symbol() {return std::u32string(U"Ti");}
 973     static std::u32string prefix()  {return std::u32string(U"tebi");}
 974 };
 975
 976 #endif
 977
 978 #ifndef BOOST_NO_STD_WSTRING
 979 template <>
 980 struct ratio_string<tebi, wchar_t>
 981 {
 982     static std::wstring symbol() {return std::wstring(L"Ti");}
 983     static std::wstring prefix()  {return std::wstring(L"tebi");}
 984 };
 985 #endif
 986 #endif
 987
 988 #ifdef BOOST_RATIO_HAS_STATIC_STRING
 989 template <typename CharT>
 990 struct ratio_string<pebi, CharT> :
 991     ratio_detail::ratio_string_static<pebi,CharT>
 992 {};
 993
 994 #else
 995 template <>
 996 struct ratio_string<pebi, char>
 997 {
 998     static std::string symbol() {return std::string("Pi");}
 999     static std::string prefix()  {return std::string("pebi");}
1000 };
1001
1002 #if BOOST_RATIO_HAS_UNICODE_SUPPORT
1003
1004 template <>
1005 struct ratio_string<pebi, char16_t>
1006 {
1007     static std::u16string symbol() {return std::u16string(u"Pi");}
1008     static std::u16string prefix()  {return std::u16string(u"pebi");}
1009 };
1010
1011 template <>
1012 struct ratio_string<pebi, char32_t>
1013 {
1014     static std::u32string symbol() {return std::u32string(U"Pi");}
1015     static std::u32string prefix()  {return std::u32string(U"pebi");}
1016 };
1017
1018 #endif
1019
1020 #ifndef BOOST_NO_STD_WSTRING
1021 template <>
1022 struct ratio_string<pebi, wchar_t>
1023 {
1024     static std::wstring symbol() {return std::wstring(L"Pi");}
1025     static std::wstring prefix()  {return std::wstring(L"pebi");}
1026 };
1027 #endif
1028 #endif
1029
1030 #ifdef BOOST_RATIO_HAS_STATIC_STRING
1031 template <typename CharT>
1032 struct ratio_string<exbi, CharT> :
1033     ratio_detail::ratio_string_static<exbi,CharT>
1034 {};
1035
1036 #else
1037 template <>
1038 struct ratio_string<exbi, char>
1039 {
1040     static std::string symbol() {return std::string("Ei");}
1041     static std::string prefix()  {return std::string("exbi");}
1042 };
1043
1044 #if BOOST_RATIO_HAS_UNICODE_SUPPORT
1045
1046 template <>
1047 struct ratio_string<exbi, char16_t>
1048 {
1049     static std::u16string symbol() {return std::u16string(u"Ei");}
1050     static std::u16string prefix()  {return std::u16string(u"exbi");}
1051 };
1052
1053 template <>
1054 struct ratio_string<exbi, char32_t>
1055 {
1056     static std::u32string symbol() {return std::u32string(U"Ei");}
1057     static std::u32string prefix()  {return std::u32string(U"exbi");}
1058 };
1059
1060 #endif
1061
1062 #ifndef BOOST_NO_STD_WSTRING
1063 template <>
1064 struct ratio_string<exbi, wchar_t>
1065 {
1066     static std::wstring symbol() {return std::wstring(L"Ei");}
1067     static std::wstring prefix()  {return std::wstring(L"exbi");}
1068 };
1069 #endif
1070 #endif
1071 #endif
1072
1073 }
1074
1075 #endif  // BOOST_RATIO_PROVIDES_DEPRECATED_FEATURES_SINCE_V2_0_0
1076 #endif  // BOOST_RATIO_RATIO_IO_HPP