#include <istream>
#include <type_traits>
#include <xlocmon>
#include <xloctime>

Classes
struct	_Fillobj< _Elem >

struct	_Monobj< _Money >

struct	_Timeobj< _Elem, _Ptr >

struct	_Quote_in< _Elem, _Traits, _Alloc >

struct	_Quote_out< _Elem, _Traits, _Sizet >

struct	_Smanip< _Arg >

Macros
#define	_IOMANIP_

Functions
template<class _Elem >
_Fillobj< _Elem >	setfill (_Elem _Ch)

template<class _Elem , class _Traits , class _Elem2 >
basic_istream< _Elem, _Traits > &	operator>> (basic_istream< _Elem, _Traits > &_Istr, const _Fillobj< _Elem2 > &_Manip)

template<class _Elem , class _Traits , class _Elem2 >
basic_ostream< _Elem, _Traits > &	operator<< (basic_ostream< _Elem, _Traits > &_Ostr, const _Fillobj< _Elem2 > &_Manip)

template<class _Money >
_Monobj< _Money >	get_money (_Money &_Val_arg, bool _Intl_arg=false)

template<class _Elem , class _Traits , class _Money >
basic_istream< _Elem, _Traits > &	operator>> (basic_istream< _Elem, _Traits > &_Istr, const _Monobj< _Money > &_Manip)

template<class _Money >
_Monobj< const _Money >	put_money (const _Money &_Val_arg, bool _Intl_arg=false)

template<class _Elem , class _Traits , class _Money >
basic_ostream< _Elem, _Traits > &	operator<< (basic_ostream< _Elem, _Traits > &_Ostr, const _Monobj< _Money > &_Manip)

template<class _Elem >
_Timeobj< _Elem, struct tm * >	get_time (struct tm _Tptr_arg, const _Elem _Fmt_arg)

template<class _Elem , class _Traits , class _Elem2 >
basic_istream< _Elem, _Traits > &	operator>> (basic_istream< _Elem, _Traits > &_Istr, const _Timeobj< _Elem2, struct tm * > &_Manip)

template<class _Elem >
_Timeobj< _Elem, const struct tm * >	put_time (const struct tm _Tptr_arg, const _Elem _Fmt_arg)

template<class _Elem , class _Traits , class _Elem2 >
basic_ostream< _Elem, _Traits > &	operator<< (basic_ostream< _Elem, _Traits > &_Ostr, const _Timeobj< _Elem2, const struct tm * > &_Manip)

template<class _Elem >
_Quote_out< _Elem, void, size_t >	quoted (const _Elem *_Ptr, _Elem _Delim=_Elem('"'), _Elem _Escape = _Elem('\\'))

template<class _Elem , class _Traits , class _Alloc >
_Quote_out< _Elem, _Traits, typename basic_string< _Elem, _Traits, _Alloc >::size_type >	quoted (const basic_string< _Elem, _Traits, _Alloc > &_Str, _Elem _Delim=_Elem('"'), _Elem _Escape = _Elem('\\'))

template<class _Elem , class _Traits , class _Alloc >
_Quote_in< _Elem, _Traits, _Alloc >	quoted (basic_string< _Elem, _Traits, _Alloc > &_Str, _Elem _Delim=_Elem('"'), _Elem _Escape = _Elem('\\'))

template<class _Elem , class _Traits , class _QuTraits , class _Sizet >
basic_ostream< _Elem, _Traits > &	operator<< (basic_ostream< _Elem, _Traits > &_Ostr, const _Quote_out< _Elem, _QuTraits, _Sizet > &_Manip)

template<class _Elem , class _Traits , class _Alloc >
basic_ostream< _Elem, _Traits > &	operator<< (basic_ostream< _Elem, _Traits > &_Ostr, const _Quote_in< _Elem, _Traits, _Alloc > &_Manip)

template<class _Elem , class _Traits , class _Alloc >
basic_istream< _Elem, _Traits > &	operator>> (basic_istream< _Elem, _Traits > &_Istr, const _Quote_in< _Elem, _Traits, _Alloc > &_Manip)

template<class _Elem , class _Traits , class _Arg >
basic_istream< _Elem, _Traits > &	operator>> (basic_istream< _Elem, _Traits > &_Istr, const _Smanip< _Arg > &_Manip)

template<class _Elem , class _Traits , class _Arg >
basic_ostream< _Elem, _Traits > &	operator<< (basic_ostream< _Elem, _Traits > &_Ostr, const _Smanip< _Arg > &_Manip)

