//	Distributed under the Boost Software License Version 1.0 https://www.boost.org/LICENSE_1_0.txt
//	Copyright Gero Peterhoff

#ifndef BOOST_UTILITY_IOS_HPP
#define BOOST_UTILITY_IOS_HPP

#include <cstdint>
#include <iostream>
#include <algorithm>
#include <boost/config.hpp>

#if !defined(BOOST_NO_CXX17_HDR_CHARCONV)
#include <charconv>
#endif



namespace boost
{
constexpr std::ios_base::fmtflags
	defaultfloat{},
	hexfloat{std::ios_base::fixed | std::ios_base::scientific};



inline constexpr std::ios_base::fmtflags	get_flags(const std::ios_base::fmtflags flags, const std::ios_base::fmtflags mask)	noexcept
{
	return flags & mask;
}

inline std::ios_base::fmtflags	get_flags(const std::ios_base& stream, const std::ios_base::fmtflags mask)	noexcept
{
	return get_flags(stream.flags(), mask);
}

inline size_t	get_base(const std::ios_base& stream)		noexcept
{
	switch (get_flags(stream, std::ios_base::basefield))
	{
		case std::ios_base::hex:	return 16;
		case std::ios_base::dec:	return 10;
		case std::ios_base::oct:	return  8;
		//case std::ios_base::bin:	return  2;
		default:					return  0;
	}
}

inline size_t	get_precision(const std::ios_base& stream)	noexcept
{
	//	return 0 if stream.precision()<=0 else stream.precision()
	return size_t(std::max(stream.precision(), std::streamsize{0}));
}

inline size_t	get_width(const std::ios_base& stream)		noexcept
{
	//	return 0 if stream.width()<=0 else stream.width()
	return size_t(std::max(stream.width(), std::streamsize{0}));
}

inline bool	is_boolalpha(const std::ios_base& stream)	noexcept	{ return get_flags(stream, std::ios_base::boolalpha)	== std::ios_base::boolalpha;}
inline bool	is_showbase(const std::ios_base& stream)	noexcept	{ return get_flags(stream, std::ios_base::showbase)		== std::ios_base::showbase;	}
inline bool	is_showpoint(const std::ios_base& stream)	noexcept	{ return get_flags(stream, std::ios_base::showpoint)	== std::ios_base::showpoint;}
inline bool	is_showpos(const std::ios_base& stream)		noexcept	{ return get_flags(stream, std::ios_base::showpos)		== std::ios_base::showpos;	}
inline bool	is_skipws(const std::ios_base& stream)		noexcept	{ return get_flags(stream, std::ios_base::skipws)		== std::ios_base::skipws;	}
inline bool	is_unitbuf(const std::ios_base& stream)		noexcept	{ return get_flags(stream, std::ios_base::unitbuf)		== std::ios_base::unitbuf;	}
inline bool	is_uppercase(const std::ios_base& stream)	noexcept	{ return get_flags(stream, std::ios_base::uppercase)	== std::ios_base::uppercase;}

inline bool	is_internal(const std::ios_base& stream)	noexcept	{ return get_flags(stream, std::ios_base::adjustfield)	== std::ios_base::internal;	}
inline bool	is_right(const std::ios_base& stream)		noexcept	{ return get_flags(stream, std::ios_base::adjustfield)	== std::ios_base::right;	}
inline bool	is_left(const std::ios_base& stream)		noexcept	{ return get_flags(stream, std::ios_base::adjustfield)	== std::ios_base::left;		}

inline bool	is_hex(const std::ios_base& stream)			noexcept	{ return get_flags(stream, std::ios_base::basefield)	== std::ios_base::hex;		}
inline bool	is_dec(const std::ios_base& stream)			noexcept	{ return get_flags(stream, std::ios_base::basefield)	== std::ios_base::dec;		}
inline bool	is_oct(const std::ios_base& stream)			noexcept	{ return get_flags(stream, std::ios_base::basefield)	== std::ios_base::oct;		}
//inline bool	is_bin(const std::ios_base& stream)		noexcept	{ return get_flags(stream, std::ios_base::basefield)	== std::ios_base::bin;		}

inline bool	is_floating_point_scientific(const std::ios_base& stream)	noexcept	{ return get_flags(stream, std::ios_base::floatfield) == std::ios_base::scientific;	}
inline bool	is_floating_point_default(const std::ios_base& stream)		noexcept	{ return get_flags(stream, std::ios_base::floatfield) == defaultfloat;				}
inline bool	is_floating_point_fixed(const std::ios_base& stream)		noexcept	{ return get_flags(stream, std::ios_base::floatfield) == std::ios_base::fixed;		}
inline bool	is_floating_point_hex(const std::ios_base& stream)			noexcept	{ return get_flags(stream, std::ios_base::floatfield) == hexfloat;					}
//inline bool	is_floating_point_bin(const std::ios_base& stream)		noexcept	{ return get_flags(stream, std::ios_base::floatfield) == binfloat;					}



#if !defined(BOOST_NO_CXX17_HDR_CHARCONV)
inline constexpr std::chars_format			to_floating_point_format(const std::ios_base::fmtflags flags)	noexcept
{
	//	convert stream::floatfield to FP chars_format
	switch (get_flags(flags, std::ios_base::floatfield))
	{
		case std::ios_base::scientific:	return std::chars_format::scientific;
		case std::ios_base::fixed:		return std::chars_format::fixed;
		case hexfloat:					return std::chars_format::hex;
		default:						return std::chars_format::general;
	}
}

inline constexpr std::ios_base::fmtflags	to_floating_point_flags(const std::chars_format fmt)	noexcept
{
	//	convert FP chars_format to stream::floatfield
	switch (fmt)
	{
		case std::chars_format::scientific:	return std::ios_base::scientific;
		case std::chars_format::fixed:		return std::ios_base::fixed;
		case std::chars_format::hex:		return hexfloat;
		default:							return defaultfloat;
	}
}

inline std::chars_format	get_floating_point_format(const std::ios_base& stream)	noexcept
{
	//	get stream::floatfield as FP chars_format
	return to_floating_point_format(stream.flags());
}

inline std::ios_base&		set_floating_point_format(std::ios_base& stream, const std::chars_format fmt)	noexcept
{
	//	set FP chars_format in stream::floatfield
	stream.setf(to_floating_point_flags(fmt), std::ios_base::floatfield);
	return stream;
}
#endif	//	BOOST_NO_CXX17_HDR_CHARCONV



//	handle numeric output for u/int8_t
template <typename Type>
inline constexpr const Type&	to_print(const Type& arg)		noexcept	{ return arg;	}
inline constexpr unsigned		to_print(const uint8_t& arg)	noexcept	{ return arg;	}
inline constexpr signed			to_print(const int8_t& arg)		noexcept	{ return arg;	}
}	//	boost



