1287 lines
38 KiB
C++
1287 lines
38 KiB
C++
// -*- C++ -*-
|
|
//===-------------------------- ostream -----------------------------------===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is dual licensed under the MIT and the University of Illinois Open
|
|
// Source Licenses. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef _LIBCPP_OSTREAM
|
|
#define _LIBCPP_OSTREAM
|
|
|
|
/*
|
|
ostream synopsis
|
|
|
|
template <class charT, class traits = char_traits<charT> >
|
|
class basic_ostream
|
|
: virtual public basic_ios<charT,traits>
|
|
{
|
|
public:
|
|
// types (inherited from basic_ios (27.5.4)):
|
|
typedef charT char_type;
|
|
typedef traits traits_type;
|
|
typedef typename traits_type::int_type int_type;
|
|
typedef typename traits_type::pos_type pos_type;
|
|
typedef typename traits_type::off_type off_type;
|
|
|
|
// 27.7.2.2 Constructor/destructor:
|
|
explicit basic_ostream(basic_streambuf<char_type,traits>* sb);
|
|
basic_ostream(basic_ostream&& rhs);
|
|
virtual ~basic_ostream();
|
|
|
|
// 27.7.2.3 Assign/swap
|
|
basic_ostream& operator=(basic_ostream&& rhs);
|
|
void swap(basic_ostream& rhs);
|
|
|
|
// 27.7.2.4 Prefix/suffix:
|
|
class sentry;
|
|
|
|
// 27.7.2.6 Formatted output:
|
|
basic_ostream& operator<<(basic_ostream& (*pf)(basic_ostream&));
|
|
basic_ostream& operator<<(basic_ios<charT, traits>& (*pf)(basic_ios<charT,traits>&));
|
|
basic_ostream& operator<<(ios_base& (*pf)(ios_base&));
|
|
basic_ostream& operator<<(bool n);
|
|
basic_ostream& operator<<(short n);
|
|
basic_ostream& operator<<(unsigned short n);
|
|
basic_ostream& operator<<(int n);
|
|
basic_ostream& operator<<(unsigned int n);
|
|
basic_ostream& operator<<(long n);
|
|
basic_ostream& operator<<(unsigned long n);
|
|
basic_ostream& operator<<(long long n);
|
|
basic_ostream& operator<<(unsigned long long n);
|
|
basic_ostream& operator<<(float f);
|
|
basic_ostream& operator<<(double f);
|
|
basic_ostream& operator<<(long double f);
|
|
basic_ostream& operator<<(const void* p);
|
|
basic_ostream& operator<<(basic_streambuf<char_type,traits>* sb);
|
|
|
|
// 27.7.2.7 Unformatted output:
|
|
basic_ostream& put(char_type c);
|
|
basic_ostream& write(const char_type* s, streamsize n);
|
|
basic_ostream& flush();
|
|
|
|
// 27.7.2.5 seeks:
|
|
pos_type tellp();
|
|
basic_ostream& seekp(pos_type);
|
|
basic_ostream& seekp(off_type, ios_base::seekdir);
|
|
};
|
|
|
|
// 27.7.2.6.4 character inserters
|
|
|
|
template<class charT, class traits>
|
|
basic_ostream<charT,traits>& operator<<(basic_ostream<charT,traits>&, charT);
|
|
|
|
template<class charT, class traits>
|
|
basic_ostream<charT,traits>& operator<<(basic_ostream<charT,traits>&, char);
|
|
|
|
template<class traits>
|
|
basic_ostream<char,traits>& operator<<(basic_ostream<char,traits>&, char);
|
|
|
|
// signed and unsigned
|
|
|
|
template<class traits>
|
|
basic_ostream<char,traits>& operator<<(basic_ostream<char,traits>&, signed char);
|
|
|
|
template<class traits>
|
|
basic_ostream<char,traits>& operator<<(basic_ostream<char,traits>&, unsigned char);
|
|
|
|
// NTBS
|
|
template<class charT, class traits>
|
|
basic_ostream<charT,traits>& operator<<(basic_ostream<charT,traits>&, const charT*);
|
|
|
|
template<class charT, class traits>
|
|
basic_ostream<charT,traits>& operator<<(basic_ostream<charT,traits>&, const char*);
|
|
|
|
template<class traits>
|
|
basic_ostream<char,traits>& operator<<(basic_ostream<char,traits>&, const char*);
|
|
|
|
// signed and unsigned
|
|
template<class traits>
|
|
basic_ostream<char,traits>& operator<<(basic_ostream<char,traits>&, const signed char*);
|
|
|
|
template<class traits>
|
|
basic_ostream<char,traits>& operator<<(basic_ostream<char,traits>&, const unsigned char*);
|
|
|
|
// swap:
|
|
template <class charT, class traits>
|
|
void swap(basic_ostream<charT, traits>& x, basic_ostream<charT, traits>& y);
|
|
|
|
template <class charT, class traits>
|
|
basic_ostream<charT,traits>& endl(basic_ostream<charT,traits>& os);
|
|
|
|
template <class charT, class traits>
|
|
basic_ostream<charT,traits>& ends(basic_ostream<charT,traits>& os);
|
|
|
|
template <class charT, class traits>
|
|
basic_ostream<charT,traits>& flush(basic_ostream<charT,traits>& os);
|
|
|
|
// rvalue stream insertion
|
|
template <class charT, class traits, class T>
|
|
basic_ostream<charT, traits>&
|
|
operator<<(basic_ostream<charT, traits>&& os, const T& x);
|
|
|
|
} // std
|
|
|
|
*/
|
|
|
|
#include <__config>
|
|
#include <ios>
|
|
#include <streambuf>
|
|
#include <locale>
|
|
#include <iterator>
|
|
#include <bitset>
|
|
|
|
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
|
#pragma GCC system_header
|
|
#endif
|
|
|
|
_LIBCPP_BEGIN_NAMESPACE_STD
|
|
|
|
template <class _CharT, class _Traits>
|
|
class _LIBCPP_TYPE_VIS basic_ostream
|
|
: virtual public basic_ios<_CharT, _Traits>
|
|
{
|
|
public:
|
|
// types (inherited from basic_ios (27.5.4)):
|
|
typedef _CharT char_type;
|
|
typedef _Traits traits_type;
|
|
typedef typename traits_type::int_type int_type;
|
|
typedef typename traits_type::pos_type pos_type;
|
|
typedef typename traits_type::off_type off_type;
|
|
|
|
// 27.7.2.2 Constructor/destructor:
|
|
explicit basic_ostream(basic_streambuf<char_type, traits_type>* __sb);
|
|
virtual ~basic_ostream();
|
|
protected:
|
|
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
basic_ostream(basic_ostream&& __rhs);
|
|
#endif
|
|
|
|
// 27.7.2.3 Assign/swap
|
|
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
basic_ostream& operator=(basic_ostream&& __rhs);
|
|
#endif
|
|
void swap(basic_ostream& __rhs);
|
|
public:
|
|
|
|
// 27.7.2.4 Prefix/suffix:
|
|
class _LIBCPP_TYPE_VIS sentry;
|
|
|
|
// 27.7.2.6 Formatted output:
|
|
basic_ostream& operator<<(basic_ostream& (*__pf)(basic_ostream&));
|
|
basic_ostream& operator<<(basic_ios<char_type, traits_type>&
|
|
(*__pf)(basic_ios<char_type,traits_type>&));
|
|
basic_ostream& operator<<(ios_base& (*__pf)(ios_base&));
|
|
basic_ostream& operator<<(bool __n);
|
|
basic_ostream& operator<<(short __n);
|
|
basic_ostream& operator<<(unsigned short __n);
|
|
basic_ostream& operator<<(int __n);
|
|
basic_ostream& operator<<(unsigned int __n);
|
|
basic_ostream& operator<<(long __n);
|
|
basic_ostream& operator<<(unsigned long __n);
|
|
basic_ostream& operator<<(long long __n);
|
|
basic_ostream& operator<<(unsigned long long __n);
|
|
basic_ostream& operator<<(float __f);
|
|
basic_ostream& operator<<(double __f);
|
|
basic_ostream& operator<<(long double __f);
|
|
basic_ostream& operator<<(const void* __p);
|
|
basic_ostream& operator<<(basic_streambuf<char_type, traits_type>* __sb);
|
|
|
|
// 27.7.2.7 Unformatted output:
|
|
basic_ostream& put(char_type __c);
|
|
basic_ostream& write(const char_type* __s, streamsize __n);
|
|
basic_ostream& flush();
|
|
|
|
// 27.7.2.5 seeks:
|
|
pos_type tellp();
|
|
basic_ostream& seekp(pos_type __pos);
|
|
basic_ostream& seekp(off_type __off, ios_base::seekdir __dir);
|
|
|
|
protected:
|
|
_LIBCPP_ALWAYS_INLINE
|
|
basic_ostream() {} // extension, intentially does not initialize
|
|
};
|
|
|
|
template <class _CharT, class _Traits>
|
|
class _LIBCPP_TYPE_VIS basic_ostream<_CharT, _Traits>::sentry
|
|
{
|
|
bool __ok_;
|
|
basic_ostream<_CharT, _Traits>& __os_;
|
|
|
|
sentry(const sentry&); // = delete;
|
|
sentry& operator=(const sentry&); // = delete;
|
|
|
|
public:
|
|
explicit sentry(basic_ostream<_CharT, _Traits>& __os);
|
|
~sentry();
|
|
|
|
_LIBCPP_ALWAYS_INLINE
|
|
_LIBCPP_EXPLICIT
|
|
operator bool() const {return __ok_;}
|
|
};
|
|
|
|
template <class _CharT, class _Traits>
|
|
basic_ostream<_CharT, _Traits>::sentry::sentry(basic_ostream<_CharT, _Traits>& __os)
|
|
: __ok_(false),
|
|
__os_(__os)
|
|
{
|
|
if (__os.good())
|
|
{
|
|
if (__os.tie())
|
|
__os.tie()->flush();
|
|
__ok_ = true;
|
|
}
|
|
}
|
|
|
|
template <class _CharT, class _Traits>
|
|
basic_ostream<_CharT, _Traits>::sentry::~sentry()
|
|
{
|
|
if (__os_.rdbuf() && __os_.good() && (__os_.flags() & ios_base::unitbuf)
|
|
&& !uncaught_exception())
|
|
{
|
|
#ifndef _LIBCPP_NO_EXCEPTIONS
|
|
try
|
|
{
|
|
#endif // _LIBCPP_NO_EXCEPTIONS
|
|
if (__os_.rdbuf()->pubsync() == -1)
|
|
__os_.setstate(ios_base::badbit);
|
|
#ifndef _LIBCPP_NO_EXCEPTIONS
|
|
}
|
|
catch (...)
|
|
{
|
|
}
|
|
#endif // _LIBCPP_NO_EXCEPTIONS
|
|
}
|
|
}
|
|
|
|
template <class _CharT, class _Traits>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
basic_ostream<_CharT, _Traits>::basic_ostream(basic_streambuf<char_type, traits_type>* __sb)
|
|
{
|
|
this->init(__sb);
|
|
}
|
|
|
|
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
|
|
|
template <class _CharT, class _Traits>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
basic_ostream<_CharT, _Traits>::basic_ostream(basic_ostream&& __rhs)
|
|
{
|
|
this->move(__rhs);
|
|
}
|
|
|
|
template <class _CharT, class _Traits>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
basic_ostream<_CharT, _Traits>&
|
|
basic_ostream<_CharT, _Traits>::operator=(basic_ostream&& __rhs)
|
|
{
|
|
swap(__rhs);
|
|
return *this;
|
|
}
|
|
|
|
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
|
|
|
template <class _CharT, class _Traits>
|
|
basic_ostream<_CharT, _Traits>::~basic_ostream()
|
|
{
|
|
}
|
|
|
|
template <class _CharT, class _Traits>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
void
|
|
basic_ostream<_CharT, _Traits>::swap(basic_ostream& __rhs)
|
|
{
|
|
basic_ios<char_type, traits_type>::swap(__rhs);
|
|
}
|
|
|
|
template <class _CharT, class _Traits>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
basic_ostream<_CharT, _Traits>&
|
|
basic_ostream<_CharT, _Traits>::operator<<(basic_ostream& (*__pf)(basic_ostream&))
|
|
{
|
|
return __pf(*this);
|
|
}
|
|
|
|
template <class _CharT, class _Traits>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
basic_ostream<_CharT, _Traits>&
|
|
basic_ostream<_CharT, _Traits>::operator<<(basic_ios<char_type, traits_type>&
|
|
(*__pf)(basic_ios<char_type,traits_type>&))
|
|
{
|
|
__pf(*this);
|
|
return *this;
|
|
}
|
|
|
|
template <class _CharT, class _Traits>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
basic_ostream<_CharT, _Traits>&
|
|
basic_ostream<_CharT, _Traits>::operator<<(ios_base& (*__pf)(ios_base&))
|
|
{
|
|
__pf(*this);
|
|
return *this;
|
|
}
|
|
|
|
template <class _CharT, class _Traits>
|
|
basic_ostream<_CharT, _Traits>&
|
|
basic_ostream<_CharT, _Traits>::operator<<(basic_streambuf<char_type, traits_type>* __sb)
|
|
{
|
|
#ifndef _LIBCPP_NO_EXCEPTIONS
|
|
try
|
|
{
|
|
#endif // _LIBCPP_NO_EXCEPTIONS
|
|
sentry __s(*this);
|
|
if (__s)
|
|
{
|
|
if (__sb)
|
|
{
|
|
#ifndef _LIBCPP_NO_EXCEPTIONS
|
|
try
|
|
{
|
|
#endif // _LIBCPP_NO_EXCEPTIONS
|
|
typedef istreambuf_iterator<_CharT, _Traits> _Ip;
|
|
typedef ostreambuf_iterator<_CharT, _Traits> _Op;
|
|
_Ip __i(__sb);
|
|
_Ip __eof;
|
|
_Op __o(*this);
|
|
size_t __c = 0;
|
|
for (; __i != __eof; ++__i, ++__o, ++__c)
|
|
{
|
|
*__o = *__i;
|
|
if (__o.failed())
|
|
break;
|
|
}
|
|
if (__c == 0)
|
|
this->setstate(ios_base::failbit);
|
|
#ifndef _LIBCPP_NO_EXCEPTIONS
|
|
}
|
|
catch (...)
|
|
{
|
|
this->__set_failbit_and_consider_rethrow();
|
|
}
|
|
#endif // _LIBCPP_NO_EXCEPTIONS
|
|
}
|
|
else
|
|
this->setstate(ios_base::badbit);
|
|
}
|
|
#ifndef _LIBCPP_NO_EXCEPTIONS
|
|
}
|
|
catch (...)
|
|
{
|
|
this->__set_badbit_and_consider_rethrow();
|
|
}
|
|
#endif // _LIBCPP_NO_EXCEPTIONS
|
|
return *this;
|
|
}
|
|
|
|
template <class _CharT, class _Traits>
|
|
basic_ostream<_CharT, _Traits>&
|
|
basic_ostream<_CharT, _Traits>::operator<<(bool __n)
|
|
{
|
|
#ifndef _LIBCPP_NO_EXCEPTIONS
|
|
try
|
|
{
|
|
#endif // _LIBCPP_NO_EXCEPTIONS
|
|
sentry __s(*this);
|
|
if (__s)
|
|
{
|
|
typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
|
|
const _Fp& __f = use_facet<_Fp>(this->getloc());
|
|
if (__f.put(*this, *this, this->fill(), __n).failed())
|
|
this->setstate(ios_base::badbit | ios_base::failbit);
|
|
}
|
|
#ifndef _LIBCPP_NO_EXCEPTIONS
|
|
}
|
|
catch (...)
|
|
{
|
|
this->__set_badbit_and_consider_rethrow();
|
|
}
|
|
#endif // _LIBCPP_NO_EXCEPTIONS
|
|
return *this;
|
|
}
|
|
|
|
template <class _CharT, class _Traits>
|
|
basic_ostream<_CharT, _Traits>&
|
|
basic_ostream<_CharT, _Traits>::operator<<(short __n)
|
|
{
|
|
#ifndef _LIBCPP_NO_EXCEPTIONS
|
|
try
|
|
{
|
|
#endif // _LIBCPP_NO_EXCEPTIONS
|
|
sentry __s(*this);
|
|
if (__s)
|
|
{
|
|
ios_base::fmtflags __flags = ios_base::flags() & ios_base::basefield;
|
|
typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
|
|
const _Fp& __f = use_facet<_Fp>(this->getloc());
|
|
if (__f.put(*this, *this, this->fill(),
|
|
__flags == ios_base::oct || __flags == ios_base::hex ?
|
|
static_cast<long>(static_cast<unsigned short>(__n)) :
|
|
static_cast<long>(__n)).failed())
|
|
this->setstate(ios_base::badbit | ios_base::failbit);
|
|
}
|
|
#ifndef _LIBCPP_NO_EXCEPTIONS
|
|
}
|
|
catch (...)
|
|
{
|
|
this->__set_badbit_and_consider_rethrow();
|
|
}
|
|
#endif // _LIBCPP_NO_EXCEPTIONS
|
|
return *this;
|
|
}
|
|
|
|
template <class _CharT, class _Traits>
|
|
basic_ostream<_CharT, _Traits>&
|
|
basic_ostream<_CharT, _Traits>::operator<<(unsigned short __n)
|
|
{
|
|
#ifndef _LIBCPP_NO_EXCEPTIONS
|
|
try
|
|
{
|
|
#endif // _LIBCPP_NO_EXCEPTIONS
|
|
sentry __s(*this);
|
|
if (__s)
|
|
{
|
|
typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
|
|
const _Fp& __f = use_facet<_Fp>(this->getloc());
|
|
if (__f.put(*this, *this, this->fill(), static_cast<unsigned long>(__n)).failed())
|
|
this->setstate(ios_base::badbit | ios_base::failbit);
|
|
}
|
|
#ifndef _LIBCPP_NO_EXCEPTIONS
|
|
}
|
|
catch (...)
|
|
{
|
|
this->__set_badbit_and_consider_rethrow();
|
|
}
|
|
#endif // _LIBCPP_NO_EXCEPTIONS
|
|
return *this;
|
|
}
|
|
|
|
template <class _CharT, class _Traits>
|
|
basic_ostream<_CharT, _Traits>&
|
|
basic_ostream<_CharT, _Traits>::operator<<(int __n)
|
|
{
|
|
#ifndef _LIBCPP_NO_EXCEPTIONS
|
|
try
|
|
{
|
|
#endif // _LIBCPP_NO_EXCEPTIONS
|
|
sentry __s(*this);
|
|
if (__s)
|
|
{
|
|
ios_base::fmtflags __flags = ios_base::flags() & ios_base::basefield;
|
|
typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
|
|
const _Fp& __f = use_facet<_Fp>(this->getloc());
|
|
if (__f.put(*this, *this, this->fill(),
|
|
__flags == ios_base::oct || __flags == ios_base::hex ?
|
|
static_cast<long>(static_cast<unsigned int>(__n)) :
|
|
static_cast<long>(__n)).failed())
|
|
this->setstate(ios_base::badbit | ios_base::failbit);
|
|
}
|
|
#ifndef _LIBCPP_NO_EXCEPTIONS
|
|
}
|
|
catch (...)
|
|
{
|
|
this->__set_badbit_and_consider_rethrow();
|
|
}
|
|
#endif // _LIBCPP_NO_EXCEPTIONS
|
|
return *this;
|
|
}
|
|
|
|
template <class _CharT, class _Traits>
|
|
basic_ostream<_CharT, _Traits>&
|
|
basic_ostream<_CharT, _Traits>::operator<<(unsigned int __n)
|
|
{
|
|
#ifndef _LIBCPP_NO_EXCEPTIONS
|
|
try
|
|
{
|
|
#endif // _LIBCPP_NO_EXCEPTIONS
|
|
sentry __s(*this);
|
|
if (__s)
|
|
{
|
|
typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
|
|
const _Fp& __f = use_facet<_Fp>(this->getloc());
|
|
if (__f.put(*this, *this, this->fill(), static_cast<unsigned long>(__n)).failed())
|
|
this->setstate(ios_base::badbit | ios_base::failbit);
|
|
}
|
|
#ifndef _LIBCPP_NO_EXCEPTIONS
|
|
}
|
|
catch (...)
|
|
{
|
|
this->__set_badbit_and_consider_rethrow();
|
|
}
|
|
#endif // _LIBCPP_NO_EXCEPTIONS
|
|
return *this;
|
|
}
|
|
|
|
template <class _CharT, class _Traits>
|
|
basic_ostream<_CharT, _Traits>&
|
|
basic_ostream<_CharT, _Traits>::operator<<(long __n)
|
|
{
|
|
#ifndef _LIBCPP_NO_EXCEPTIONS
|
|
try
|
|
{
|
|
#endif // _LIBCPP_NO_EXCEPTIONS
|
|
sentry __s(*this);
|
|
if (__s)
|
|
{
|
|
typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
|
|
const _Fp& __f = use_facet<_Fp>(this->getloc());
|
|
if (__f.put(*this, *this, this->fill(), __n).failed())
|
|
this->setstate(ios_base::badbit | ios_base::failbit);
|
|
}
|
|
#ifndef _LIBCPP_NO_EXCEPTIONS
|
|
}
|
|
catch (...)
|
|
{
|
|
this->__set_badbit_and_consider_rethrow();
|
|
}
|
|
#endif // _LIBCPP_NO_EXCEPTIONS
|
|
return *this;
|
|
}
|
|
|
|
template <class _CharT, class _Traits>
|
|
basic_ostream<_CharT, _Traits>&
|
|
basic_ostream<_CharT, _Traits>::operator<<(unsigned long __n)
|
|
{
|
|
#ifndef _LIBCPP_NO_EXCEPTIONS
|
|
try
|
|
{
|
|
#endif // _LIBCPP_NO_EXCEPTIONS
|
|
sentry __s(*this);
|
|
if (__s)
|
|
{
|
|
typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
|
|
const _Fp& __f = use_facet<_Fp>(this->getloc());
|
|
if (__f.put(*this, *this, this->fill(), __n).failed())
|
|
this->setstate(ios_base::badbit | ios_base::failbit);
|
|
}
|
|
#ifndef _LIBCPP_NO_EXCEPTIONS
|
|
}
|
|
catch (...)
|
|
{
|
|
this->__set_badbit_and_consider_rethrow();
|
|
}
|
|
#endif // _LIBCPP_NO_EXCEPTIONS
|
|
return *this;
|
|
}
|
|
|
|
template <class _CharT, class _Traits>
|
|
basic_ostream<_CharT, _Traits>&
|
|
basic_ostream<_CharT, _Traits>::operator<<(long long __n)
|
|
{
|
|
#ifndef _LIBCPP_NO_EXCEPTIONS
|
|
try
|
|
{
|
|
#endif // _LIBCPP_NO_EXCEPTIONS
|
|
sentry __s(*this);
|
|
if (__s)
|
|
{
|
|
typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
|
|
const _Fp& __f = use_facet<_Fp>(this->getloc());
|
|
if (__f.put(*this, *this, this->fill(), __n).failed())
|
|
this->setstate(ios_base::badbit | ios_base::failbit);
|
|
}
|
|
#ifndef _LIBCPP_NO_EXCEPTIONS
|
|
}
|
|
catch (...)
|
|
{
|
|
this->__set_badbit_and_consider_rethrow();
|
|
}
|
|
#endif // _LIBCPP_NO_EXCEPTIONS
|
|
return *this;
|
|
}
|
|
|
|
template <class _CharT, class _Traits>
|
|
basic_ostream<_CharT, _Traits>&
|
|
basic_ostream<_CharT, _Traits>::operator<<(unsigned long long __n)
|
|
{
|
|
#ifndef _LIBCPP_NO_EXCEPTIONS
|
|
try
|
|
{
|
|
#endif // _LIBCPP_NO_EXCEPTIONS
|
|
sentry __s(*this);
|
|
if (__s)
|
|
{
|
|
typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
|
|
const _Fp& __f = use_facet<_Fp>(this->getloc());
|
|
if (__f.put(*this, *this, this->fill(), __n).failed())
|
|
this->setstate(ios_base::badbit | ios_base::failbit);
|
|
}
|
|
#ifndef _LIBCPP_NO_EXCEPTIONS
|
|
}
|
|
catch (...)
|
|
{
|
|
this->__set_badbit_and_consider_rethrow();
|
|
}
|
|
#endif // _LIBCPP_NO_EXCEPTIONS
|
|
return *this;
|
|
}
|
|
|
|
template <class _CharT, class _Traits>
|
|
basic_ostream<_CharT, _Traits>&
|
|
basic_ostream<_CharT, _Traits>::operator<<(float __n)
|
|
{
|
|
#ifndef _LIBCPP_NO_EXCEPTIONS
|
|
try
|
|
{
|
|
#endif // _LIBCPP_NO_EXCEPTIONS
|
|
sentry __s(*this);
|
|
if (__s)
|
|
{
|
|
typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
|
|
const _Fp& __f = use_facet<_Fp>(this->getloc());
|
|
if (__f.put(*this, *this, this->fill(), static_cast<double>(__n)).failed())
|
|
this->setstate(ios_base::badbit | ios_base::failbit);
|
|
}
|
|
#ifndef _LIBCPP_NO_EXCEPTIONS
|
|
}
|
|
catch (...)
|
|
{
|
|
this->__set_badbit_and_consider_rethrow();
|
|
}
|
|
#endif // _LIBCPP_NO_EXCEPTIONS
|
|
return *this;
|
|
}
|
|
|
|
template <class _CharT, class _Traits>
|
|
basic_ostream<_CharT, _Traits>&
|
|
basic_ostream<_CharT, _Traits>::operator<<(double __n)
|
|
{
|
|
#ifndef _LIBCPP_NO_EXCEPTIONS
|
|
try
|
|
{
|
|
#endif // _LIBCPP_NO_EXCEPTIONS
|
|
sentry __s(*this);
|
|
if (__s)
|
|
{
|
|
typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
|
|
const _Fp& __f = use_facet<_Fp>(this->getloc());
|
|
if (__f.put(*this, *this, this->fill(), __n).failed())
|
|
this->setstate(ios_base::badbit | ios_base::failbit);
|
|
}
|
|
#ifndef _LIBCPP_NO_EXCEPTIONS
|
|
}
|
|
catch (...)
|
|
{
|
|
this->__set_badbit_and_consider_rethrow();
|
|
}
|
|
#endif // _LIBCPP_NO_EXCEPTIONS
|
|
return *this;
|
|
}
|
|
|
|
template <class _CharT, class _Traits>
|
|
basic_ostream<_CharT, _Traits>&
|
|
basic_ostream<_CharT, _Traits>::operator<<(long double __n)
|
|
{
|
|
#ifndef _LIBCPP_NO_EXCEPTIONS
|
|
try
|
|
{
|
|
#endif // _LIBCPP_NO_EXCEPTIONS
|
|
sentry __s(*this);
|
|
if (__s)
|
|
{
|
|
typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
|
|
const _Fp& __f = use_facet<_Fp>(this->getloc());
|
|
if (__f.put(*this, *this, this->fill(), __n).failed())
|
|
this->setstate(ios_base::badbit | ios_base::failbit);
|
|
}
|
|
#ifndef _LIBCPP_NO_EXCEPTIONS
|
|
}
|
|
catch (...)
|
|
{
|
|
this->__set_badbit_and_consider_rethrow();
|
|
}
|
|
#endif // _LIBCPP_NO_EXCEPTIONS
|
|
return *this;
|
|
}
|
|
|
|
template <class _CharT, class _Traits>
|
|
basic_ostream<_CharT, _Traits>&
|
|
basic_ostream<_CharT, _Traits>::operator<<(const void* __n)
|
|
{
|
|
#ifndef _LIBCPP_NO_EXCEPTIONS
|
|
try
|
|
{
|
|
#endif // _LIBCPP_NO_EXCEPTIONS
|
|
sentry __s(*this);
|
|
if (__s)
|
|
{
|
|
typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
|
|
const _Fp& __f = use_facet<_Fp>(this->getloc());
|
|
if (__f.put(*this, *this, this->fill(), __n).failed())
|
|
this->setstate(ios_base::badbit | ios_base::failbit);
|
|
}
|
|
#ifndef _LIBCPP_NO_EXCEPTIONS
|
|
}
|
|
catch (...)
|
|
{
|
|
this->__set_badbit_and_consider_rethrow();
|
|
}
|
|
#endif // _LIBCPP_NO_EXCEPTIONS
|
|
return *this;
|
|
}
|
|
|
|
template<class _CharT, class _Traits>
|
|
basic_ostream<_CharT, _Traits>&
|
|
operator<<(basic_ostream<_CharT, _Traits>& __os, _CharT __c)
|
|
{
|
|
#ifndef _LIBCPP_NO_EXCEPTIONS
|
|
try
|
|
{
|
|
#endif // _LIBCPP_NO_EXCEPTIONS
|
|
typename basic_ostream<_CharT, _Traits>::sentry __s(__os);
|
|
if (__s)
|
|
{
|
|
typedef ostreambuf_iterator<_CharT, _Traits> _Ip;
|
|
if (__pad_and_output(_Ip(__os),
|
|
&__c,
|
|
(__os.flags() & ios_base::adjustfield) == ios_base::left ?
|
|
&__c + 1 :
|
|
&__c,
|
|
&__c + 1,
|
|
__os,
|
|
__os.fill()).failed())
|
|
__os.setstate(ios_base::badbit | ios_base::failbit);
|
|
}
|
|
#ifndef _LIBCPP_NO_EXCEPTIONS
|
|
}
|
|
catch (...)
|
|
{
|
|
__os.__set_badbit_and_consider_rethrow();
|
|
}
|
|
#endif // _LIBCPP_NO_EXCEPTIONS
|
|
return __os;
|
|
}
|
|
|
|
template<class _CharT, class _Traits>
|
|
basic_ostream<_CharT, _Traits>&
|
|
operator<<(basic_ostream<_CharT, _Traits>& __os, char __cn)
|
|
{
|
|
#ifndef _LIBCPP_NO_EXCEPTIONS
|
|
try
|
|
{
|
|
#endif // _LIBCPP_NO_EXCEPTIONS
|
|
typename basic_ostream<_CharT, _Traits>::sentry __s(__os);
|
|
if (__s)
|
|
{
|
|
_CharT __c = __os.widen(__cn);
|
|
typedef ostreambuf_iterator<_CharT, _Traits> _Ip;
|
|
if (__pad_and_output(_Ip(__os),
|
|
&__c,
|
|
(__os.flags() & ios_base::adjustfield) == ios_base::left ?
|
|
&__c + 1 :
|
|
&__c,
|
|
&__c + 1,
|
|
__os,
|
|
__os.fill()).failed())
|
|
__os.setstate(ios_base::badbit | ios_base::failbit);
|
|
}
|
|
#ifndef _LIBCPP_NO_EXCEPTIONS
|
|
}
|
|
catch (...)
|
|
{
|
|
__os.__set_badbit_and_consider_rethrow();
|
|
}
|
|
#endif // _LIBCPP_NO_EXCEPTIONS
|
|
return __os;
|
|
}
|
|
|
|
template<class _Traits>
|
|
basic_ostream<char, _Traits>&
|
|
operator<<(basic_ostream<char, _Traits>& __os, char __c)
|
|
{
|
|
#ifndef _LIBCPP_NO_EXCEPTIONS
|
|
try
|
|
{
|
|
#endif // _LIBCPP_NO_EXCEPTIONS
|
|
typename basic_ostream<char, _Traits>::sentry __s(__os);
|
|
if (__s)
|
|
{
|
|
typedef ostreambuf_iterator<char, _Traits> _Ip;
|
|
if (__pad_and_output(_Ip(__os),
|
|
&__c,
|
|
(__os.flags() & ios_base::adjustfield) == ios_base::left ?
|
|
&__c + 1 :
|
|
&__c,
|
|
&__c + 1,
|
|
__os,
|
|
__os.fill()).failed())
|
|
__os.setstate(ios_base::badbit | ios_base::failbit);
|
|
}
|
|
#ifndef _LIBCPP_NO_EXCEPTIONS
|
|
}
|
|
catch (...)
|
|
{
|
|
__os.__set_badbit_and_consider_rethrow();
|
|
}
|
|
#endif // _LIBCPP_NO_EXCEPTIONS
|
|
return __os;
|
|
}
|
|
|
|
template<class _Traits>
|
|
basic_ostream<char, _Traits>&
|
|
operator<<(basic_ostream<char, _Traits>& __os, signed char __c)
|
|
{
|
|
#ifndef _LIBCPP_NO_EXCEPTIONS
|
|
try
|
|
{
|
|
#endif // _LIBCPP_NO_EXCEPTIONS
|
|
typename basic_ostream<char, _Traits>::sentry __s(__os);
|
|
if (__s)
|
|
{
|
|
typedef ostreambuf_iterator<char, _Traits> _Ip;
|
|
if (__pad_and_output(_Ip(__os),
|
|
(char*)&__c,
|
|
(__os.flags() & ios_base::adjustfield) == ios_base::left ?
|
|
(char*)&__c + 1 :
|
|
(char*)&__c,
|
|
(char*)&__c + 1,
|
|
__os,
|
|
__os.fill()).failed())
|
|
__os.setstate(ios_base::badbit | ios_base::failbit);
|
|
}
|
|
#ifndef _LIBCPP_NO_EXCEPTIONS
|
|
}
|
|
catch (...)
|
|
{
|
|
__os.__set_badbit_and_consider_rethrow();
|
|
}
|
|
#endif // _LIBCPP_NO_EXCEPTIONS
|
|
return __os;
|
|
}
|
|
|
|
template<class _Traits>
|
|
basic_ostream<char, _Traits>&
|
|
operator<<(basic_ostream<char, _Traits>& __os, unsigned char __c)
|
|
{
|
|
#ifndef _LIBCPP_NO_EXCEPTIONS
|
|
try
|
|
{
|
|
#endif // _LIBCPP_NO_EXCEPTIONS
|
|
typename basic_ostream<char, _Traits>::sentry __s(__os);
|
|
if (__s)
|
|
{
|
|
typedef ostreambuf_iterator<char, _Traits> _Ip;
|
|
if (__pad_and_output(_Ip(__os),
|
|
(char*)&__c,
|
|
(__os.flags() & ios_base::adjustfield) == ios_base::left ?
|
|
(char*)&__c + 1 :
|
|
(char*)&__c,
|
|
(char*)&__c + 1,
|
|
__os,
|
|
__os.fill()).failed())
|
|
__os.setstate(ios_base::badbit | ios_base::failbit);
|
|
}
|
|
#ifndef _LIBCPP_NO_EXCEPTIONS
|
|
}
|
|
catch (...)
|
|
{
|
|
__os.__set_badbit_and_consider_rethrow();
|
|
}
|
|
#endif // _LIBCPP_NO_EXCEPTIONS
|
|
return __os;
|
|
}
|
|
|
|
template<class _CharT, class _Traits>
|
|
basic_ostream<_CharT, _Traits>&
|
|
operator<<(basic_ostream<_CharT, _Traits>& __os, const _CharT* __str)
|
|
{
|
|
#ifndef _LIBCPP_NO_EXCEPTIONS
|
|
try
|
|
{
|
|
#endif // _LIBCPP_NO_EXCEPTIONS
|
|
typename basic_ostream<_CharT, _Traits>::sentry __s(__os);
|
|
if (__s)
|
|
{
|
|
typedef ostreambuf_iterator<_CharT, _Traits> _Ip;
|
|
size_t __len = _Traits::length(__str);
|
|
if (__pad_and_output(_Ip(__os),
|
|
__str,
|
|
(__os.flags() & ios_base::adjustfield) == ios_base::left ?
|
|
__str + __len :
|
|
__str,
|
|
__str + __len,
|
|
__os,
|
|
__os.fill()).failed())
|
|
__os.setstate(ios_base::badbit | ios_base::failbit);
|
|
}
|
|
#ifndef _LIBCPP_NO_EXCEPTIONS
|
|
}
|
|
catch (...)
|
|
{
|
|
__os.__set_badbit_and_consider_rethrow();
|
|
}
|
|
#endif // _LIBCPP_NO_EXCEPTIONS
|
|
return __os;
|
|
}
|
|
|
|
template<class _CharT, class _Traits>
|
|
basic_ostream<_CharT, _Traits>&
|
|
operator<<(basic_ostream<_CharT, _Traits>& __os, const char* __strn)
|
|
{
|
|
#ifndef _LIBCPP_NO_EXCEPTIONS
|
|
try
|
|
{
|
|
#endif // _LIBCPP_NO_EXCEPTIONS
|
|
typename basic_ostream<_CharT, _Traits>::sentry __s(__os);
|
|
if (__s)
|
|
{
|
|
typedef ostreambuf_iterator<_CharT, _Traits> _Ip;
|
|
size_t __len = char_traits<char>::length(__strn);
|
|
const int __bs = 100;
|
|
_CharT __wbb[__bs];
|
|
_CharT* __wb = __wbb;
|
|
unique_ptr<_CharT, void(*)(void*)> __h(0, free);
|
|
if (__len > __bs)
|
|
{
|
|
__wb = (_CharT*)malloc(__len*sizeof(_CharT));
|
|
if (__wb == 0)
|
|
__throw_bad_alloc();
|
|
__h.reset(__wb);
|
|
}
|
|
for (_CharT* __p = __wb; *__strn != '\0'; ++__strn, ++__p)
|
|
*__p = __os.widen(*__strn);
|
|
if (__pad_and_output(_Ip(__os),
|
|
__wb,
|
|
(__os.flags() & ios_base::adjustfield) == ios_base::left ?
|
|
__wb + __len :
|
|
__wb,
|
|
__wb + __len,
|
|
__os,
|
|
__os.fill()).failed())
|
|
__os.setstate(ios_base::badbit | ios_base::failbit);
|
|
}
|
|
#ifndef _LIBCPP_NO_EXCEPTIONS
|
|
}
|
|
catch (...)
|
|
{
|
|
__os.__set_badbit_and_consider_rethrow();
|
|
}
|
|
#endif // _LIBCPP_NO_EXCEPTIONS
|
|
return __os;
|
|
}
|
|
|
|
template<class _Traits>
|
|
basic_ostream<char, _Traits>&
|
|
operator<<(basic_ostream<char, _Traits>& __os, const char* __str)
|
|
{
|
|
#ifndef _LIBCPP_NO_EXCEPTIONS
|
|
try
|
|
{
|
|
#endif // _LIBCPP_NO_EXCEPTIONS
|
|
typename basic_ostream<char, _Traits>::sentry __s(__os);
|
|
if (__s)
|
|
{
|
|
typedef ostreambuf_iterator<char, _Traits> _Ip;
|
|
size_t __len = _Traits::length(__str);
|
|
if (__pad_and_output(_Ip(__os),
|
|
__str,
|
|
(__os.flags() & ios_base::adjustfield) == ios_base::left ?
|
|
__str + __len :
|
|
__str,
|
|
__str + __len,
|
|
__os,
|
|
__os.fill()).failed())
|
|
__os.setstate(ios_base::badbit | ios_base::failbit);
|
|
}
|
|
#ifndef _LIBCPP_NO_EXCEPTIONS
|
|
}
|
|
catch (...)
|
|
{
|
|
__os.__set_badbit_and_consider_rethrow();
|
|
}
|
|
#endif // _LIBCPP_NO_EXCEPTIONS
|
|
return __os;
|
|
}
|
|
|
|
template<class _Traits>
|
|
basic_ostream<char, _Traits>&
|
|
operator<<(basic_ostream<char, _Traits>& __os, const signed char* __str)
|
|
{
|
|
#ifndef _LIBCPP_NO_EXCEPTIONS
|
|
try
|
|
{
|
|
#endif // _LIBCPP_NO_EXCEPTIONS
|
|
typename basic_ostream<char, _Traits>::sentry __s(__os);
|
|
if (__s)
|
|
{
|
|
typedef ostreambuf_iterator<char, _Traits> _Ip;
|
|
size_t __len = _Traits::length((const char*)__str);
|
|
if (__pad_and_output(_Ip(__os),
|
|
(const char*)__str,
|
|
(__os.flags() & ios_base::adjustfield) == ios_base::left ?
|
|
(const char*)__str + __len :
|
|
(const char*)__str,
|
|
(const char*)__str + __len,
|
|
__os,
|
|
__os.fill()).failed())
|
|
__os.setstate(ios_base::badbit | ios_base::failbit);
|
|
}
|
|
#ifndef _LIBCPP_NO_EXCEPTIONS
|
|
}
|
|
catch (...)
|
|
{
|
|
__os.__set_badbit_and_consider_rethrow();
|
|
}
|
|
#endif // _LIBCPP_NO_EXCEPTIONS
|
|
return __os;
|
|
}
|
|
|
|
template<class _Traits>
|
|
basic_ostream<char, _Traits>&
|
|
operator<<(basic_ostream<char, _Traits>& __os, const unsigned char* __str)
|
|
{
|
|
#ifndef _LIBCPP_NO_EXCEPTIONS
|
|
try
|
|
{
|
|
#endif // _LIBCPP_NO_EXCEPTIONS
|
|
typename basic_ostream<char, _Traits>::sentry __s(__os);
|
|
if (__s)
|
|
{
|
|
typedef ostreambuf_iterator<char, _Traits> _Ip;
|
|
size_t __len = _Traits::length((const char*)__str);
|
|
if (__pad_and_output(_Ip(__os),
|
|
(const char*)__str,
|
|
(__os.flags() & ios_base::adjustfield) == ios_base::left ?
|
|
(const char*)__str + __len :
|
|
(const char*)__str,
|
|
(const char*)__str + __len,
|
|
__os,
|
|
__os.fill()).failed())
|
|
__os.setstate(ios_base::badbit | ios_base::failbit);
|
|
}
|
|
#ifndef _LIBCPP_NO_EXCEPTIONS
|
|
}
|
|
catch (...)
|
|
{
|
|
__os.__set_badbit_and_consider_rethrow();
|
|
}
|
|
#endif // _LIBCPP_NO_EXCEPTIONS
|
|
return __os;
|
|
}
|
|
|
|
template <class _CharT, class _Traits>
|
|
basic_ostream<_CharT, _Traits>&
|
|
basic_ostream<_CharT, _Traits>::put(char_type __c)
|
|
{
|
|
#ifndef _LIBCPP_NO_EXCEPTIONS
|
|
try
|
|
{
|
|
#endif // _LIBCPP_NO_EXCEPTIONS
|
|
sentry __s(*this);
|
|
if (__s)
|
|
{
|
|
typedef ostreambuf_iterator<_CharT, _Traits> _Op;
|
|
_Op __o(*this);
|
|
*__o = __c;
|
|
if (__o.failed())
|
|
this->setstate(ios_base::badbit);
|
|
}
|
|
#ifndef _LIBCPP_NO_EXCEPTIONS
|
|
}
|
|
catch (...)
|
|
{
|
|
this->__set_badbit_and_consider_rethrow();
|
|
}
|
|
#endif // _LIBCPP_NO_EXCEPTIONS
|
|
return *this;
|
|
}
|
|
|
|
template <class _CharT, class _Traits>
|
|
basic_ostream<_CharT, _Traits>&
|
|
basic_ostream<_CharT, _Traits>::write(const char_type* __s, streamsize __n)
|
|
{
|
|
#ifndef _LIBCPP_NO_EXCEPTIONS
|
|
try
|
|
{
|
|
#endif // _LIBCPP_NO_EXCEPTIONS
|
|
sentry __sen(*this);
|
|
if (__sen && __n)
|
|
{
|
|
if (this->rdbuf()->sputn(__s, __n) != __n)
|
|
this->setstate(ios_base::badbit);
|
|
}
|
|
#ifndef _LIBCPP_NO_EXCEPTIONS
|
|
}
|
|
catch (...)
|
|
{
|
|
this->__set_badbit_and_consider_rethrow();
|
|
}
|
|
#endif // _LIBCPP_NO_EXCEPTIONS
|
|
return *this;
|
|
}
|
|
|
|
template <class _CharT, class _Traits>
|
|
basic_ostream<_CharT, _Traits>&
|
|
basic_ostream<_CharT, _Traits>::flush()
|
|
{
|
|
#ifndef _LIBCPP_NO_EXCEPTIONS
|
|
try
|
|
{
|
|
#endif // _LIBCPP_NO_EXCEPTIONS
|
|
if (this->rdbuf())
|
|
{
|
|
sentry __s(*this);
|
|
if (__s)
|
|
{
|
|
if (this->rdbuf()->pubsync() == -1)
|
|
this->setstate(ios_base::badbit);
|
|
}
|
|
}
|
|
#ifndef _LIBCPP_NO_EXCEPTIONS
|
|
}
|
|
catch (...)
|
|
{
|
|
this->__set_badbit_and_consider_rethrow();
|
|
}
|
|
#endif // _LIBCPP_NO_EXCEPTIONS
|
|
return *this;
|
|
}
|
|
|
|
template <class _CharT, class _Traits>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
typename basic_ostream<_CharT, _Traits>::pos_type
|
|
basic_ostream<_CharT, _Traits>::tellp()
|
|
{
|
|
if (this->fail())
|
|
return pos_type(-1);
|
|
return this->rdbuf()->pubseekoff(0, ios_base::cur, ios_base::out);
|
|
}
|
|
|
|
template <class _CharT, class _Traits>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
basic_ostream<_CharT, _Traits>&
|
|
basic_ostream<_CharT, _Traits>::seekp(pos_type __pos)
|
|
{
|
|
if (!this->fail())
|
|
{
|
|
if (this->rdbuf()->pubseekpos(__pos, ios_base::out) == pos_type(-1))
|
|
this->setstate(ios_base::failbit);
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
template <class _CharT, class _Traits>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
basic_ostream<_CharT, _Traits>&
|
|
basic_ostream<_CharT, _Traits>::seekp(off_type __off, ios_base::seekdir __dir)
|
|
{
|
|
if (!this->fail())
|
|
this->rdbuf()->pubseekoff(__off, __dir, ios_base::out);
|
|
return *this;
|
|
}
|
|
|
|
template <class _CharT, class _Traits>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
basic_ostream<_CharT, _Traits>&
|
|
endl(basic_ostream<_CharT, _Traits>& __os)
|
|
{
|
|
__os.put(__os.widen('\n'));
|
|
__os.flush();
|
|
return __os;
|
|
}
|
|
|
|
template <class _CharT, class _Traits>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
basic_ostream<_CharT, _Traits>&
|
|
ends(basic_ostream<_CharT, _Traits>& __os)
|
|
{
|
|
__os.put(_CharT());
|
|
return __os;
|
|
}
|
|
|
|
template <class _CharT, class _Traits>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
basic_ostream<_CharT, _Traits>&
|
|
flush(basic_ostream<_CharT, _Traits>& __os)
|
|
{
|
|
__os.flush();
|
|
return __os;
|
|
}
|
|
|
|
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
|
|
|
template <class _Stream, class _Tp>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
typename enable_if
|
|
<
|
|
!is_lvalue_reference<_Stream>::value &&
|
|
is_base_of<ios_base, _Stream>::value,
|
|
_Stream&&
|
|
>::type
|
|
operator<<(_Stream&& __os, const _Tp& __x)
|
|
{
|
|
__os << __x;
|
|
return _VSTD::move(__os);
|
|
}
|
|
|
|
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
|
|
|
template<class _CharT, class _Traits, class _Allocator>
|
|
basic_ostream<_CharT, _Traits>&
|
|
operator<<(basic_ostream<_CharT, _Traits>& __os,
|
|
const basic_string<_CharT, _Traits, _Allocator>& __str)
|
|
{
|
|
#ifndef _LIBCPP_NO_EXCEPTIONS
|
|
try
|
|
{
|
|
#endif // _LIBCPP_NO_EXCEPTIONS
|
|
typename basic_ostream<_CharT, _Traits>::sentry __s(__os);
|
|
if (__s)
|
|
{
|
|
typedef ostreambuf_iterator<_CharT, _Traits> _Ip;
|
|
size_t __len = __str.size();
|
|
if (__pad_and_output(_Ip(__os),
|
|
__str.data(),
|
|
(__os.flags() & ios_base::adjustfield) == ios_base::left ?
|
|
__str.data() + __len :
|
|
__str.data(),
|
|
__str.data() + __len,
|
|
__os,
|
|
__os.fill()).failed())
|
|
__os.setstate(ios_base::badbit | ios_base::failbit);
|
|
}
|
|
#ifndef _LIBCPP_NO_EXCEPTIONS
|
|
}
|
|
catch (...)
|
|
{
|
|
__os.__set_badbit_and_consider_rethrow();
|
|
}
|
|
#endif // _LIBCPP_NO_EXCEPTIONS
|
|
return __os;
|
|
}
|
|
|
|
template <class _CharT, class _Traits>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
basic_ostream<_CharT, _Traits>&
|
|
operator<<(basic_ostream<_CharT, _Traits>& __os, const error_code& __ec)
|
|
{
|
|
return __os << __ec.category().name() << ':' << __ec.value();
|
|
}
|
|
|
|
template<class _CharT, class _Traits, class _Yp>
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
basic_ostream<_CharT, _Traits>&
|
|
operator<<(basic_ostream<_CharT, _Traits>& __os, shared_ptr<_Yp> const& __p)
|
|
{
|
|
return __os << __p.get();
|
|
}
|
|
|
|
template <class _CharT, class _Traits, size_t _Size>
|
|
basic_ostream<_CharT, _Traits>&
|
|
operator<<(basic_ostream<_CharT, _Traits>& __os, const bitset<_Size>& __x)
|
|
{
|
|
return __os << __x.template to_string<_CharT, _Traits>
|
|
(use_facet<ctype<_CharT> >(__os.getloc()).widen('0'),
|
|
use_facet<ctype<_CharT> >(__os.getloc()).widen('1'));
|
|
}
|
|
|
|
_LIBCPP_EXTERN_TEMPLATE(class basic_ostream<char>)
|
|
_LIBCPP_EXTERN_TEMPLATE(class basic_ostream<wchar_t>)
|
|
|
|
_LIBCPP_END_NAMESPACE_STD
|
|
|
|
#endif // _LIBCPP_OSTREAM
|