_MRTIMP2 _Smanip< ios_base::fmtflags > __cdecl	resetiosflags (ios_base::fmtflags)

_MRTIMP2 _Smanip< ios_base::fmtflags > __cdecl	setiosflags (ios_base::fmtflags)

_MRTIMP2 _Smanip< int > __cdecl	setbase (int)

_MRTIMP2 _Smanip< streamsize > __cdecl	setprecision (streamsize)

_MRTIMP2 _Smanip< streamsize > __cdecl	setw (streamsize)

Macro Definition Documentation

#define _IOMANIP_

Function Documentation

template<class _Money >

_Monobj<_Money> get_money	(	_Money &	_Val_arg,
		bool	_Intl_arg = `false`
	)

inline

     {   // return a _Monobj manipulator
     return (_Monobj<_Money>(_Val_arg, _Intl_arg));
     }

template<class _Elem >

_Timeobj<_Elem, struct tm *> get_time	(	struct tm *	_Tptr_arg,
		const _Elem *	_Fmt_arg
	)

inline

     {   // return a _Timeobj manipulator
     return (_Timeobj<_Elem, struct tm *>(_Tptr_arg, _Fmt_arg));
     }

template<class _Elem , class _Traits , class _Elem2 >

basic_ostream<_Elem, _Traits>& operator<<	(	basic_ostream< _Elem, _Traits > &	_Ostr,
		const _Fillobj< _Elem2 > &	_Manip
	)

inline

     {   // set fill character in output stream
     static_assert(is_same<_Elem, _Elem2>::value,
         "wrong character type for setfill");
 
     _Ostr.fill(_Manip._Fill);
     return (_Ostr);
     }

template<class _Elem , class _Traits , class _Money >

basic_ostream<_Elem, _Traits>& operator<<	(	basic_ostream< _Elem, _Traits > &	_Ostr,
		const _Monobj< _Money > &	_Manip
	)

inline

     {   // put monetary amount to output stream
     typedef basic_ostream<_Elem, _Traits> _Myos;
     typedef ostreambuf_iterator<_Elem, _Traits> _Iter;
     typedef money_put<_Elem, _Iter> _Mymput;
 
     ios_base::iostate _State = ios_base::goodbit;
     const typename _Myos::sentry _Ok(_Ostr);
 
     if (_Ok)
         {   // state okay, insert monetary amount
         const _Mymput& _Mput_fac = _USE(_Ostr.getloc(), _Mymput);
         _TRY_IO_BEGIN
         if (_Mput_fac.put(_Iter(_Ostr.rdbuf()), _Manip._Intl,
             _Ostr, _Ostr.fill(), _Manip._Val).failed())
                 _State |= ios_base::badbit;
         _CATCH_IO_(_Ostr)
         }
 
     _Ostr.setstate(_State);
     return (_Ostr);
     }

template<class _Elem , class _Traits , class _Elem2 >

basic_ostream<_Elem, _Traits>& operator<<	(	basic_ostream< _Elem, _Traits > &	_Ostr,
		const _Timeobj< _Elem2, const struct tm * > &	_Manip
	)

inline

     {   // put time information to output stream
     typedef basic_ostream<_Elem, _Traits> _Myos;
     typedef ostreambuf_iterator<_Elem, _Traits> _Iter;
     typedef time_put<_Elem2, _Iter> _Mytput;
 
     static_assert(is_same<_Elem, _Elem2>::value,
         "wrong character type for put_time");
 
     ios_base::iostate _State = ios_base::goodbit;
     const typename _Myos::sentry _Ok(_Ostr);
 
     if (_Ok)
         {   // state okay, insert monetary amount
         const _Mytput& _Tput_fac = _USE(_Ostr.getloc(), _Mytput);
         _TRY_IO_BEGIN
         if (_Tput_fac.put(_Iter(_Ostr.rdbuf()), _Ostr, _Ostr.fill(),
             _Manip._Tptr, _Manip._Fmtfirst, _Manip._Fmtlast).failed())
             _State |= ios_base::badbit;
         _CATCH_IO_(_Ostr)
         }
 
     _Ostr.setstate(_State);
     return (_Ostr);
     }

template<class _Elem , class _Traits , class _Alloc >

basic_ostream<_Elem, _Traits>& operator<<	(	basic_ostream< _Elem, _Traits > &	_Ostr,
		const _Quote_in< _Elem, _Traits, _Alloc > &	_Manip
	)

