#ifndef PRINTABLEH
#define PRINTABLEH
#include <iostream>
#include <sstream>  //for ostringstream
#include <cctype>   //for std::isprint
#include <cwctype>  //for std::iswprint
#include <limits>   //for numeric_limits
#include "except.h"
using namespace std;

template <class CHAR = char>
class basic_printable {
	CHAR c;
	typedef typename char_traits<CHAR>::int_type int_type;

	static bool isprint(CHAR c) throw ();
	static bool isprint(int_type i) throw ();

	static int_type code(CHAR c) throw ();
	static int_type code(int_type i) throw () {return i;}
public:
	basic_printable& operator=(CHAR c) throw (except);
	basic_printable& operator=(int_type i) throw (except);

	basic_printable(CHAR c) throw (except) {*this = c;}
	basic_printable(int_type i) throw (except) {*this = i;}

	operator CHAR() const throw () {
		return c;
	}
};

typedef basic_printable<char> printable_t;
typedef basic_printable<wchar_t> wprintable_t;

template <>
inline bool printable_t::isprint(char c) throw () {
	return std::isprint(static_cast<unsigned char>(c)) != 0;
}

template <>
inline bool printable_t::isprint(char_traits<char>::int_type i) throw () {
	return i >= 0
		&& i <= numeric_limits<unsigned char>::max()
		&& std::isprint(i) != 0;
}

template <>
inline bool wprintable_t::isprint(wchar_t wc) throw () {
	return iswprint(wc) != 0;
}

template <>
inline bool wprintable_t::isprint(char_traits<wchar_t>::int_type i) throw () {
	return i >= numeric_limits<wchar_t>::min()
		&& i <= numeric_limits<wchar_t>::max()
		&& iswprint(i) != 0;
}

template <>
inline char_traits<char>::int_type printable_t::code(char c) throw () {
	return static_cast<unsigned char>(c);
}

template <>
inline char_traits<wchar_t>::int_type wprintable_t::code(wchar_t wc) throw () {
	return wc;
}

template <class CHAR>
basic_printable<CHAR>& basic_printable<CHAR>::operator=(CHAR c) throw (except)
{
	if (!isprint(c)) {
		ostringstream ost;
		ost << "character code " << code(c) << " is not printable";
		throw except(ost);
	}

	this->c = c;
	return *this;
}

template <class CHAR>
basic_printable<CHAR>& basic_printable<CHAR>::operator=(int_type i)
	throw (except)
{
	if (!isprint(i)) {
		ostringstream ost;
		ost << "character code " << code(i) << " is not printable";
		throw except(ost);
	}

	c = i;
	return *this;
}

template <class CHAR>
inline basic_printable<CHAR>&
operator+=(basic_printable<CHAR>& p, typename char_traits<CHAR>::int_type i)
	throw (except) {
	return p = static_cast<CHAR>(p) + i;
}

template <class CHAR>
inline basic_printable<CHAR>&
operator-=(basic_printable<CHAR>& p, typename char_traits<CHAR>::int_type i)
	throw (except) {
	return p = static_cast<CHAR>(p) - i;
}

template <class CHAR>
inline basic_printable<CHAR>&
operator++(basic_printable<CHAR>& p) throw (except) {
	return p += 1;
}

template <class CHAR>
inline basic_printable<CHAR>&
operator--(basic_printable<CHAR>& p) throw (except) {
	return p -= 1;
}

template <class CHAR>
inline const basic_printable<CHAR>
operator++(basic_printable<CHAR>& p, int) throw (except) {
	const basic_printable<CHAR> old = p;
	++p;
	return old;
}

template <class CHAR>
inline const basic_printable<CHAR>
operator--(basic_printable<CHAR>& p, int) throw (except) {
	const basic_printable<CHAR> old = p;
	--p;
	return old;
}

template <class CHAR>
inline const basic_printable<CHAR>
operator+(basic_printable<CHAR> p, int i) throw (except) {
	return p += i;
}

template <class CHAR>
inline const basic_printable<CHAR>
operator+(int i, basic_printable<CHAR> p) throw (except) {
	return p += i;
}

template <class CHAR>
inline const basic_printable<CHAR>
operator-(basic_printable<CHAR> p, int i) throw (except) {
	return p -= i;
}

template <class CHAR>
static basic_istream<CHAR>&
operator>>(basic_istream<CHAR>& ist, basic_printable<CHAR>& p) throw (except)
{
        CHAR c;           //uninitialized variable

        if (ist >> c) {   //if (operator>>(ist, c).operator void *()) {
                p = c;        //p.operator=(c);
        }

        return ist;
}

inline wostream& operator<<(wostream& ost, wprintable_t& p) throw () {
	return ost << static_cast<wchar_t>(p);
}

inline bool operator<(const printable_t& a, const printable_t& b) {
	return static_cast<char>(a) < static_cast<char>(b);
}

inline bool operator<(const wprintable_t& a, const wprintable_t& b) {
	return static_cast<wchar_t>(a) < static_cast<wchar_t>(b);
}

inline bool operator==(const printable_t& a, const printable_t& b) {
	return static_cast<char>(a) == static_cast<char>(b);
}

inline bool operator==(const wprintable_t& a, const wprintable_t& b) {
	return static_cast<wchar_t>(a) == static_cast<wchar_t>(b);
}

inline bool operator<=(const printable_t& a, const printable_t& b) {
	return static_cast<char>(a) <= static_cast<char>(b);
}

inline bool operator<=(const wprintable_t& a, const wprintable_t& b) {
	return static_cast<wchar_t>(a) <= static_cast<wchar_t>(b);
}

inline bool operator!=(const printable_t& a, const printable_t& b) {
	return !(a == b);
}

inline bool operator!=(const wprintable_t& a, const wprintable_t& b) {
	return !(a == b);
}

inline bool operator>(const printable_t& a, const printable_t& b) {
	return b < a;
}

inline bool operator>(const wprintable_t& a, const wprintable_t& b) {
	return b < a;
}

inline bool operator>=(const printable_t& a, const printable_t& b) {
	return b <= a;
}

inline bool operator>=(const wprintable_t& a, const wprintable_t& b) {
	return b <= a;
}
#endif