namespace std
{
#if !defined(BOOST_NO_CXX17_HDR_CHARCONV)
//	like setbase, setprecision, ...
struct setfloat
{
protected:
	const chars_format
		value;

public:
	inline constexpr setfloat(const chars_format& fmt) noexcept : value{fmt}	{}
	inline friend ios_base&	operator<<(ios_base& stream, const setfloat& fmt)	noexcept
	{
		return boost::set_floating_point_format(stream, fmt.value);
	}
};
#endif	//	BOOST_NO_CXX17_HDR_CHARCONV



template <typename Char, typename Traits>
inline basic_ostream<Char, Traits>&	cr(basic_ostream<Char, Traits>& stream)		noexcept
{
	//	carriage return
	return stream.put(Char('\r'));
}

template <typename Char, typename Traits>
inline basic_ostream<Char, Traits>&	ff(basic_ostream<Char, Traits>& stream)		noexcept
{
	//	form feed
	return stream.put(Char('\f'));
}

template <typename Char, typename Traits>
inline basic_ostream<Char, Traits>&	tab(basic_ostream<Char, Traits>& stream)	noexcept
{
	//	horizontal tab
	return stream.put(Char('\t'));
}

template <typename Char, typename Traits>
inline basic_ostream<Char, Traits>&	vtab(basic_ostream<Char, Traits>& stream)	noexcept
{
	//	vertical tab
	return stream.put(Char('\v'));
}
}	//	std

#endif	//	BOOST_UTILITY_IOS_HPP