boost/logic/tribool_io.hpp
// Three-state boolean logic library
// Copyright Douglas Gregor 2002-2004. Use, modification and
// distribution is subject to the Boost Software License, Version
// 1.0. (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#ifndef BOOST_LOGIC_TRIBOOL_IO_HPP
#define BOOST_LOGIC_TRIBOOL_IO_HPP
#include <boost/logic/tribool.hpp>
#include <boost/detail/workaround.hpp>
#include <boost/noncopyable.hpp>
#if BOOST_WORKAROUND(_MSC_VER, >= 1200)
# pragma once
#endif
#ifndef BOOST_NO_STD_LOCALE
# include <locale>
#endif
#include <string>
#include <iostream>
namespace boost { namespace logic {
#ifdef BOOST_NO_STD_LOCALE
/**
* \brief Returns a string containing the default name for the \c
* false value of a tribool with the given character type T.
*
* This function only exists when the C++ standard library
* implementation does not support locales.
*/
template<typename T> std::basic_string<T> default_false_name();
/**
* \brief Returns the character string "false".
*
* This function only exists when the C++ standard library
* implementation does not support locales.
*/
template<>
inline std::basic_string<char> default_false_name<char>()
{ return "false"; }
# ifndef BOOST_NO_WCHAR_T
/**
* \brief Returns the wide character string L"false".
*
* This function only exists when the C++ standard library
* implementation does not support locales.
*/
template<>
inline std::basic_string<wchar_t> default_false_name<wchar_t>()
{ return L"false"; }
# endif
/**
* \brief Returns a string containing the default name for the \c true
* value of a tribool with the given character type T.
*
* This function only exists when the C++ standard library
* implementation does not support locales.
*/
template<typename T> std::basic_string<T> default_true_name();
/**
* \brief Returns the character string "true".
*
* This function only exists when the C++ standard library
* implementation does not support locales.
*/
template<>
inline std::basic_string<char> default_true_name<char>()
{ return "true"; }
# ifndef BOOST_NO_WCHAR_T
/**
* \brief Returns the wide character string L"true".
*
* This function only exists * when the C++ standard library
* implementation does not support * locales.
*/
template<>
inline std::basic_string<wchar_t> default_true_name<wchar_t>()
{ return L"true"; }
# endif
#endif
/**
* \brief Returns a string containing the default name for the indeterminate
* value of a tribool with the given character type T.
*
* This routine is used by the input and output streaming operators
* for tribool when there is no locale support or the stream's locale
* does not contain the indeterminate_name facet.
*/
template<typename T> std::basic_string<T> get_default_indeterminate_name();
/// Returns the character string "indeterminate".
template<>
inline std::basic_string<char> get_default_indeterminate_name<char>()
{ return "indeterminate"; }
#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
// VC++ 6.0 chokes on the specialization below, so we're stuck without
// wchar_t support. What a pain. TODO: it might just need a the template
// parameter as function parameter...
#else
# ifndef BOOST_NO_WCHAR_T
/// Returns the wide character string L"indeterminate".
template<>
inline std::basic_string<wchar_t> get_default_indeterminate_name<wchar_t>()
{ return L"indeterminate"; }
# endif
#endif
// http://www.cantrip.org/locale.html
#ifndef BOOST_NO_STD_LOCALE
/**
* \brief A locale facet specifying the name of the indeterminate
* value of a tribool.
*
* The facet is used to perform I/O on tribool values when \c
* std::boolalpha has been specified. This class template is only
* available if the C++ standard library implementation supports
* locales.
*/
template<typename CharT>
class indeterminate_name : public std::locale::facet, private boost::noncopyable
{
public:
typedef CharT char_type;
typedef std::basic_string<CharT> string_type;
/// Construct the facet with the default name
indeterminate_name() : name_(get_default_indeterminate_name<CharT>()) {}
/// Construct the facet with the given name for the indeterminate value
explicit indeterminate_name(const string_type& initial_name)
: name_(initial_name) {}
/// Returns the name for the indeterminate value
string_type name() const { return name_; }
/// Uniquily identifies this facet with the locale.
static std::locale::id id;
private:
string_type name_;
};
template<typename CharT> std::locale::id indeterminate_name<CharT>::id;
#endif
/**
* \brief Writes the value of a tribool to a stream.
*
* When the value of @p x is either \c true or \c false, this routine
* is semantically equivalent to:
* \code out << static_cast<bool>(x); \endcode
*
* When @p x has an indeterminate value, it outputs either the integer
* value 2 (if <tt>(out.flags() & std::ios_base::boolalpha) == 0</tt>)
* or the name of the indeterminate value. The name of the
* indeterminate value comes from the indeterminate_name facet (if it
* is defined in the output stream's locale), or from the
* get_default_indeterminate_name function (if it is not defined in the
* locale or if the C++ standard library implementation does not
* support locales).
*
* \returns @p out
*/
template<typename CharT, typename Traits>
inline std::basic_ostream<CharT, Traits>&
operator<<(std::basic_ostream<CharT, Traits>& out, tribool x)
{
if (!indeterminate(x)) {
out << static_cast<bool>(x);
} else {
typename std::basic_ostream<CharT, Traits>::sentry cerberus(out);
if (cerberus) {
if (out.flags() & std::ios_base::boolalpha) {
#ifndef BOOST_NO_STD_LOCALE
if (BOOST_HAS_FACET(indeterminate_name<CharT>, out.getloc())) {
const indeterminate_name<CharT>& facet =
BOOST_USE_FACET(indeterminate_name<CharT>, out.getloc());
out << facet.name();
} else {
out << get_default_indeterminate_name<CharT>();
}
#else
out << get_default_indeterminate_name<CharT>();
#endif
}
else
out << 2;
}
}
return out;
}
/**
* \brief Writes the indeterminate tribool value to a stream.
*
* This routine outputs either the integer
* value 2 (if <tt>(out.flags() & std::ios_base::boolalpha) == 0</tt>)
* or the name of the indeterminate value. The name of the
* indeterminate value comes from the indeterminate_name facet (if it
* is defined in the output stream's locale), or from the
* get_default_indeterminate_name function (if it is not defined in the
* locale or if the C++ standard library implementation does not
* support locales).
*
* \returns @p out
*/
template<typename CharT, typename Traits>
inline std::basic_ostream<CharT, Traits>&
operator<<(std::basic_ostream<CharT, Traits>& out,
bool (*)(tribool, detail::indeterminate_t))
{ return out << tribool(indeterminate); }
/**
* \brief Reads a tribool value from a stream.
*
* When <tt>(out.flags() & std::ios_base::boolalpha) == 0</tt>, this
* function reads a \c long value from the input stream @p in and
* converts that value to a tribool. If that value is 0, @p x becomes
* \c false; if it is 1, @p x becomes \c true; if it is 2, @p becomes
* \c indetermine; otherwise, the operation fails (and the fail bit is
* set on the input stream @p in).
*
* When <tt>(out.flags() & std::ios_base::boolalpha) != 0</tt>, this
* function first determines the names of the false, true, and
* indeterminate values. The false and true names are extracted from
* the \c std::numpunct facet of the input stream's locale (if the C++
* standard library implementation supports locales), or from the \c
* default_false_name and \c default_true_name functions (if there is
* no locale support). The indeterminate name is extracted from the
* appropriate \c indeterminate_name facet (if it is available in the
* input stream's locale), or from the \c get_default_indeterminate_name
* function (if the C++ standard library implementation does not
* support locales, or the \c indeterminate_name facet is not
* specified for this locale object). The input is then matched to
* each of these names, and the tribool @p x is assigned the value
* corresponding to the longest name that matched. If no name is
* matched or all names are empty, the operation fails (and the fail
* bit is set on the input stream @p in).
*
* \returns @p in
*/
template<typename CharT, typename Traits>
inline std::basic_istream<CharT, Traits>&
operator>>(std::basic_istream<CharT, Traits>& in, tribool& x)
{
if (in.flags() & std::ios_base::boolalpha) {
typename std::basic_istream<CharT, Traits>::sentry cerberus(in);
if (cerberus) {
typedef std::basic_string<CharT> string_type;
#ifndef BOOST_NO_STD_LOCALE
const std::numpunct<CharT>& numpunct_facet =
BOOST_USE_FACET(std::numpunct<CharT>, in.getloc());
string_type falsename = numpunct_facet.falsename();
string_type truename = numpunct_facet.truename();
string_type othername;
if (BOOST_HAS_FACET(indeterminate_name<CharT>, in.getloc())) {
othername =
BOOST_USE_FACET(indeterminate_name<CharT>, in.getloc()).name();
} else {
othername = get_default_indeterminate_name<CharT>();
}
#else
string_type falsename = default_false_name<CharT>();
string_type truename = default_true_name<CharT>();
string_type othername = get_default_indeterminate_name<CharT>();
#endif
typename string_type::size_type pos = 0;
bool falsename_ok = true, truename_ok = true, othername_ok = true;
// Modeled after the code from Library DR 17
while (falsename_ok && pos < falsename.size()
|| truename_ok && pos < truename.size()
|| othername_ok && pos < othername.size()) {
typename Traits::int_type c = in.get();
if (c == Traits::eof())
return in;
bool matched = false;
if (falsename_ok && pos < falsename.size()) {
if (Traits::eq(Traits::to_char_type(c), falsename[pos]))
matched = true;
else
falsename_ok = false;
}
if (truename_ok && pos < truename.size()) {
if (Traits::eq(Traits::to_char_type(c), truename[pos]))
matched = true;
else
truename_ok = false;
}
if (othername_ok && pos < othername.size()) {
if (Traits::eq(Traits::to_char_type(c), othername[pos]))
matched = true;
else
othername_ok = false;
}
if (matched) { ++pos; }
if (pos > falsename.size()) falsename_ok = false;
if (pos > truename.size()) truename_ok = false;
if (pos > othername.size()) othername_ok = false;
}
if (pos == 0)
in.setstate(std::ios_base::failbit);
else {
if (falsename_ok) x = false;
else if (truename_ok) x = true;
else if (othername_ok) x = indeterminate;
else in.setstate(std::ios_base::failbit);
}
}
} else {
long value;
if (in >> value) {
switch (value) {
case 0: x = false; break;
case 1: x = true; break;
case 2: x = indeterminate; break;
default: in.setstate(std::ios_base::failbit); break;
}
}
}
return in;
}
} } // end namespace boost::logic
#endif // BOOST_LOGIC_TRIBOOL_IO_HPP