inline

     {   // put quoted string to output stream
     typedef basic_string<_Elem, _Traits, _Alloc> _Mystr;
     const _Mystr& _Ref = _Manip._Str;
     return (_Ostr << _STD quoted(_Ref, _Manip._Delim, _Manip._Escape));
     }

template<class _Elem , class _Traits , class _QuTraits , class _Sizet >

basic_ostream<_Elem, _Traits>& operator<<	(	basic_ostream< _Elem, _Traits > &	_Ostr,
		const _Quote_out< _Elem, _QuTraits, _Sizet > &	_Manip
	)

inline

     {   // put quoted string to output stream
     static_assert(is_void<_QuTraits>::value
         || is_same<_QuTraits, _Traits>::value,
         "quoted() traits must match basic_ostream traits");
 
     typedef basic_ostream<_Elem, _Traits> _Myos;
 
     const _Elem *const _Last = _Manip._Ptr + _Manip._Size;
 
     _Sizet _Size = _Manip._Size + 2;    // allow for delimiters
     for (const _Elem *_Ptr = _Manip._Ptr; _Ptr != _Last; ++_Ptr)
         if (_Traits::eq(*_Ptr, _Manip._Delim)
             || _Traits::eq(*_Ptr, _Manip._Escape))
             ++_Size;    // count escapes
 
     ios_base::iostate _State = ios_base::goodbit;
     _Sizet _Pad = _Ostr.width() <= 0 || (_Sizet)_Ostr.width() <= _Size
         ? 0 : (_Sizet)_Ostr.width() - _Size;
     const typename _Myos::sentry _Ok(_Ostr);
 
     if (!_Ok)
         _State |= ios_base::badbit;
     else
         {   // state okay, insert characters
     _TRY_IO_BEGIN
         if ((_Ostr.flags() & ios_base::adjustfield) != ios_base::left)
             for (; 0 < _Pad; --_Pad)    // pad on left
                 if (_Traits::eq_int_type(_Traits::eof(),
                     _Ostr.rdbuf()->sputc(_Ostr.fill())))
                     {   // insertion failed, quit
                     _State |= ios_base::badbit;
                     break;
                     }
 
         if (_State == ios_base::goodbit
             && _Traits::eq_int_type(_Traits::eof(),
                 _Ostr.rdbuf()->sputc(_Manip._Delim)))   // put delimiter
             _State |= ios_base::badbit;
 
         for (const _Elem *_Ptr = _Manip._Ptr; _Ptr != _Last; ++_Ptr)
             {   // put (possibly escaped) element
             if ((_Traits::eq(*_Ptr, _Manip._Delim)
                 || _Traits::eq(*_Ptr, _Manip._Escape))
                 && _State == ios_base::goodbit
                 && _Traits::eq_int_type(_Traits::eof(),
                     _Ostr.rdbuf()->sputc(_Manip._Escape)))  // put escape
                 {   // insertion failed, quit
                 _State |= ios_base::badbit;
                 break;
                 }
             if (_State == ios_base::goodbit
                 && _Traits::eq_int_type(_Traits::eof(),
                     _Ostr.rdbuf()->sputc(*_Ptr)))   // put element
                 {   // insertion failed, quit
                 _State |= ios_base::badbit;
                 break;
                 }
             }
         if (_State == ios_base::goodbit
             && _Traits::eq_int_type(_Traits::eof(),
                 _Ostr.rdbuf()->sputc(_Manip._Delim)))   // put delimiter
             _State |= ios_base::badbit;
 
         if (_State == ios_base::goodbit)
             for (; 0 < _Pad; --_Pad)    // pad on right
                 if (_Traits::eq_int_type(_Traits::eof(),
                     _Ostr.rdbuf()->sputc(_Ostr.fill())))
                     {   // insertion failed, quit
                     _State |= ios_base::badbit;
                     break;
                     }
         _Ostr.width(0);
         _CATCH_IO_(_Ostr)
         }
 
     _Ostr.setstate(_State);
     return (_Ostr);
     }

template<class _Elem , class _Traits , class _Arg >

basic_ostream<_Elem, _Traits>& operator<<	(	basic_ostream< _Elem, _Traits > &	_Ostr,
		const _Smanip< _Arg > &	_Manip
	)

inline

     {   // insert by calling function with output stream and argument
     (*_Manip._Pfun)(_Ostr, _Manip._Manarg);
     return (_Ostr);
     }

template<class _Elem , class _Traits , class _Elem2 >

basic_istream<_Elem, _Traits>& operator>>	(	basic_istream< _Elem, _Traits > &	_Istr,
		const _Fillobj< _Elem2 > &	_Manip
	)

inline

     {   // set fill character in input stream
     static_assert(is_same<_Elem, _Elem2>::value,
         "wrong character type for setfill");
 
     _Istr.fill(_Manip._Fill);
     return (_Istr);
     }

template<class _Elem , class _Traits , class _Money >

basic_istream<_Elem, _Traits>& operator>>	(	basic_istream< _Elem, _Traits > &	_Istr,
		const _Monobj< _Money > &	_Manip
	)

inline

     {   // get monetary amount from input stream
     typedef basic_istream<_Elem, _Traits> _Myis;
     typedef istreambuf_iterator<_Elem, _Traits> _Iter;
     typedef money_get<_Elem, _Iter> _Mymget;
 
     ios_base::iostate _State = ios_base::goodbit;
     const typename _Myis::sentry _Ok(_Istr);
 
     if (_Ok)
         {   // state okay, extract monetary amount
         const _Mymget& _Mget_fac = _USE(_Istr.getloc(), _Mymget);
         _TRY_IO_BEGIN
         _Mget_fac.get(_Iter(_Istr.rdbuf()), _Iter(0), _Manip._Intl,
             _Istr, _State, _Manip._Val);
         _CATCH_IO_(_Istr)
         }
 
     _Istr.setstate(_State);
     return (_Istr);
     }

template<class _Elem , class _Traits , class _Elem2 >

basic_istream<_Elem, _Traits>& operator>>	(	basic_istream< _Elem, _Traits > &	_Istr,
		const _Timeobj< _Elem2, struct tm * > &	_Manip
	)

inline

     {   // get time information from input stream
     typedef basic_istream<_Elem, _Traits> _Myis;
     typedef istreambuf_iterator<_Elem, _Traits> _Iter;
     typedef time_get<_Elem2, _Iter> _Mytget;
 
     static_assert(is_same<_Elem, _Elem2>::value,
         "wrong character type for get_time");
 
     ios_base::iostate _State = ios_base::goodbit;
     const typename _Myis::sentry _Ok(_Istr);
 
     if (_Ok)
         {   // state okay, extract time amounts
         const _Mytget& _Tget_fac = _USE(_Istr.getloc(), _Mytget);
         _TRY_IO_BEGIN
         _Tget_fac.get(_Iter(_Istr.rdbuf()), _Iter(0), _Istr, _State,
             _Manip._Tptr, _Manip._Fmtfirst, _Manip._Fmtlast);
         _CATCH_IO_(_Istr)
         }
 
     _Istr.setstate(_State);
     return (_Istr);
     }

template<class _Elem , class _Traits , class _Alloc >

basic_istream<_Elem, _Traits>& operator>>	(	basic_istream< _Elem, _Traits > &	_Istr,
		const _Quote_in< _Elem, _Traits, _Alloc > &	_Manip
	)

inline

     {   // get quoted string from input stream
     typedef basic_istream<_Elem, _Traits> _Myis;
     typedef basic_string<_Elem, _Traits, _Alloc> _Mystr;
     typedef typename _Mystr::size_type _Sizet;
 
     ios_base::iostate _State = ios_base::goodbit;
     bool _Changed = false;
     const typename _Myis::sentry _Ok(_Istr);
 
     while (_Ok)
         {   // state okay, extract characters
         _TRY_IO_BEGIN
         _Sizet _Size = 0 < _Istr.width()
             && (_Sizet)_Istr.width() < _Manip._Str.max_size()
                 ? (_Sizet)_Istr.width() : _Manip._Str.max_size();
         typename _Traits::int_type _Meta = _Istr.rdbuf()->sgetc();
         typename _Traits::int_type _Delim =
             _Traits::to_int_type(_Manip._Delim);
         typename _Traits::int_type _Escape =
             _Traits::to_int_type(_Manip._Escape);
 
         if (!_Traits::eq_int_type(_Meta, _Delim))   // no leading delimiter
             return (_Istr >> _Manip._Str);
         _Manip._Str.clear();
         _Meta = _Istr.rdbuf()->snextc();    // discard leading delimiter
 
         for (; !_Traits::eq_int_type(_Meta, _Delim) && 0 < _Size;
             _Meta = _Istr.rdbuf()->snextc(), --_Size)
             if (_Traits::eq_int_type(_Traits::eof(), _Meta))
                 {   // end of file, quit
                 _State |= ios_base::eofbit;
                 break;
                 }
             else if (!_Traits::eq_int_type(_Meta, _Escape))
                 _Manip._Str.append(1,
                     _Traits::to_char_type(_Meta));  // add element
             else if (_Traits::eq_int_type(_Traits::eof(),
                 _Meta = _Istr.rdbuf()->snextc()))
                 {   // escaped end of file, quit
                 _State |= ios_base::eofbit;
                 break;
                 }
             else
                 _Manip._Str.append(1,
                     _Traits::to_char_type(_Meta));  // add escaped element
 
         if (!_Traits::eq_int_type(_Meta, _Delim))
             _State |= ios_base::failbit;    // no trailing delimiter, fail
         else
             {   // discard trailing delimiter
             _Changed = true;
             _Istr.rdbuf()->snextc();
             }
         _CATCH_IO_(_Istr)
         break;
         }
 
     _Istr.width(0);
     if (!_Changed)
         _State |= ios_base::failbit;
     _Istr.setstate(_State);
     return (_Istr);
     }

template<class _Elem , class _Traits , class _Arg >

basic_istream<_Elem, _Traits>& operator>>	(	basic_istream< _Elem, _Traits > &	_Istr,
		const _Smanip< _Arg > &	_Manip
	)

inline

     {   // extract by calling function with input stream and argument
     (*_Manip._Pfun)(_Istr, _Manip._Manarg);
     return (_Istr);
     }

template<class _Money >

_Monobj<const _Money> put_money	(	const _Money &	_Val_arg,
		bool	_Intl_arg = `false`
	)

inline

     {   // return a _Monobj manipulator
     return (_Monobj<const _Money>(_Val_arg, _Intl_arg));
     }

template<class _Elem >

_Timeobj<_Elem, const struct tm *> put_time	(	const struct tm *	_Tptr_arg,
		const _Elem *	_Fmt_arg
	)

inline

     {   // return a _Timeobj manipulator
     return (_Timeobj<_Elem, const struct tm *>(_Tptr_arg, _Fmt_arg));
     }

template<class _Elem >

_Quote_out<_Elem, void, size_t> quoted	(	const _Elem *	_Ptr,
		_Elem	_Delim = `_Elem('"')`,
		_Elem	_Escape = `_Elem('\\')`
	)

inline

     {   // return a _Quote_out manipulator for pointer/length
     size_t _Size = 0;
     for (; _Ptr[_Size] != _Elem(0); ++_Size)
         ;
     return (_Quote_out<_Elem, void, size_t>(_Ptr, _Size, _Delim, _Escape));
     }

template<class _Elem , class _Traits , class _Alloc >

_Quote_out<_Elem, _Traits, typename basic_string<_Elem, _Traits, _Alloc>::size_type> quoted	(	const basic_string< _Elem, _Traits, _Alloc > &	_Str,
		_Elem	_Delim = `_Elem('"')`,
		_Elem	_Escape = `_Elem('\\')`
	)

inline

     {   // return a _Quote_out manipulator for string
     typedef _Quote_out<_Elem, _Traits,
         typename basic_string<_Elem, _Traits, _Alloc>::size_type> _Qobj;
     return (_Qobj(_Str.c_str(), _Str.size(), _Delim, _Escape));
     }

template<class _Elem , class _Traits , class _Alloc >

_Quote_in<_Elem, _Traits, _Alloc> quoted	(	basic_string< _Elem, _Traits, _Alloc > &	_Str,
		_Elem	_Delim = `_Elem('"')`,
		_Elem	_Escape = `_Elem('\\')`
	)

inline

     {   // return a _Quote_in manipulator
     return (_Quote_in<_Elem, _Traits, _Alloc>(_Str, _Delim, _Escape));
     }

_MRTIMP2 _Smanip<ios_base::fmtflags> __cdecl resetiosflags ( ios_base::fmtflags )

_MRTIMP2 _Smanip<int> __cdecl setbase ( int )

template<class _Elem >

_Fillobj<_Elem> setfill ( _Elem _Ch )

inline

     {   // return a _Fillobj manipulator
     return (_Fillobj<_Elem>(_Ch));
     }

_MRTIMP2 _Smanip<ios_base::fmtflags> __cdecl setiosflags ( ios_base::fmtflags )

_MRTIMP2 _Smanip<streamsize> __cdecl setprecision ( streamsize )

_MRTIMP2 _Smanip<streamsize> __cdecl setw ( streamsize )

Classes

Macros

Functions

Macro Definition Documentation

Function Documentation