contrib/libc++/include/iomanip

   1 // -*- C++ -*-
   2 //===--------------------------- iomanip ----------------------------------===//
   3 //
   4 //                     The LLVM Compiler Infrastructure
   5 //
   6 // This file is dual licensed under the MIT and the University of Illinois Open
   7 // Source Licenses. See LICENSE.TXT for details.
   8 //
   9 //===----------------------------------------------------------------------===//
  10
  11 #ifndef _LIBCPP_IOMANIP
  12 #define _LIBCPP_IOMANIP
  13
  14 /*
  15     iomanip synopsis
  16
  17 // types T1, T2, ... are unspecified implementation types
  18 T1 resetiosflags(ios_base::fmtflags mask);
  19 T2 setiosflags (ios_base::fmtflags mask);
  20 T3 setbase(int base);
  21 template<charT> T4 setfill(charT c);
  22 T5 setprecision(int n);
  23 T6 setw(int n);
  24 template <class moneyT> T7 get_money(moneyT& mon, bool intl = false);
  25 template <class charT, class moneyT> T8 put_money(const moneyT& mon, bool intl = false);
  26 template <class charT> T9 get_time(struct tm* tmb, const charT* fmt);
  27 template <class charT> T10 put_time(const struct tm* tmb, const charT* fmt);
  28
  29 }  // std
  30
  31 */
  32
  33 #include <__config>
  34 #include <istream>
  35
  36 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
  37 #pragma GCC system_header
  38 #endif
  39
  40 _LIBCPP_BEGIN_NAMESPACE_STD
  41
  42 // resetiosflags
  43
  44 class __iom_t1
  45 {
  46     ios_base::fmtflags __mask_;
  47 public:
  48     _LIBCPP_INLINE_VISIBILITY
  49     explicit __iom_t1(ios_base::fmtflags __m) : __mask_(__m) {}
  50
  51     template <class _CharT, class _Traits>
  52     friend
  53     _LIBCPP_INLINE_VISIBILITY
  54     basic_istream<_CharT, _Traits>&
  55     operator>>(basic_istream<_CharT, _Traits>& __is, const __iom_t1& __x)
  56     {
  57         __is.unsetf(__x.__mask_);
  58         return __is;
  59     }
  60
  61     template <class _CharT, class _Traits>
  62     friend
  63     _LIBCPP_INLINE_VISIBILITY
  64     basic_ostream<_CharT, _Traits>&
  65     operator<<(basic_ostream<_CharT, _Traits>& __os, const __iom_t1& __x)
  66     {
  67         __os.unsetf(__x.__mask_);
  68         return __os;
  69     }
  70 };
  71
  72 inline _LIBCPP_INLINE_VISIBILITY
  73 __iom_t1
  74 resetiosflags(ios_base::fmtflags __mask)
  75 {
  76     return __iom_t1(__mask);
  77 }
  78
  79 // setiosflags
  80
  81 class __iom_t2
  82 {
  83     ios_base::fmtflags __mask_;
  84 public:
  85     _LIBCPP_INLINE_VISIBILITY
  86     explicit __iom_t2(ios_base::fmtflags __m) : __mask_(__m) {}
  87
  88     template <class _CharT, class _Traits>
  89     friend
  90     _LIBCPP_INLINE_VISIBILITY
  91     basic_istream<_CharT, _Traits>&
  92     operator>>(basic_istream<_CharT, _Traits>& __is, const __iom_t2& __x)
  93     {
  94         __is.setf(__x.__mask_);
  95         return __is;
  96     }
  97
  98     template <class _CharT, class _Traits>
  99     friend
 100     _LIBCPP_INLINE_VISIBILITY
 101     basic_ostream<_CharT, _Traits>&
 102     operator<<(basic_ostream<_CharT, _Traits>& __os, const __iom_t2& __x)
 103     {
 104         __os.setf(__x.__mask_);
 105         return __os;
 106     }
 107 };
 108
 109 inline _LIBCPP_INLINE_VISIBILITY
 110 __iom_t2
 111 setiosflags(ios_base::fmtflags __mask)
 112 {
 113     return __iom_t2(__mask);
 114 }
 115
 116 // setbase
 117
 118 class __iom_t3
 119 {
 120     int __base_;
 121 public:
 122     _LIBCPP_INLINE_VISIBILITY
 123     explicit __iom_t3(int __b) : __base_(__b) {}
 124
 125     template <class _CharT, class _Traits>
 126     friend
 127     _LIBCPP_INLINE_VISIBILITY
 128     basic_istream<_CharT, _Traits>&
 129     operator>>(basic_istream<_CharT, _Traits>& __is, const __iom_t3& __x)
 130     {
 131         __is.setf(__x.__base_ == 8  ? ios_base::oct :
 132                   __x.__base_ == 10 ? ios_base::dec :
 133                   __x.__base_ == 16 ? ios_base::hex :
 134                   ios_base::fmtflags(0), ios_base::basefield);
 135         return __is;
 136     }
 137
 138     template <class _CharT, class _Traits>
 139     friend
 140     _LIBCPP_INLINE_VISIBILITY
 141     basic_ostream<_CharT, _Traits>&
 142     operator<<(basic_ostream<_CharT, _Traits>& __os, const __iom_t3& __x)
 143     {
 144         __os.setf(__x.__base_ == 8  ? ios_base::oct :
 145                   __x.__base_ == 10 ? ios_base::dec :
 146                   __x.__base_ == 16 ? ios_base::hex :
 147                   ios_base::fmtflags(0), ios_base::basefield);
 148         return __os;
 149     }
 150 };
 151
 152 inline _LIBCPP_INLINE_VISIBILITY
 153 __iom_t3
 154 setbase(int __base)
 155 {
 156     return __iom_t3(__base);
 157 }
 158
 159 // setfill
 160
 161 template<class _CharT>
 162 class __iom_t4
 163 {
 164     _CharT __fill_;
 165 public:
 166     _LIBCPP_INLINE_VISIBILITY
 167     explicit __iom_t4(_CharT __c) : __fill_(__c) {}
 168
 169     template <class _Traits>
 170     friend
 171     _LIBCPP_INLINE_VISIBILITY
 172     basic_ostream<_CharT, _Traits>&
 173     operator<<(basic_ostream<_CharT, _Traits>& __os, const __iom_t4& __x)
 174     {
 175         __os.fill(__x.__fill_);
 176         return __os;
 177     }
 178 };
 179
 180 template<class _CharT>
 181 inline _LIBCPP_INLINE_VISIBILITY
 182 __iom_t4<_CharT>
 183 setfill(_CharT __c)
 184 {
 185     return __iom_t4<_CharT>(__c);
 186 }
 187
 188 // setprecision
 189
 190 class __iom_t5
 191 {
 192     int __n_;
 193 public:
 194     _LIBCPP_INLINE_VISIBILITY
 195     explicit __iom_t5(int __n) : __n_(__n) {}
 196
 197     template <class _CharT, class _Traits>
 198     friend
 199     _LIBCPP_INLINE_VISIBILITY
 200     basic_istream<_CharT, _Traits>&
 201     operator>>(basic_istream<_CharT, _Traits>& __is, const __iom_t5& __x)
 202     {
 203         __is.precision(__x.__n_);
 204         return __is;
 205     }
 206
 207     template <class _CharT, class _Traits>
 208     friend
 209     _LIBCPP_INLINE_VISIBILITY
 210     basic_ostream<_CharT, _Traits>&
 211     operator<<(basic_ostream<_CharT, _Traits>& __os, const __iom_t5& __x)
 212     {
 213         __os.precision(__x.__n_);
 214         return __os;
 215     }
 216 };
 217
 218 inline _LIBCPP_INLINE_VISIBILITY
 219 __iom_t5
 220 setprecision(int __n)
 221 {
 222     return __iom_t5(__n);
 223 }
 224
 225 // setw
 226
 227 class __iom_t6
 228 {
 229     int __n_;
 230 public:
 231     _LIBCPP_INLINE_VISIBILITY
 232     explicit __iom_t6(int __n) : __n_(__n) {}
 233
 234     template <class _CharT, class _Traits>
 235     friend
 236     _LIBCPP_INLINE_VISIBILITY
 237     basic_istream<_CharT, _Traits>&
 238     operator>>(basic_istream<_CharT, _Traits>& __is, const __iom_t6& __x)
 239     {
 240         __is.width(__x.__n_);
 241         return __is;
 242     }
 243
 244     template <class _CharT, class _Traits>
 245     friend
 246     _LIBCPP_INLINE_VISIBILITY
 247     basic_ostream<_CharT, _Traits>&
 248     operator<<(basic_ostream<_CharT, _Traits>& __os, const __iom_t6& __x)
 249     {
 250         __os.width(__x.__n_);
 251         return __os;
 252     }
 253 };
 254
 255 inline _LIBCPP_INLINE_VISIBILITY
 256 __iom_t6
 257 setw(int __n)
 258 {
 259     return __iom_t6(__n);
 260 }
 261
 262 // get_money
 263
 264 template <class _MoneyT> class __iom_t7;
 265
 266 template <class _CharT, class _Traits, class _MoneyT>
 267 basic_istream<_CharT, _Traits>&
 268 operator>>(basic_istream<_CharT, _Traits>& __is, const __iom_t7<_MoneyT>& __x);
 269
 270 template <class _MoneyT>
 271 class __iom_t7
 272 {
 273     _MoneyT& __mon_;
 274     bool __intl_;
 275 public:
 276     _LIBCPP_INLINE_VISIBILITY
 277     __iom_t7(_MoneyT& __mon, bool __intl)
 278         : __mon_(__mon), __intl_(__intl) {}
 279
 280     template <class _CharT, class _Traits, class _Mp>
 281     friend
 282     basic_istream<_CharT, _Traits>&
 283     operator>>(basic_istream<_CharT, _Traits>& __is, const __iom_t7<_Mp>& __x);
 284 };
 285
 286 template <class _CharT, class _Traits, class _MoneyT>
 287 basic_istream<_CharT, _Traits>&
 288 operator>>(basic_istream<_CharT, _Traits>& __is, const __iom_t7<_MoneyT>& __x)
 289 {
 290 #ifndef _LIBCPP_NO_EXCEPTIONS
 291     try
 292     {
 293 #endif  // _LIBCPP_NO_EXCEPTIONS
 294         typename basic_istream<_CharT, _Traits>::sentry __s(__is);
 295         if (__s)
 296         {
 297             typedef istreambuf_iterator<_CharT, _Traits> _Ip;
 298             typedef money_get<_CharT, _Ip> _Fp;
 299             ios_base::iostate __err = ios_base::goodbit;
 300             const _Fp& __mf = use_facet<_Fp>(__is.getloc());
 301             __mf.get(_Ip(__is), _Ip(), __x.__intl_, __is, __err, __x.__mon_);
 302             __is.setstate(__err);
 303         }
 304 #ifndef _LIBCPP_NO_EXCEPTIONS
 305     }
 306     catch (...)
 307     {
 308         __is.__set_badbit_and_consider_rethrow();
 309     }
 310 #endif  // _LIBCPP_NO_EXCEPTIONS
 311     return __is;
 312 }
 313
 314 template <class _MoneyT>
 315 inline _LIBCPP_INLINE_VISIBILITY
 316 __iom_t7<_MoneyT>
 317 get_money(_MoneyT& __mon, bool __intl = false)
 318 {
 319     return __iom_t7<_MoneyT>(__mon, __intl);
 320 }
 321
 322 // put_money
 323
 324 template <class _MoneyT> class __iom_t8;
 325
 326 template <class _CharT, class _Traits, class _MoneyT>
 327 basic_ostream<_CharT, _Traits>&
 328 operator<<(basic_ostream<_CharT, _Traits>& __os, const __iom_t8<_MoneyT>& __x);
 329
 330 template <class _MoneyT>
 331 class __iom_t8
 332 {
 333     const _MoneyT& __mon_;
 334     bool __intl_;
 335 public:
 336     _LIBCPP_INLINE_VISIBILITY
 337     __iom_t8(const _MoneyT& __mon, bool __intl)
 338         : __mon_(__mon), __intl_(__intl) {}
 339
 340     template <class _CharT, class _Traits, class _Mp>
 341     friend
 342     basic_ostream<_CharT, _Traits>&
 343     operator<<(basic_ostream<_CharT, _Traits>& __os, const __iom_t8<_Mp>& __x);
 344 };
 345
 346 template <class _CharT, class _Traits, class _MoneyT>
 347 basic_ostream<_CharT, _Traits>&
 348 operator<<(basic_ostream<_CharT, _Traits>& __os, const __iom_t8<_MoneyT>& __x)
 349 {
 350 #ifndef _LIBCPP_NO_EXCEPTIONS
 351     try
 352     {
 353 #endif  // _LIBCPP_NO_EXCEPTIONS
 354         typename basic_ostream<_CharT, _Traits>::sentry __s(__os);
 355         if (__s)
 356         {
 357             typedef ostreambuf_iterator<_CharT, _Traits> _Op;
 358             typedef money_put<_CharT, _Op> _Fp;
 359             const _Fp& __mf = use_facet<_Fp>(__os.getloc());
 360             if (__mf.put(_Op(__os), __x.__intl_, __os, __os.fill(), __x.__mon_).failed())
 361                 __os.setstate(ios_base::badbit);
 362         }
 363 #ifndef _LIBCPP_NO_EXCEPTIONS
 364     }
 365     catch (...)
 366     {
 367         __os.__set_badbit_and_consider_rethrow();
 368     }
 369 #endif  // _LIBCPP_NO_EXCEPTIONS
 370     return __os;
 371 }
 372
 373 template <class _MoneyT>
 374 inline _LIBCPP_INLINE_VISIBILITY
 375 __iom_t8<_MoneyT>
 376 put_money(const _MoneyT& __mon, bool __intl = false)
 377 {
 378     return __iom_t8<_MoneyT>(__mon, __intl);
 379 }
 380
 381 // get_time
 382
 383 template <class _CharT> class __iom_t9;
 384
 385 template <class _CharT, class _Traits>
 386 basic_istream<_CharT, _Traits>&
 387 operator>>(basic_istream<_CharT, _Traits>& __is, const __iom_t9<_CharT>& __x);
 388
 389 template <class _CharT>
 390 class __iom_t9
 391 {
 392     tm* __tm_;
 393     const _CharT* __fmt_;
 394 public:
 395     _LIBCPP_INLINE_VISIBILITY
 396     __iom_t9(tm* __tm, const _CharT* __fmt)
 397         : __tm_(__tm), __fmt_(__fmt) {}
 398
 399     template <class _Cp, class _Traits>
 400     friend
 401     basic_istream<_Cp, _Traits>&
 402     operator>>(basic_istream<_Cp, _Traits>& __is, const __iom_t9<_Cp>& __x);
 403 };
 404
 405 template <class _CharT, class _Traits>
 406 basic_istream<_CharT, _Traits>&
 407 operator>>(basic_istream<_CharT, _Traits>& __is, const __iom_t9<_CharT>& __x)
 408 {
 409 #ifndef _LIBCPP_NO_EXCEPTIONS
 410     try
 411     {
 412 #endif  // _LIBCPP_NO_EXCEPTIONS
 413         typename basic_istream<_CharT, _Traits>::sentry __s(__is);
 414         if (__s)
 415         {
 416             typedef istreambuf_iterator<_CharT, _Traits> _Ip;
 417             typedef time_get<_CharT, _Ip> _Fp;
 418             ios_base::iostate __err = ios_base::goodbit;
 419             const _Fp& __tf = use_facet<_Fp>(__is.getloc());
 420             __tf.get(_Ip(__is), _Ip(), __is, __err, __x.__tm_,
 421                      __x.__fmt_, __x.__fmt_ + _Traits::length(__x.__fmt_));
 422             __is.setstate(__err);
 423         }
 424 #ifndef _LIBCPP_NO_EXCEPTIONS
 425     }
 426     catch (...)
 427     {
 428         __is.__set_badbit_and_consider_rethrow();
 429     }
 430 #endif  // _LIBCPP_NO_EXCEPTIONS
 431     return __is;
 432 }
 433
 434 template <class _CharT>
 435 inline _LIBCPP_INLINE_VISIBILITY
 436 __iom_t9<_CharT>
 437 get_time(tm* __tm, const _CharT* __fmt)
 438 {
 439     return __iom_t9<_CharT>(__tm, __fmt);
 440 }
 441
 442 // put_time
 443
 444 template <class _CharT> class __iom_t10;
 445
 446 template <class _CharT, class _Traits>
 447 basic_ostream<_CharT, _Traits>&
 448 operator<<(basic_ostream<_CharT, _Traits>& __os, const __iom_t10<_CharT>& __x);
 449
 450 template <class _CharT>
 451 class __iom_t10
 452 {
 453     const tm* __tm_;
 454     const _CharT* __fmt_;
 455 public:
 456     _LIBCPP_INLINE_VISIBILITY
 457     __iom_t10(const tm* __tm, const _CharT* __fmt)
 458         : __tm_(__tm), __fmt_(__fmt) {}
 459
 460     template <class _Cp, class _Traits>
 461     friend
 462     basic_ostream<_Cp, _Traits>&
 463     operator<<(basic_ostream<_Cp, _Traits>& __os, const __iom_t10<_Cp>& __x);
 464 };
 465
 466 template <class _CharT, class _Traits>
 467 basic_ostream<_CharT, _Traits>&
 468 operator<<(basic_ostream<_CharT, _Traits>& __os, const __iom_t10<_CharT>& __x)
 469 {
 470 #ifndef _LIBCPP_NO_EXCEPTIONS
 471     try
 472     {
 473 #endif  // _LIBCPP_NO_EXCEPTIONS
 474         typename basic_ostream<_CharT, _Traits>::sentry __s(__os);
 475         if (__s)
 476         {
 477             typedef ostreambuf_iterator<_CharT, _Traits> _Op;
 478             typedef time_put<_CharT, _Op> _Fp;
 479             const _Fp& __tf = use_facet<_Fp>(__os.getloc());
 480             if (__tf.put(_Op(__os), __os, __os.fill(), __x.__tm_,
 481                          __x.__fmt_, __x.__fmt_ + _Traits::length(__x.__fmt_)).failed())
 482                 __os.setstate(ios_base::badbit);
 483         }
 484 #ifndef _LIBCPP_NO_EXCEPTIONS
 485     }
 486     catch (...)
 487     {
 488         __os.__set_badbit_and_consider_rethrow();
 489     }
 490 #endif  // _LIBCPP_NO_EXCEPTIONS
 491     return __os;
 492 }
 493
 494 template <class _CharT>
 495 inline _LIBCPP_INLINE_VISIBILITY
 496 __iom_t10<_CharT>
 497 put_time(const tm* __tm, const _CharT* __fmt)
 498 {
 499     return __iom_t10<_CharT>(__tm, __fmt);
 500 }
 501
 502 _LIBCPP_END_NAMESPACE_STD
 503
 504 #endif  // _LIBCPP_IOMANIP