include/c++/stl/stl/_ostream.h

   1 /*
   2  * Copyright (c) 1999
   3  * Silicon Graphics Computer Systems, Inc.
   4  *
   5  * Copyright (c) 1999
   6  * Boris Fomitchev
   7  *
   8  * This material is provided "as is", with absolutely no warranty expressed
   9  * or implied. Any use is at your own risk.
  10  *
  11  * Permission to use or copy this software for any purpose is hereby granted
  12  * without fee, provided the above notices are retained on all copies.
  13  * Permission to modify the code and to distribute modified code is granted,
  14  * provided the above notices are retained, and a notice that the code was
  15  * modified is included with the above copyright notice.
  16  *
  17  */
  18
  19
  20 #ifndef _STLP_INTERNAL_OSTREAM_H
  21 #define _STLP_INTERNAL_OSTREAM_H
  22
  23 #ifndef _STLP_INTERNAL_IOS_H
  24 #  include <stl/_ios.h>                  // For basic_ios<>.  Includes <iosfwd>.
  25 #endif
  26
  27 #ifndef _STLP_INTERNAL_OSTREAMBUF_ITERATOR_H
  28 #  include <stl/_ostreambuf_iterator.h>
  29 #endif
  30
  31 #if !defined (_STLP_NO_UNCAUGHT_EXCEPT_SUPPORT) && !defined (_STLP_INTERNAL_EXCEPTION)
  32 #  include <stl/_exception.h>
  33 #endif
  34
  35 _STLP_BEGIN_NAMESPACE
  36
  37 #if defined (_STLP_USE_TEMPLATE_EXPORT)
  38 template <class _CharT, class _Traits>
  39 class _Osentry;
  40 #endif
  41
  42 _STLP_MOVE_TO_PRIV_NAMESPACE
  43
  44 template <class _CharT, class _Traits>
  45 bool __init_bostr(basic_ostream<_CharT, _Traits>& __str);
  46
  47 _STLP_MOVE_TO_STD_NAMESPACE
  48
  49 //----------------------------------------------------------------------
  50 // class basic_ostream<>
  51
  52 template <class _CharT, class _Traits>
  53 class basic_ostream : virtual public basic_ios<_CharT, _Traits> {
  54   typedef basic_ostream<_CharT, _Traits> _Self;
  55
  56 #if defined (_STLP_MSVC) && (_STLP_MSVC >= 1300 && _STLP_MSVC <= 1310)
  57   //explicitely defined as private to avoid warnings:
  58   basic_ostream(_Self const&);
  59   _Self& operator = (_Self const&);
  60 #endif
  61
  62 public:                         // Types
  63   typedef _CharT                     char_type;
  64   typedef typename _Traits::int_type int_type;
  65   typedef typename _Traits::pos_type pos_type;
  66   typedef typename _Traits::off_type off_type;
  67   typedef _Traits                    traits_type;
  68   typedef basic_ios<_CharT, _Traits> _Basic_ios;
  69
  70 public:                         // Constructor and destructor.
  71   explicit basic_ostream(basic_streambuf<_CharT, _Traits>* __buf);
  72   ~basic_ostream();
  73
  74 public:                         // Hooks for manipulators.
  75   typedef basic_ios<_CharT, _Traits>& (_STLP_CALL *__ios_fn)(basic_ios<_CharT, _Traits>&);
  76   typedef ios_base& (_STLP_CALL *__ios_base_fn)(ios_base&);
  77   typedef _Self& (_STLP_CALL *__ostream_fn)(_Self&);
  78   _Self& operator<< (__ostream_fn __f) { return __f(*this); }
  79   _Self & operator<< (__ios_base_fn __f) { __f(*this); return *this; }
  80   _Self& operator<< (__ios_fn __ff) { __ff(*this); return *this; }
  81
  82 private:
  83   bool _M_copy_buffered(basic_streambuf<_CharT, _Traits>* __from,
  84                         basic_streambuf<_CharT, _Traits>* __to);
  85   bool _M_copy_unbuffered(basic_streambuf<_CharT, _Traits>* __from,
  86                           basic_streambuf<_CharT, _Traits>* __to);
  87
  88 public:
  89   void _M_put_char(_CharT __c);
  90
  91   void _M_put_nowiden(const _CharT* __s);
  92   void _M_put_widen(const char* __s);
  93   bool _M_put_widen_aux(const char* __s, streamsize __n);
  94
  95 public:                         // Unformatted output.
  96   _Self& put(char_type __c);
  97   _Self& write(const char_type* __s, streamsize __n);
  98
  99 public:                         // Formatted output.
 100   // Formatted output from a streambuf.
 101   _Self& operator<<(basic_streambuf<_CharT, _Traits>* __buf);
 102 # ifndef _STLP_NO_FUNCTION_TMPL_PARTIAL_ORDER
 103   // this is needed for compiling with option char = unsigned
 104   _Self& operator<<(unsigned char __x) { _M_put_char(__x); return *this; }
 105 # endif
 106   _Self& operator<<(short __x);
 107   _Self& operator<<(unsigned short __x);
 108   _Self& operator<<(int __x);
 109 #if defined (_WIN64) || !defined (_STLP_MSVC) || (_STLP_MSVC < 1300)
 110   _Self& operator<<(unsigned int __x);
 111 #else
 112 /* We define this operator with size_t rather than unsigned int to avoid
 113  * 64 bits warning.
 114  */
 115   _Self& operator<<(size_t __x);
 116 #endif
 117   _Self& operator<<(long __x);
 118   _Self& operator<<(unsigned long __x);
 119 #ifdef _STLP_LONG_LONG
 120   _Self& operator<< (_STLP_LONG_LONG __x);
 121   _Self& operator<< (unsigned _STLP_LONG_LONG __x);
 122 #endif
 123   _Self& operator<<(float __x);
 124   _Self& operator<<(double __x);
 125 # ifndef _STLP_NO_LONG_DOUBLE
 126   _Self& operator<<(long double __x);
 127 # endif
 128   _Self& operator<<(const void* __x);
 129 # ifndef _STLP_NO_BOOL
 130   _Self& operator<<(bool __x);
 131 # endif
 132
 133 public:                         // Buffer positioning and manipulation.
 134   _Self& flush() {
 135     if (this->rdbuf())
 136       if (this->rdbuf()->pubsync() == -1)
 137         this->setstate(ios_base::badbit);
 138     return *this;
 139   }
 140
 141   pos_type tellp() {
 142     return this->rdbuf() && !this->fail()
 143       ? this->rdbuf()->pubseekoff(0, ios_base::cur, ios_base::out)
 144       : pos_type(-1);
 145   }
 146
 147   _Self& seekp(pos_type __pos) {
 148     if (this->rdbuf() && !this->fail()) {
 149       if (this->rdbuf()->pubseekpos(__pos) == pos_type(-1)) {
 150         this->setstate(ios_base::failbit);
 151       }
 152     }
 153     return *this;
 154   }
 155
 156   _Self& seekp(off_type __off, ios_base::seekdir __dir) {
 157     if (this->rdbuf() && !this->fail())
 158       this->rdbuf()->pubseekoff(__off, __dir);
 159     return *this;
 160   }
 161
 162 #if defined (_STLP_USE_TEMPLATE_EXPORT)
 163   // If we are using DLL specs, we have not to use inner classes
 164   // end class declaration here
 165   typedef _Osentry<_CharT, _Traits>  sentry;
 166 };
 167 #  define sentry _Osentry
 168   template <class _CharT, class _Traits>
 169   class _Osentry {
 170     typedef _Osentry<_CharT, _Traits> _Self;
 171 #else
 172     class sentry {
 173       typedef sentry _Self;
 174 #endif
 175     private:
 176       basic_ostream<_CharT, _Traits>& _M_str;
 177       //      basic_streambuf<_CharT, _Traits>* _M_buf;
 178       bool _M_ok;
 179     public:
 180       explicit sentry(basic_ostream<_CharT, _Traits>& __str)
 181         : _M_str(__str), /* _M_buf(__str.rdbuf()), */ _M_ok(_STLP_PRIV __init_bostr(__str))
 182       {}
 183
 184       ~sentry() {
 185         if (_M_str.flags() & ios_base::unitbuf)
 186 #if !defined (_STLP_NO_UNCAUGHT_EXCEPT_SUPPORT)
 187           if (!uncaught_exception())
 188 #endif
 189             _M_str.flush();
 190       }
 191
 192       operator bool() const { return _M_ok; }
 193     private:                        // Disable assignment and copy constructor.
 194       //Implementation is here only to avoid warning with some compilers.
 195       sentry(const _Self& __s) : _M_str(__s._M_str) {}
 196       _Self& operator=(const _Self&) { return *this; }
 197     };
 198 #if defined (_STLP_USE_TEMPLATE_EXPORT)
 199 #  undef sentry
 200 #else
 201   // close basic_ostream class definition here
 202 };
 203 #endif
 204
 205 #if defined (_STLP_USE_TEMPLATE_EXPORT)
 206 _STLP_EXPORT_TEMPLATE_CLASS basic_ostream<char, char_traits<char> >;
 207 _STLP_EXPORT_TEMPLATE_CLASS _Osentry<char, char_traits<char> >;
 208 #  if !defined (_STLP_NO_WCHAR_T)
 209 _STLP_EXPORT_TEMPLATE_CLASS basic_ostream<wchar_t, char_traits<wchar_t> >;
 210 _STLP_EXPORT_TEMPLATE_CLASS _Osentry<wchar_t, char_traits<wchar_t> >;
 211 #  endif
 212 #endif /* _STLP_USE_TEMPLATE_EXPORT */
 213
 214 _STLP_MOVE_TO_PRIV_NAMESPACE
 215
 216 // Helper functions for istream<>::sentry constructor.
 217 template <class _CharT, class _Traits>
 218 bool __init_bostr(basic_ostream<_CharT, _Traits>& __str) {
 219   if (__str.good()) {
 220     // boris : check if this is needed !
 221     if (!__str.rdbuf())
 222       __str.setstate(ios_base::badbit);
 223     if (__str.tie())
 224       __str.tie()->flush();
 225     return __str.good();
 226   }
 227   else
 228     return false;
 229 }
 230
 231 template <class _CharT, class _Traits>
 232 inline basic_streambuf<_CharT, _Traits>* _STLP_CALL
 233 __get_ostreambuf(basic_ostream<_CharT, _Traits>& __St)
 234 { return __St.rdbuf(); }
 235
 236 _STLP_MOVE_TO_STD_NAMESPACE
 237
 238 // Non-member functions.
 239 template <class _CharT, class _Traits>
 240 inline basic_ostream<_CharT, _Traits>& _STLP_CALL
 241 operator<<(basic_ostream<_CharT, _Traits>& __os, _CharT __c){
 242   __os._M_put_char(__c);
 243   return __os;
 244 }
 245
 246 template <class _CharT, class _Traits>
 247 inline basic_ostream<_CharT, _Traits>& _STLP_CALL
 248 operator<<(basic_ostream<_CharT, _Traits>& __os, const _CharT* __s) {
 249   __os._M_put_nowiden(__s);
 250   return __os;
 251 }
 252
 253 #if defined (_STLP_NO_FUNCTION_TMPL_PARTIAL_ORDER)
 254 // some specializations
 255
 256 inline basic_ostream<char, char_traits<char> >& _STLP_CALL
 257 operator<<(basic_ostream<char, char_traits<char> >& __os, char __c) {
 258   __os._M_put_char(__c);
 259   return __os;
 260 }
 261
 262 inline basic_ostream<char, char_traits<char> >& _STLP_CALL
 263 operator<<(basic_ostream<char, char_traits<char> >& __os, signed char __c) {
 264   __os._M_put_char(__c);
 265   return __os;
 266 }
 267
 268 inline basic_ostream<char, char_traits<char> >& _STLP_CALL
 269 operator<<(basic_ostream<char, char_traits<char> >& __os, unsigned char __c) {
 270   __os._M_put_char(__c);
 271   return __os;
 272 }
 273
 274 inline basic_ostream<char, char_traits<char> >& _STLP_CALL
 275 operator<<(basic_ostream<char, char_traits<char> >& __os, const char* __s) {
 276   __os._M_put_nowiden(__s);
 277   return __os;
 278 }
 279
 280 inline basic_ostream<char, char_traits<char> >& _STLP_CALL
 281 operator<<(basic_ostream<char, char_traits<char> >& __os, const signed char* __s) {
 282   __os._M_put_nowiden(__REINTERPRET_CAST(const char*,__s));
 283   return __os;
 284 }
 285
 286 inline basic_ostream<char, char_traits<char> >&
 287 operator<<(basic_ostream<char, char_traits<char> >& __os, const unsigned char* __s) {
 288   __os._M_put_nowiden(__REINTERPRET_CAST(const char*,__s));
 289   return __os;
 290 }
 291
 292 #else
 293
 294 // also for compilers who might use that
 295 template <class _CharT, class _Traits>
 296 inline basic_ostream<_CharT, _Traits>& _STLP_CALL
 297 operator<<(basic_ostream<_CharT, _Traits>& __os, char __c) {
 298   __os._M_put_char(__os.widen(__c));
 299   return __os;
 300 }
 301
 302 template <class _Traits>
 303 inline basic_ostream<char, _Traits>& _STLP_CALL
 304 operator<<(basic_ostream<char, _Traits>& __os, char __c) {
 305   __os._M_put_char(__c);
 306   return __os;
 307 }
 308
 309 template <class _Traits>
 310 inline basic_ostream<char, _Traits>& _STLP_CALL
 311 operator<<(basic_ostream<char, _Traits>& __os, signed char __c) {
 312   __os._M_put_char(__c);
 313   return __os;
 314 }
 315
 316 template <class _Traits>
 317 inline basic_ostream<char, _Traits>& _STLP_CALL
 318 operator<<(basic_ostream<char, _Traits>& __os, unsigned char __c) {
 319   __os._M_put_char(__c);
 320   return __os;
 321 }
 322
 323 template <class _CharT, class _Traits>
 324 inline basic_ostream<_CharT, _Traits>& _STLP_CALL
 325 operator<<(basic_ostream<_CharT, _Traits>& __os, const char* __s) {
 326   __os._M_put_widen(__s);
 327   return __os;
 328 }
 329
 330 template <class _Traits>
 331 inline basic_ostream<char, _Traits>& _STLP_CALL
 332 operator<<(basic_ostream<char, _Traits>& __os, const char* __s) {
 333   __os._M_put_nowiden(__s);
 334   return __os;
 335 }
 336
 337 template <class _Traits>
 338 inline basic_ostream<char, _Traits>& _STLP_CALL
 339 operator<<(basic_ostream<char, _Traits>& __os, const signed char* __s) {
 340   __os._M_put_nowiden(__REINTERPRET_CAST(const char*,__s));
 341   return __os;
 342 }
 343
 344 template <class _Traits>
 345 inline basic_ostream<char, _Traits>&
 346 operator<<(basic_ostream<char, _Traits>& __os, const unsigned char* __s) {
 347   __os._M_put_nowiden(__REINTERPRET_CAST(const char*,__s));
 348   return __os;
 349 }
 350 #endif /* _STLP_NO_FUNCTION_TMPL_PARTIAL_ORDER */
 351
 352 //----------------------------------------------------------------------
 353 // basic_ostream manipulators.
 354
 355 template <class _CharT, class _Traits>
 356 inline basic_ostream<_CharT, _Traits>& _STLP_CALL
 357 endl(basic_ostream<_CharT, _Traits>& __os) {
 358   __os.put(__os.widen('\n'));
 359   __os.flush();
 360   return __os;
 361 }
 362
 363 template <class _CharT, class _Traits>
 364 inline basic_ostream<_CharT, _Traits>& _STLP_CALL
 365 ends(basic_ostream<_CharT, _Traits>& __os) {
 366   __os.put(_STLP_DEFAULT_CONSTRUCTED(_CharT));
 367   return __os;
 368 }
 369
 370 template <class _CharT, class _Traits>
 371 inline basic_ostream<_CharT, _Traits>& _STLP_CALL
 372 flush(basic_ostream<_CharT, _Traits>& __os) {
 373   __os.flush();
 374   return __os;
 375 }
 376
 377 _STLP_END_NAMESPACE
 378
 379 #if defined (_STLP_EXPOSE_STREAM_IMPLEMENTATION) && !defined (_STLP_LINK_TIME_INSTANTIATION)
 380 #  include <stl/_ostream.c>
 381 #endif
 382
 383 #endif /* _STLP_INTERNAL_OSTREAM_H */
 384
 385 // Local Variables:
 386 // mode:C++
 387 // End: