// ios standard header
#pragma once
#ifndef _IOS_
#define _IOS_
#ifndef RC_INVOKED
#include <xlocnum>

 #pragma pack(push,_CRT_PACKING)
 #pragma warning(push,_STL_WARNING_LEVEL)
 #pragma warning(disable: _STL_DISABLED_WARNINGS)
 _STL_DISABLE_CLANG_WARNINGS
 #pragma push_macro("new")
 #undef new

_STD_BEGIN
		// CLASS TEMPLATE basic_ios
template<class _Elem,
	class _Traits>
	class basic_ios
		: public ios_base
	{	// base class for basic_istream/basic_ostream
public:
	typedef basic_ostream<_Elem, _Traits> _Myos;
	typedef basic_streambuf<_Elem, _Traits> _Mysb;
	typedef ctype<_Elem> _Ctype;
	typedef _Elem char_type;
	typedef _Traits traits_type;
	typedef typename _Traits::int_type int_type;
	typedef typename _Traits::pos_type pos_type;
	typedef typename _Traits::off_type off_type;

	explicit __CLR_OR_THIS_CALL basic_ios(_Mysb *_Strbuf)
		{	// construct from stream buffer pointer
		init(_Strbuf);
		}

	virtual __CLR_OR_THIS_CALL ~basic_ios() noexcept
		{	// destroy the object
		}

	void __CLR_OR_THIS_CALL clear(iostate _State = goodbit, bool _Reraise = false)
		{	// set state, possibly reraise exception
		ios_base::clear(_Mystrbuf == nullptr ? (_State | ios_base::badbit) : _State, _Reraise);
		}

 #if _HAS_OLD_IOSTREAMS_MEMBERS
	void __CLR_OR_THIS_CALL clear(io_state _State)
		{	// set state to _State
		clear((iostate)_State);
		}
 #endif /* _HAS_OLD_IOSTREAMS_MEMBERS */

	void __CLR_OR_THIS_CALL setstate(iostate _State, bool _Reraise = false)
		{	// merge _State into state, possibly reraise exception
		clear(rdstate() | _State, _Reraise);
		}

 #if _HAS_OLD_IOSTREAMS_MEMBERS
	void __CLR_OR_THIS_CALL setstate(io_state _State)
		{	// merge _State into state
		setstate((iostate)_State);
		}
 #endif /* _HAS_OLD_IOSTREAMS_MEMBERS */

	basic_ios& __CLR_OR_THIS_CALL copyfmt(const basic_ios& _Right)
		{	// copy format parameters
		_Tiestr = _Right.tie();
		_Fillch = _Right.fill();
		ios_base::copyfmt(_Right);
		return (*this);
		}

	_Myos *__CLR_OR_THIS_CALL tie() const
		{	// return tie pointer
		return (_Tiestr);
		}

	_Myos *__CLR_OR_THIS_CALL tie(_Myos *_Newtie)
		{	// set tie pointer
		_Myos *_Oldtie = _Tiestr;
		_Tiestr = _Newtie;
		return (_Oldtie);
		}

	_NODISCARD _Mysb *__CLR_OR_THIS_CALL rdbuf() const
		{	// return stream buffer pointer
		return (_Mystrbuf);
		}

	_Mysb *__CLR_OR_THIS_CALL rdbuf(_Mysb *_Strbuf)
		{	// set stream buffer pointer
		_Mysb *_Oldstrbuf = _Mystrbuf;
		_Mystrbuf = _Strbuf;
		clear();
		return (_Oldstrbuf);
		}

	locale __CLR_OR_THIS_CALL imbue(const locale& _Loc)
		{	// set locale to argument
		locale _Oldlocale = ios_base::imbue(_Loc);
		if (rdbuf() != nullptr)
			rdbuf()->pubimbue(_Loc);
		return (_Oldlocale);
		}

	_Elem __CLR_OR_THIS_CALL fill() const
		{	// return fill character
		return (_Fillch);
		}

	_Elem __CLR_OR_THIS_CALL fill(_Elem _Newfill)
		{	// set fill character
		_Elem _Oldfill = _Fillch;
		_Fillch = _Newfill;
		return (_Oldfill);
		}

	char __CLR_OR_THIS_CALL narrow(_Elem _Ch, char _Dflt = '\0') const
		{	// convert _Ch to byte using imbued locale
		return (_STD use_facet<_Ctype>(getloc()).narrow(_Ch, _Dflt));
		}

	_Elem __CLR_OR_THIS_CALL widen(char _Byte) const
		{	// convert _Byte to character using imbued locale
		return (_STD use_facet<_Ctype>(getloc()).widen(_Byte));
		}

	void __CLR_OR_THIS_CALL move(basic_ios& _Right)
		{	// assign by moving _Right
		if (this != _STD addressof(_Right))
			{	// different, do the move
			_Mystrbuf = nullptr;
			_Tiestr = nullptr;
			this->swap(_Right);
			}
		}

	void __CLR_OR_THIS_CALL move(basic_ios&& _Right)
		{	// assign by moving _Right
		if (this != _STD addressof(_Right))
			{	// different, do the move
			_Mystrbuf = nullptr;
			_Tiestr = nullptr;
			this->swap(_Right);
			}
		}

	void __CLR_OR_THIS_CALL swap(basic_ios& _Right) noexcept
		{	// swap all but rdbuf() with right
		ios_base::swap(_Right);
		_STD swap(_Fillch, _Right._Fillch);
		_STD swap(_Tiestr, _Right._Tiestr);
		}

	void __CLR_OR_THIS_CALL set_rdbuf(_Mysb *_Strbuf)
		{	// set stream buffer pointer without changing state
		_Mystrbuf = _Strbuf;
		}

protected:
	void __CLR_OR_THIS_CALL init(_Mysb *_Strbuf = nullptr,
		bool _Isstd = false)
		{	// initialize with stream buffer pointer
		_Init();	// initialize ios_base
		_Mystrbuf = _Strbuf;
		_Tiestr = nullptr;
		_Fillch = widen(' ');

		if (_Mystrbuf == nullptr)
			setstate(badbit);

		if (_Isstd)
			_Addstd(this);	// special handling for standard streams
		}

	__CLR_OR_THIS_CALL basic_ios()
		{	// default constructor, do nothing
		}

private:
	_Mysb *_Mystrbuf;	// pointer to stream buffer
	_Myos *_Tiestr;	// pointer to tied output stream
	_Elem _Fillch;	// the fill character

public:
	__CLR_OR_THIS_CALL basic_ios(const basic_ios&) = delete;
	basic_ios& __CLR_OR_THIS_CALL operator=(const basic_ios&) = delete;
	};

 #if defined(_DLL_CPPLIB)

  #if !defined(_CRTBLD) || defined(__FORCE_INSTANCE)
template class _CRTIMP2_PURE_IMPORT basic_ios<char,
	char_traits<char> >;
template class _CRTIMP2_PURE_IMPORT basic_ios<wchar_t,
	char_traits<wchar_t> >;
  #endif /* !defined(_CRTBLD) || defined(__FORCE_INSTANCE) */

  #ifdef __FORCE_INSTANCE
template class _CRTIMP2_PURE_IMPORT basic_ios<unsigned short,
	char_traits<unsigned short> >;
  #endif /* __FORCE_INSTANCE */
 #endif /* defined(_DLL_CPPLIB) */

		// MANIPULATORS
inline ios_base& __CLRCALL_OR_CDECL boolalpha(ios_base& _Iosbase)
	{	// set boolalpha
	_Iosbase.setf(ios_base::boolalpha);
	return (_Iosbase);
	}

inline ios_base& __CLRCALL_OR_CDECL dec(ios_base& _Iosbase)
	{	// set basefield to dec
	_Iosbase.setf(ios_base::dec, ios_base::basefield);
	return (_Iosbase);
	}

inline ios_base& __CLRCALL_OR_CDECL defaultfloat(ios_base& _Iosbase)
	{	// clear floatfield
	_Iosbase.unsetf(ios_base::floatfield);
	return (_Iosbase);
	}

inline ios_base& __CLRCALL_OR_CDECL fixed(ios_base& _Iosbase)
	{	// set floatfield to fixed
	_Iosbase.setf(ios_base::fixed, ios_base::floatfield);
	return (_Iosbase);
	}

inline ios_base& __CLRCALL_OR_CDECL hex(ios_base& _Iosbase)
	{	// set basefield to hex
	_Iosbase.setf(ios_base::hex, ios_base::basefield);
	return (_Iosbase);
	}

inline ios_base& __CLRCALL_OR_CDECL hexfloat(ios_base& _Iosbase)
	{	// set floatfield to hexfloat
	_Iosbase.setf(ios_base::hexfloat, ios_base::floatfield);
	return (_Iosbase);
	}

inline ios_base& __CLRCALL_OR_CDECL internal(ios_base& _Iosbase)
	{	// set adjustfield to internal
	_Iosbase.setf(ios_base::internal, ios_base::adjustfield);
	return (_Iosbase);
	}

inline ios_base& __CLRCALL_OR_CDECL left(ios_base& _Iosbase)
	{	// set adjustfield to left
	_Iosbase.setf(ios_base::left, ios_base::adjustfield);
	return (_Iosbase);
	}

inline ios_base& __CLRCALL_OR_CDECL noboolalpha(ios_base& _Iosbase)
	{	// clear boolalpha
	_Iosbase.unsetf(ios_base::boolalpha);
	return (_Iosbase);
	}

inline ios_base& __CLRCALL_OR_CDECL noshowbase(ios_base& _Iosbase)
	{	// clear showbase
	_Iosbase.unsetf(ios_base::showbase);
	return (_Iosbase);
	}

inline ios_base& __CLRCALL_OR_CDECL noshowpoint(ios_base& _Iosbase)
	{	// clear showpoint
	_Iosbase.unsetf(ios_base::showpoint);
	return (_Iosbase);
	}

inline ios_base& __CLRCALL_OR_CDECL noshowpos(ios_base& _Iosbase)
	{	// clear showpos
	_Iosbase.unsetf(ios_base::showpos);
	return (_Iosbase);
	}

inline ios_base& __CLRCALL_OR_CDECL noskipws(ios_base& _Iosbase)
	{	// clear skipws
	_Iosbase.unsetf(ios_base::skipws);
	return (_Iosbase);
	}

inline ios_base& __CLRCALL_OR_CDECL nounitbuf(ios_base& _Iosbase)
	{	// clear unitbuf
	_Iosbase.unsetf(ios_base::unitbuf);
	return (_Iosbase);
	}

inline ios_base& __CLRCALL_OR_CDECL nouppercase(ios_base& _Iosbase)
	{	// clear uppercase
	_Iosbase.unsetf(ios_base::uppercase);
	return (_Iosbase);
	}

inline ios_base& __CLRCALL_OR_CDECL oct(ios_base& _Iosbase)
	{	// set oct in basefield
	_Iosbase.setf(ios_base::oct, ios_base::basefield);
	return (_Iosbase);
	}

inline ios_base& __CLRCALL_OR_CDECL right(ios_base& _Iosbase)
	{	// set right in adjustfield
	_Iosbase.setf(ios_base::right, ios_base::adjustfield);
	return (_Iosbase);
	}

inline ios_base& __CLRCALL_OR_CDECL scientific(ios_base& _Iosbase)
	{	// set scientific in floatfield
	_Iosbase.setf(ios_base::scientific, ios_base::floatfield);
	return (_Iosbase);
	}

inline ios_base& __CLRCALL_OR_CDECL showbase(ios_base& _Iosbase)
	{	// set showbase
	_Iosbase.setf(ios_base::showbase);
	return (_Iosbase);
	}

inline ios_base& __CLRCALL_OR_CDECL showpoint(ios_base& _Iosbase)
	{	// set showpoint
	_Iosbase.setf(ios_base::showpoint);
	return (_Iosbase);
	}

inline ios_base& __CLRCALL_OR_CDECL showpos(ios_base& _Iosbase)
	{	// set showpos
	_Iosbase.setf(ios_base::showpos);
	return (_Iosbase);
	}

inline ios_base& __CLRCALL_OR_CDECL skipws(ios_base& _Iosbase)
	{	// set skipws
	_Iosbase.setf(ios_base::skipws);
	return (_Iosbase);
	}

inline ios_base& __CLRCALL_OR_CDECL unitbuf(ios_base& _Iosbase)
	{	// set unitbuf
	_Iosbase.setf(ios_base::unitbuf);
	return (_Iosbase);
	}

inline ios_base& __CLRCALL_OR_CDECL uppercase(ios_base& _Iosbase)
	{	// set uppercase
	_Iosbase.setf(ios_base::uppercase);
	return (_Iosbase);
	}

#if _HAS_TR1_NAMESPACE
namespace _DEPRECATE_TR1_NAMESPACE tr1 {
using _STD hexfloat;
}
#endif /* _HAS_TR1_NAMESPACE */

_STD_END

 #pragma pop_macro("new")
 _STL_RESTORE_CLANG_WARNINGS
 #pragma warning(pop)
 #pragma pack(pop)
#endif /* RC_INVOKED */
#endif /* _IOS_ */

/*
 * Copyright (c) by P.J. Plauger. All rights reserved.
 * Consult your license regarding permissions and restrictions.
V6.50:0009 */
