Merge changes from develop for the 1.58.0 release

C++11 updates for tribool: added noexcepts and constexprs, fixed warnings

Tested on Linux with gcc-4.9.1.

doc/Jamfile.v2

@@ -0,0 +1,26 @@
+# Tribool library
+
+# Copyright (C) 2002-2003 Douglas Gregor
+
+# 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)
+
+# For more information, see http://www.boost.org/
+
+project boost-sandbox/utility/doc ;
+import boostbook ;
+import doxygen ;
+
+doxygen reference : [ glob ../../../boost/logic/tribool.hpp ]
+                    [ glob ../../../boost/logic/tribool_fwd.hpp ]
+                    [ glob ../../../boost/logic/tribool_io.hpp ]
+                  ;
+boostbook tribool 
+    : 
+    tribool.boostbook 
+    :
+        <xsl:param>boost.root=../../../..
+        <format>pdf:<xsl:param>boost.url.prefix=http://www.boost.org/doc/libs/release/doc/html
+        <dependency>reference
+    ;

doc/tribool.boostbook

@@ -0,0 +1,231 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!DOCTYPE library PUBLIC "-//Boost//DTD BoostBook XML V1.0//EN"
+  "http://www.boost.org/tools/boostbook/dtd/boostbook.dtd">
+<library name="Tribool" dirname="logic" id="tribool"
+         last-revision="$Date: 2007/05/03 03:28:53 $" xmlns:xi="http://www.w3.org/2001/XInclude">
+  <libraryinfo>
+    <author>
+      <firstname>Douglas</firstname>
+      <surname>Gregor</surname>
+      <email>dgregor -at- cs.indiana.edu</email>
+    </author>
+
+    <copyright>
+      <year>2002</year>
+      <year>2003</year>
+      <year>2004</year>
+      <holder>Douglas Gregor</holder>
+    </copyright>    
+
+    <legalnotice>
+      <para>Use, modification and distribution is subject to the Boost
+    Software License, Version 1.0. (See accompanying file
+    <filename>LICENSE_1_0.txt</filename> or copy at <ulink
+    url="http://www.boost.org/LICENSE_1_0.txt">http://www.boost.org/LICENSE_1_0.txt</ulink>)</para>
+    </legalnotice>
+
+    <librarypurpose>Three-state boolean type</librarypurpose>
+    <librarycategory name="category:misc"/>
+  </libraryinfo>
+
+  <title>Boost.Tribool</title>
+
+  <section id="tribool.introduction">
+    <title>Introduction</title>
+
+    <para>The 3-state boolean library contains a single class,
+    <code><classname>boost::logic::tribool</classname></code>, along with
+    support functions and operator overloads that implement 3-state
+    boolean logic. </para>
+  </section>
+
+  <section id="tribool.tutorial">
+    <title>Tutorial</title>
+
+    <using-namespace name="boost::logic"/>
+
+    <section>
+      <title>Basic usage</title>
+    <para> The <code><classname>tribool</classname></code> class acts
+    like the built-in <code>bool</code> type, but for 3-state boolean
+    logic. The three states are <code>true</code>, <code>false</code>,
+    and <code><functionname>indeterminate</functionname></code>, where
+    the first two states are equivalent to those of the C++
+    <code>bool</code> type and the last state represents an unknown
+    boolean value (that may be <code>true</code> or
+    <code>false</code>, we don't know).</para>
+
+    <para> The <code><classname>tribool</classname></code> class
+    supports conversion from <code>bool</code> values and literals
+    along with its own
+    <code><functionname>indeterminate</functionname></code>
+    keyword:</para>
+
+    <programlisting><classname>tribool</classname> b(true);
+b = false;
+b = <functionname>indeterminate</functionname>;
+<classname>tribool</classname> b2(b);</programlisting>
+
+    <para> <code><classname>tribool</classname></code> supports
+    conversions to <code>bool</code> for use in conditional
+    statements. The conversion to <code>bool</code> will be
+    <code>true</code> when the value of the
+    <code><classname>tribool</classname></code> is always true, and
+    <code>false</code> otherwise. Consequently, the following idiom
+    may be used to determine which of the three states a
+    <code><classname>tribool</classname></code> currently
+    holds:</para>
+
+<programlisting><classname>tribool</classname> b = some_operation();
+if (b) {
+  // b is true
+}
+else if (!b) {
+  // b is false
+}
+else {
+  // b is indeterminate
+}</programlisting>
+
+  <para> <code><classname>tribool</classname></code> supports the
+  3-state logic operators <code>!</code> (negation),
+  <code>&amp;&amp;</code> (AND), and <code>||</code> (OR), with
+  <code>bool</code> and <code><classname>tribool</classname></code>
+  values. For instance:</para>
+
+  <programlisting><classname>tribool</classname> x = some_op();
+<classname>tribool</classname> y = some_other_op();
+if (x &amp;&amp; y) {
+  // both x and y are true
+}
+else if (!(x &amp;&amp; y)) {
+  // either x or y is false
+}
+else {
+  // neither x nor y is false, but we don't know that both are true
+
+  if (x || y) {
+    // either x or y is true
+  }
+}</programlisting>
+
+  <para> Similarly, <code><classname>tribool</classname></code>
+  supports 3-state equality comparisons via the operators
+  <code>==</code> and <code>!=</code>. These operators differ from
+  "normal" equality operators in C++ because they return a
+  <code><classname>tribool</classname></code>, because potentially we
+  might not know the result of a comparison (try to compare
+  <code>true</code> and
+  <code><functionname>indeterminate</functionname></code>). For
+  instance:</para>
+
+<programlisting><classname>tribool</classname> x(true);
+<classname>tribool</classname> y(<functionname>indeterminate</functionname>);
+
+assert(x == x); // okay, x == x returns true
+assert(x == true); // okay, can compare <classname>tribool</classname>s and bools</programlisting>
+
+  <para> The <code><functionname>indeterminate</functionname></code> keyword (representing the
+  <functionname>indeterminate</functionname>&nbsp;<code><classname>tribool</classname></code> value)
+  doubles as a function to check if the value of a
+  <code><classname>tribool</classname></code> is indeterminate,
+  e.g.,</para>
+ 
+  <programlisting><classname>tribool</classname> x = try_to_do_something_tricky();
+if (<functionname>indeterminate</functionname>(x)) {
+  // value of x is indeterminate
+}
+else {
+  // report success or failure of x
+}</programlisting>
+
+  <para> All the logical operators and methods of <code><classname>tribool</classname></code> are marked
+  as <code>constexpr</code> in C++11. It means that <code><classname>tribool</classname></code> can
+  be used in compile time expressions:</para>
+
+  <programlisting>constexpr <classname>tribool</classname> x = (tribool(true) || tribool(indeterminate));
+<functionname>static_assert</functionname>(x, "Must be true!");
+</programlisting>
+
+  <note>Some compilers may have troubles with evaluating <code>tribool::operator safe_bool()</code> at compile time.</note>
+
+
+</section>
+  
+  <section>
+    <title>Renaming the indeterminate state</title>
+  <para> Users may introduce additional keywords for the indeterminate
+  value in addition to the implementation-supplied
+  <code><functionname>indeterminate</functionname></code> using the
+  <code><macroname>BOOST_TRIBOOL_THIRD_STATE</macroname></code>
+  macro. For instance, the following macro instantiation (at the
+  global scope) will introduce the keyword <code>maybe</code> as a
+  synonym for <code><functionname>indeterminate</functionname></code>
+  (also residing in the <code>boost</code> namespace):</para>
+  <programlisting><macroname>BOOST_TRIBOOL_THIRD_STATE</macroname>(maybe)
+<classname>tribool</classname> x = maybe;
+if (maybe(x)) { /* ... */ }</programlisting>
+  </section>
+
+  <section>
+    <title><code>tribool</code> input/output</title>
+  <para><code><classname>tribool</classname></code> objects may be
+  read from and written to streams by including the
+  <headername>boost/logic/tribool_io.hpp</headername> header in a
+  manner very similar to <code>bool</code> values. When the
+  <code>boolalpha</code> flag is not set on the input/output stream,
+  the integral values 0, 1, and 2 correspond to <code>tribool</code>
+  values <code>false</code>, <code>true</code>, and
+  <code>indeterminate</code>, respectively. When
+  <code>boolalpha</code> is set on the stream, arbitrary strings can
+  be used to represent the three values, the default being "false",
+  "true", and "indeterminate". For instance:</para>
+<programlisting><classname>tribool</classname> x;
+cin &gt;&gt; x; // Type "0", "1", or "2" to get false, true, or indeterminate
+cout &lt;&lt; boolalpha &lt;&lt; x; // Produces "false", "true", or "indeterminate"</programlisting>
+
+  <para><code><classname>tribool</classname></code> input and output
+  is sensitive to the stream's current locale. The strings associated
+  with false and true values are contained in the standard
+  <code><classname>std::numpunct</classname></code> facet, and the
+  string naming the indeterminate type is contained in the
+  <code><classname>indeterminate_name</classname></code> facet. To
+  replace the name of the indeterminate state, you need to imbue your
+  stream with a local containing a
+  <code><classname>indeterminate_name</classname></code> facet, e.g.:</para>
+
+  <programlisting><macroname>BOOST_TRIBOOL_THIRD_STATE</macroname>(maybe)
+locale global;
+locale test_locale(global, new <classname>indeterminate_name</classname>&lt;char&gt;("maybe"));
+cout.imbue(test_locale);
+<classname>tribool</classname> x(maybe);
+cout &lt;&lt; boolalpha &lt;&lt; x &lt;&lt; endl; // Prints "maybe"</programlisting>
+
+  <para>If you C++ standard library implementation does not support
+  locales, <code>tribool</code> input/output will still work, but you
+  will be unable to customize the strings printed/parsed when
+  <code>boolalpha</code> is set.</para>
+  </section>
+
+  </section>
+
+  <xi:include href="reference.xml"/>
+
+  <testsuite id="tribool.tests">
+    <run-test filename="tribool_test.cpp">
+      <purpose><para>Test all features of the
+      <code><classname>boost::logic::tribool</classname></code>
+      class.</para></purpose>
+    </run-test>
+
+    <run-test filename="tribool_rename_test.cpp">
+      <purpose><para>Test the use of the
+      <code><macroname>BOOST_TRIBOOL_THIRD_STATE</macroname></code>
+      macro.</para></purpose>
+    </run-test>
+
+    <run-test filename="tribool_io_test.cpp">
+      <purpose><para>Test tribool input/output.</para></purpose>
+    </run-test>
+  </testsuite>
+</library>

include/boost/logic/tribool.hpp

@@ -14,7 +14,7 @@
 #include <boost/config.hpp>
 #include <boost/detail/workaround.hpp>
 
-#if BOOST_WORKAROUND(_MSC_VER, >= 1200)
+#ifdef BOOST_HAS_PRAGMA_ONCE
 #  pragma once
 #endif
 
@@ -59,9 +59,9 @@ typedef bool (*indeterminate_keyword_t)(tribool, detail::indeterminate_t);
  * \returns <tt>x.value == tribool::indeterminate_value</tt>
  * \throws nothrow
  */
-inline bool
+BOOST_CONSTEXPR inline bool
 indeterminate(tribool x,
-              detail::indeterminate_t dummy = detail::indeterminate_t());
+              detail::indeterminate_t dummy = detail::indeterminate_t()) BOOST_NOEXCEPT;
 
 /**
  * \brief A 3-state boolean type.
@@ -85,7 +85,7 @@ public:
    *
    * \throws nothrow
    */
-  tribool() : value(false_value) {}
+  BOOST_CONSTEXPR tribool() BOOST_NOEXCEPT : value(false_value) {}
 
   /**
    * Construct a new 3-state boolean value with the given boolean
@@ -93,14 +93,14 @@ public:
    *
    * \throws nothrow
    */
-  tribool(bool value) : value(value? true_value : false_value) {}
+  BOOST_CONSTEXPR tribool(bool initial_value) BOOST_NOEXCEPT : value(initial_value? true_value : false_value) {}
 
   /**
    * Construct a new 3-state boolean value with an indeterminate value.
    *
    * \throws nothrow
    */
-  tribool(indeterminate_keyword_t) : value(indeterminate_value) {}
+  BOOST_CONSTEXPR tribool(indeterminate_keyword_t) BOOST_NOEXCEPT : value(indeterminate_value) {}
 
   /**
    * Use a 3-state boolean in a boolean context. Will evaluate true in a
@@ -109,7 +109,7 @@ public:
    * \returns true if the 3-state boolean is true, false otherwise
    * \throws nothrow
    */
-  operator safe_bool() const
+  BOOST_CONSTEXPR operator safe_bool() const BOOST_NOEXCEPT
   {
     return value == true_value? &dummy::nonnull : 0;
   }
@@ -123,7 +123,7 @@ public:
 
 // Check if the given tribool has an indeterminate value. Also doubles as a
 // keyword for the 'indeterminate' value
-inline bool indeterminate(tribool x, detail::indeterminate_t)
+BOOST_CONSTEXPR inline bool indeterminate(tribool x, detail::indeterminate_t) BOOST_NOEXCEPT
 {
   return x.value == tribool::indeterminate_value;
 }
@@ -156,7 +156,7 @@ inline bool indeterminate(tribool x, detail::indeterminate_t)
  *  </table>
  * \throws nothrow
  */
-inline tribool operator!(tribool x)
+BOOST_CONSTEXPR inline tribool operator!(tribool x) BOOST_NOEXCEPT
 {
   return x.value == tribool::false_value? tribool(true)
         :x.value == tribool::true_value? tribool(false)
@@ -196,38 +196,36 @@ inline tribool operator!(tribool x)
  *       </table>
  * \throws nothrow
  */
-inline tribool operator&&(tribool x, tribool y)
+BOOST_CONSTEXPR inline tribool operator&&(tribool x, tribool y) BOOST_NOEXCEPT
 {
-  if (static_cast<bool>(!x) || static_cast<bool>(!y))
-    return false;
-  else if (static_cast<bool>(x) && static_cast<bool>(y))
-    return true;
-  else
-    return indeterminate;
+  return (static_cast<bool>(!x) || static_cast<bool>(!y))
+    ? tribool(false)
+    : ((static_cast<bool>(x) && static_cast<bool>(y)) ? tribool(true) : indeterminate)
+  ;
 }
 
 /**
  * \overload
  */
-inline tribool operator&&(tribool x, bool y)
+BOOST_CONSTEXPR inline tribool operator&&(tribool x, bool y) BOOST_NOEXCEPT
 { return y? x : tribool(false); }
 
 /**
  * \overload
  */
-inline tribool operator&&(bool x, tribool y)
+BOOST_CONSTEXPR inline tribool operator&&(bool x, tribool y) BOOST_NOEXCEPT
 { return x? y : tribool(false); }
 
 /**
  * \overload
  */
-inline tribool operator&&(indeterminate_keyword_t, tribool x)
+BOOST_CONSTEXPR inline tribool operator&&(indeterminate_keyword_t, tribool x) BOOST_NOEXCEPT
 { return !x? tribool(false) : tribool(indeterminate); }
 
 /**
  * \overload
  */
-inline tribool operator&&(tribool x, indeterminate_keyword_t)
+BOOST_CONSTEXPR inline tribool operator&&(tribool x, indeterminate_keyword_t) BOOST_NOEXCEPT
 { return !x? tribool(false) : tribool(indeterminate); }
 
 /**
@@ -263,38 +261,36 @@ inline tribool operator&&(tribool x, indeterminate_keyword_t)
  *       </table>
  *  \throws nothrow
  */
-inline tribool operator||(tribool x, tribool y)
+BOOST_CONSTEXPR inline tribool operator||(tribool x, tribool y) BOOST_NOEXCEPT
 {
-  if (static_cast<bool>(!x) && static_cast<bool>(!y))
-    return false;
-  else if (static_cast<bool>(x) || static_cast<bool>(y))
-    return true;
-  else
-    return indeterminate;
+  return (static_cast<bool>(!x) && static_cast<bool>(!y))
+    ? tribool(false)
+    : ((static_cast<bool>(x) || static_cast<bool>(y)) ? tribool(true) : tribool(indeterminate))
+  ;
 }
 
 /**
  * \overload
  */
-inline tribool operator||(tribool x, bool y)
+BOOST_CONSTEXPR inline tribool operator||(tribool x, bool y) BOOST_NOEXCEPT
 { return y? tribool(true) : x; }
 
 /**
  * \overload
  */
-inline tribool operator||(bool x, tribool y)
+BOOST_CONSTEXPR inline tribool operator||(bool x, tribool y) BOOST_NOEXCEPT
 { return x? tribool(true) : y; }
 
 /**
  * \overload
  */
-inline tribool operator||(indeterminate_keyword_t, tribool x)
+BOOST_CONSTEXPR inline tribool operator||(indeterminate_keyword_t, tribool x) BOOST_NOEXCEPT
 { return x? tribool(true) : tribool(indeterminate); }
 
 /**
  * \overload
  */
-inline tribool operator||(tribool x, indeterminate_keyword_t)
+BOOST_CONSTEXPR inline tribool operator||(tribool x, indeterminate_keyword_t) BOOST_NOEXCEPT
 { return x? tribool(true) : tribool(indeterminate); }
 //@}
 
@@ -331,34 +327,34 @@ inline tribool operator||(tribool x, indeterminate_keyword_t)
  *      </table>
  * \throws nothrow
  */
-inline tribool operator==(tribool x, tribool y)
+BOOST_CONSTEXPR inline tribool operator==(tribool x, tribool y) BOOST_NOEXCEPT
 {
-  if (indeterminate(x) || indeterminate(y))
-    return indeterminate;
-  else
-    return x && y || !x && !y;
+  return (indeterminate(x) || indeterminate(y))
+    ? indeterminate
+    : ((x && y) || (!x && !y))
+  ;
 }
 
 /**
  * \overload
  */
-inline tribool operator==(tribool x, bool y) { return x == tribool(y); }
+BOOST_CONSTEXPR inline tribool operator==(tribool x, bool y) BOOST_NOEXCEPT { return x == tribool(y); }
 
 /**
  * \overload
  */
-inline tribool operator==(bool x, tribool y) { return tribool(x) == y; }
+BOOST_CONSTEXPR inline tribool operator==(bool x, tribool y) BOOST_NOEXCEPT { return tribool(x) == y; }
 
 /**
  * \overload
  */
-inline tribool operator==(indeterminate_keyword_t, tribool x)
+BOOST_CONSTEXPR inline tribool operator==(indeterminate_keyword_t, tribool x) BOOST_NOEXCEPT
 { return tribool(indeterminate) == x; }
 
 /**
  * \overload
  */
-inline tribool operator==(tribool x, indeterminate_keyword_t)
+BOOST_CONSTEXPR inline tribool operator==(tribool x, indeterminate_keyword_t) BOOST_NOEXCEPT
 { return tribool(indeterminate) == x; }
 
 /**
@@ -394,34 +390,34 @@ inline tribool operator==(tribool x, indeterminate_keyword_t)
  *       </table>
  * \throws nothrow
  */
-inline tribool operator!=(tribool x, tribool y)
+BOOST_CONSTEXPR inline tribool operator!=(tribool x, tribool y) BOOST_NOEXCEPT
 {
-  if (indeterminate(x) || indeterminate(y))
-    return indeterminate;
-  else
-    return !(x && y || !x && !y);
+  return (indeterminate(x) || indeterminate(y))
+    ? indeterminate
+    : !((x && y) || (!x && !y))
+  ;
 }
 
 /**
  * \overload
  */
-inline tribool operator!=(tribool x, bool y) { return x != tribool(y); }
+BOOST_CONSTEXPR inline tribool operator!=(tribool x, bool y) BOOST_NOEXCEPT { return x != tribool(y); }
 
 /**
  * \overload
  */
-inline tribool operator!=(bool x, tribool y) { return tribool(x) != y; }
+BOOST_CONSTEXPR inline tribool operator!=(bool x, tribool y) BOOST_NOEXCEPT { return tribool(x) != y; }
 
 /**
  * \overload
  */
-inline tribool operator!=(indeterminate_keyword_t, tribool x)
+BOOST_CONSTEXPR inline tribool operator!=(indeterminate_keyword_t, tribool x) BOOST_NOEXCEPT
 { return tribool(indeterminate) != x; }
 
 /**
  * \overload
  */
-inline tribool operator!=(tribool x, indeterminate_keyword_t)
+BOOST_CONSTEXPR inline tribool operator!=(tribool x, indeterminate_keyword_t) BOOST_NOEXCEPT
 { return x != tribool(indeterminate); }
 
 } } // end namespace boost::logic
@@ -452,7 +448,7 @@ namespace boost {
 #define BOOST_TRIBOOL_THIRD_STATE(Name)                                 \
 inline bool                                                             \
 Name(boost::logic::tribool x,                                           \
-     boost::logic::detail::indeterminate_t dummy =                      \
+     boost::logic::detail::indeterminate_t =                            \
        boost::logic::detail::indeterminate_t())                         \
 { return x.value == boost::logic::tribool::indeterminate_value; }
 

include/boost/logic/tribool_io.hpp

@@ -11,7 +11,7 @@
 #include <boost/detail/workaround.hpp>
 #include <boost/noncopyable.hpp>
 
-#if BOOST_WORKAROUND(_MSC_VER, >= 1200)
+#if defined(_MSC_VER)
 #  pragma once
 #endif
 
@@ -104,17 +104,11 @@ 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
+#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
@@ -140,7 +134,8 @@ public:
   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& name) : name_(name) {}
+  explicit indeterminate_name(const string_type& initial_name)
+  : name_(initial_name) {}
 
   /// Returns the name for the indeterminate value
   string_type name() const { return name_; }
@@ -284,9 +279,9 @@ operator>>(std::basic_istream<CharT, Traits>& in, tribool& x)
       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()) {
+      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;

index.html

@@ -0,0 +1,16 @@
+
+<!--
+Copyright 2011 Daniel James.
+Distributed under 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)
+-->
+
+<html>
+<head>
+    <meta http-equiv="refresh" content="0; URL=../../doc/html/tribool.html">
+</head>
+<body>
+Automatic redirection failed, please go to
+<a href="../../doc/html/tribool.html">../../doc/html/tribool.html</a>
+</body>
+</html>

meta/libraries.json

@@ -0,0 +1,15 @@
+{
+    "key": "logic/tribool",
+    "name": "Tribool",
+    "authors": [
+        "Doug Gregor"
+    ],
+    "description": "3-state boolean type library.",
+    "documentation": "/doc/html/tribool.html",
+    "category": [
+        "Miscellaneous"
+    ],
+    "maintainers": [
+        "Douglas Gregor <dgregor -at- cs.indiana.edu>"
+    ]
+}

test/Jamfile.v2

@@ -0,0 +1,17 @@
+# Tribool library
+
+# Copyright (C) 2002-2003 Douglas Gregor
+
+# 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) 
+
+# For more information, see http://www.boost.org/
+
+  test-suite logic  : 
+    [ run tribool_test.cpp ]
+    [ run tribool_rename_test.cpp ]
+    [ run tribool_io_test.cpp ]
+   ;
+
+      

test/tribool_io_test.cpp

@@ -0,0 +1,198 @@
+// 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)
+#include <boost/logic/tribool.hpp>
+#include <boost/logic/tribool_io.hpp>
+#include <boost/test/minimal.hpp>
+#include <sstream>
+#include <string>
+#include <iostream>
+#include <ios>     // for std::boolalpha
+
+#ifndef BOOST_NO_STD_LOCALE
+#  include <locale>
+#endif
+
+int test_main(int, char*[])
+{
+  using namespace boost::logic;
+
+  tribool x;
+
+  // Check tribool output
+  std::ostringstream out;
+
+  // Output false (noboolalpha)
+  out.str(std::string());
+  x = false;
+  out << x;
+  std::cout << "Output false (noboolalpha): " << out.str() << std::endl;
+  BOOST_CHECK(out.str() == "0");
+
+  // Output true (noboolalpha)
+  out.str(std::string());
+  x = true;
+  out << x;
+  std::cout << "Output true (noboolalpha): " << out.str() << std::endl;
+  BOOST_CHECK(out.str() == "1");
+
+  // Output indeterminate (noboolalpha)
+  out.str(std::string());
+  x = indeterminate;
+  out << x;
+  std::cout << "Output indeterminate (noboolalpha): " << out.str()
+            << std::endl;
+  BOOST_CHECK(out.str() == "2");
+
+  // Output indeterminate (noboolalpha)
+  out.str(std::string());
+  out << indeterminate;
+  std::cout << "Output indeterminate (noboolalpha): " << out.str()
+            << std::endl;
+  BOOST_CHECK(out.str() == "2");
+
+#ifndef BOOST_NO_STD_LOCALE
+  const std::numpunct<char>& punct =
+    BOOST_USE_FACET(std::numpunct<char>, out.getloc());
+
+  // Output false (boolalpha)
+  out.str(std::string());
+  x = false;
+  out << std::boolalpha << x;
+  std::cout << "Output false (boolalpha): " << out.str() << std::endl;
+  BOOST_CHECK(out.str() == punct.falsename());
+
+  // Output true (boolalpha)
+  out.str(std::string());
+  x = true;
+  out << std::boolalpha << x;
+  std::cout << "Output true (boolalpha): " << out.str() << std::endl;
+
+  BOOST_CHECK(out.str() == punct.truename());
+
+  // Output indeterminate (boolalpha - default name)
+  out.str(std::string());
+  x = indeterminate;
+  out << std::boolalpha << x;
+  std::cout << "Output indeterminate (boolalpha - default name): " << out.str()
+            << std::endl;
+  BOOST_CHECK(out.str() == "indeterminate");
+
+  // Output indeterminate (boolalpha - default name)
+  out.str(std::string());
+  out << std::boolalpha << indeterminate;
+  std::cout << "Output indeterminate (boolalpha - default name): " << out.str()
+            << std::endl;
+  BOOST_CHECK(out.str() == "indeterminate");
+
+#  if BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, == 1)
+  // No template constructors, so we can't build the test locale
+#  else
+  // Give indeterminate a new name, and output it via boolalpha
+  std::locale global;
+  std::locale test_locale(global, new indeterminate_name<char>("maybe"));
+  out.imbue(test_locale);
+  out.str(std::string());
+  out << std::boolalpha << x;
+  std::cout << "Output indeterminate (boolalpha - \"maybe\"): " << out.str()
+            << std::endl;
+  BOOST_CHECK(out.str() == "maybe");
+#  endif
+#endif // ! BOOST_NO_STD_LOCALE
+
+  // Checking tribool input
+
+  // Input false (noboolalpha)
+  {
+    std::istringstream in("0");
+    std::cout << "Input \"0\" (checks for false)" << std::endl;
+    in >> x;
+    BOOST_CHECK(x == false);
+  }
+
+  // Input true (noboolalpha)
+  {
+    std::istringstream in("1");
+    std::cout << "Input \"1\" (checks for true)" << std::endl;
+    in >> x;
+    BOOST_CHECK(x == true);
+  }
+
+  // Input false (noboolalpha)
+  {
+    std::istringstream in("2");
+    std::cout << "Input \"2\" (checks for indeterminate)" << std::endl;
+    in >> x;
+    BOOST_CHECK(indeterminate(x));
+  }
+
+  // Input bad number (noboolalpha)
+  {
+    std::istringstream in("3");
+    std::cout << "Input \"3\" (checks for failure)" << std::endl;
+    BOOST_CHECK(!(in >> x));
+  }
+
+  // Input false (boolalpha)
+  {
+    std::istringstream in("false");
+    std::cout << "Input \"false\" (checks for false)" << std::endl;
+    in >> std::boolalpha >> x;
+    BOOST_CHECK(x == false);
+  }
+
+  // Input true (boolalpha)
+  {
+    std::istringstream in("true");
+    std::cout << "Input \"true\" (checks for true)" << std::endl;
+    in >> std::boolalpha >> x;
+    BOOST_CHECK(x == true);
+  }
+
+  // Input indeterminate (boolalpha)
+  {
+    std::istringstream in("indeterminate");
+    std::cout << "Input \"indeterminate\" (checks for indeterminate)"
+              << std::endl;
+    in >> std::boolalpha >> x;
+    BOOST_CHECK(indeterminate(x));
+  }
+
+  // Input bad string (boolalpha)
+  {
+    std::istringstream in("bad");
+    std::cout << "Input \"bad\" (checks for failure)"
+              << std::endl;
+    BOOST_CHECK(!(in >> std::boolalpha >> x));
+  }
+
+#if BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, == 1)
+  // No template constructors, so we can't build the test locale
+#elif !defined(BOOST_NO_STD_LOCALE)
+
+  // Input indeterminate named "maybe" (boolalpha)
+  {
+    std::istringstream in("maybe");
+    in.imbue(test_locale);
+    std::cout << "Input \"maybe\" (checks for indeterminate, uses locales)"
+              << std::endl;
+    in >> std::boolalpha >> x;
+    BOOST_CHECK(indeterminate(x));
+  }
+
+  // Input indeterminate named "true_or_false" (boolalpha)
+  {
+    std::locale my_locale(global,
+                          new indeterminate_name<char>("true_or_false"));
+    std::istringstream in("true_or_false");
+    in.imbue(my_locale);
+    std::cout << "Input \"true_or_false\" (checks for indeterminate)"
+              << std::endl;
+    in >> std::boolalpha >> x;
+    BOOST_CHECK(indeterminate(x));
+  }
+#endif
+
+  return 0;
+}

test/tribool_rename_test.cpp

@@ -0,0 +1,123 @@
+// Copyright Douglas Gregor 2002-2003. 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)
+
+// For more information, see http://www.boost.org
+
+#include <boost/logic/tribool.hpp>
+#include <boost/test/minimal.hpp>
+#include <iostream>
+
+BOOST_TRIBOOL_THIRD_STATE(maybe)
+
+int test_main(int,char*[])
+{
+  using namespace boost::logic;
+
+  tribool x; // false
+  tribool y(true); // true
+  tribool z(maybe); // maybe
+
+  BOOST_CHECK(!x);
+  BOOST_CHECK(x == false);
+  BOOST_CHECK(false == x);
+  BOOST_CHECK(x != true);
+  BOOST_CHECK(true != x);
+  BOOST_CHECK(maybe(x == maybe));
+  BOOST_CHECK(maybe(maybe == x));
+  BOOST_CHECK(maybe(x != maybe));
+  BOOST_CHECK(maybe(maybe != x));
+  BOOST_CHECK(x == x);
+  BOOST_CHECK(!(x != x));
+  BOOST_CHECK(!(x && true));
+  BOOST_CHECK(!(true && x));
+  BOOST_CHECK(x || true);
+  BOOST_CHECK(true || x);
+
+  BOOST_CHECK(y);
+  BOOST_CHECK(y == true);
+  BOOST_CHECK(true == y);
+  BOOST_CHECK(y != false);
+  BOOST_CHECK(false != y);
+  BOOST_CHECK(maybe(y == maybe));
+  BOOST_CHECK(maybe(maybe == y));
+  BOOST_CHECK(maybe(y != maybe));
+  BOOST_CHECK(maybe(maybe != y));
+  BOOST_CHECK(y == y);
+  BOOST_CHECK(!(y != y));
+
+  BOOST_CHECK(maybe(z || !z));
+  BOOST_CHECK(maybe(z == true));
+  BOOST_CHECK(maybe(true == z));
+  BOOST_CHECK(maybe(z == false));
+  BOOST_CHECK(maybe(false == z));
+  BOOST_CHECK(maybe(z == maybe));
+  BOOST_CHECK(maybe(maybe == z));
+  BOOST_CHECK(maybe(z != maybe));
+  BOOST_CHECK(maybe(maybe != z));
+  BOOST_CHECK(maybe(z == z));
+  BOOST_CHECK(maybe(z != z));
+
+  BOOST_CHECK(!(x == y));
+  BOOST_CHECK(x != y);
+  BOOST_CHECK(maybe(x == z));
+  BOOST_CHECK(maybe(x != z));
+  BOOST_CHECK(maybe(y == z));
+  BOOST_CHECK(maybe(y != z));
+
+  BOOST_CHECK(!(x && y));
+  BOOST_CHECK(x || y);
+  BOOST_CHECK(!(x && z));
+  BOOST_CHECK(maybe(y && z));
+  BOOST_CHECK(maybe(z && z));
+  BOOST_CHECK(maybe(z || z));
+  BOOST_CHECK(maybe(x || z));
+  BOOST_CHECK(y || z);
+
+  BOOST_CHECK(maybe(y && maybe));
+  BOOST_CHECK(maybe(maybe && y));
+  BOOST_CHECK(!(x && maybe));
+  BOOST_CHECK(!(maybe && x));
+
+  BOOST_CHECK(maybe || y);
+  BOOST_CHECK(y || maybe);
+  BOOST_CHECK(maybe(x || maybe));
+  BOOST_CHECK(maybe(maybe || x));
+
+  // Test the if (z) ... else (!z) ... else ... idiom
+  if (z) {
+    BOOST_CHECK(false);
+  }
+  else if (!z) {
+    BOOST_CHECK(false);
+  }
+  else {
+    BOOST_CHECK(true);
+  }
+
+  z = true;
+  if (z) {
+    BOOST_CHECK(true);
+  }
+  else if (!z) {
+    BOOST_CHECK(false);
+  }
+  else {
+    BOOST_CHECK(false);
+  }
+
+  z = false;
+  if (z) {
+    BOOST_CHECK(false);
+  }
+  else if (!z) {
+    BOOST_CHECK(true);
+  }
+  else {
+    BOOST_CHECK(false);
+  }
+
+  std::cout << "no errors detected\n";
+  return 0;
+}

test/tribool_test.cpp

@@ -0,0 +1,139 @@
+// Copyright Douglas Gregor 2002-2003. 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)
+
+#include <boost/logic/tribool.hpp>
+#include <boost/test/minimal.hpp>
+#include <iostream>
+
+int test_main(int, char*[])
+{
+  using namespace boost::logic;
+
+  tribool x; // false
+  tribool y(true); // true
+  tribool z(indeterminate); // indeterminate
+
+  BOOST_CHECK(!x);
+  BOOST_CHECK(x == false);
+  BOOST_CHECK(false == x);
+  BOOST_CHECK(x != true);
+  BOOST_CHECK(true != x);
+  BOOST_CHECK(indeterminate(x == indeterminate));
+  BOOST_CHECK(indeterminate(indeterminate == x));
+  BOOST_CHECK(indeterminate(x != indeterminate));
+  BOOST_CHECK(indeterminate(indeterminate != x));
+  BOOST_CHECK(x == x);
+  BOOST_CHECK(!(x != x));
+  BOOST_CHECK(!(x && true));
+  BOOST_CHECK(!(true && x));
+  BOOST_CHECK(x || true);
+  BOOST_CHECK(true || x);
+
+  BOOST_CHECK(y);
+  BOOST_CHECK(y == true);
+  BOOST_CHECK(true == y);
+  BOOST_CHECK(y != false);
+  BOOST_CHECK(false != y);
+  BOOST_CHECK(indeterminate(y == indeterminate));
+  BOOST_CHECK(indeterminate(indeterminate == y));
+  BOOST_CHECK(indeterminate(y != indeterminate));
+  BOOST_CHECK(indeterminate(indeterminate != y));
+  BOOST_CHECK(y == y);
+  BOOST_CHECK(!(y != y));
+
+  BOOST_CHECK(indeterminate(z || !z));
+  BOOST_CHECK(indeterminate(z == true));
+  BOOST_CHECK(indeterminate(true == z));
+  BOOST_CHECK(indeterminate(z == false));
+  BOOST_CHECK(indeterminate(false == z));
+  BOOST_CHECK(indeterminate(z == indeterminate));
+  BOOST_CHECK(indeterminate(indeterminate == z));
+  BOOST_CHECK(indeterminate(z != indeterminate));
+  BOOST_CHECK(indeterminate(indeterminate != z));
+  BOOST_CHECK(indeterminate(z == z));
+  BOOST_CHECK(indeterminate(z != z));
+
+  BOOST_CHECK(!(x == y));
+  BOOST_CHECK(x != y);
+  BOOST_CHECK(indeterminate(x == z));
+  BOOST_CHECK(indeterminate(x != z));
+  BOOST_CHECK(indeterminate(y == z));
+  BOOST_CHECK(indeterminate(y != z));
+
+  BOOST_CHECK(!(x && y));
+  BOOST_CHECK(x || y);
+  BOOST_CHECK(!(x && z));
+  BOOST_CHECK(indeterminate(y && z));
+  BOOST_CHECK(indeterminate(z && z));
+  BOOST_CHECK(indeterminate(z || z));
+  BOOST_CHECK(indeterminate(x || z));
+  BOOST_CHECK(y || z);
+
+  BOOST_CHECK(indeterminate(y && indeterminate));
+  BOOST_CHECK(indeterminate(indeterminate && y));
+  BOOST_CHECK(!(x && indeterminate));
+  BOOST_CHECK(!(indeterminate && x));
+
+  BOOST_CHECK(indeterminate || y);
+  BOOST_CHECK(y || indeterminate);
+  BOOST_CHECK(indeterminate(x || indeterminate));
+  BOOST_CHECK(indeterminate(indeterminate || x));
+
+  // Test the if (z) ... else (!z) ... else ... idiom
+  if (z) {
+    BOOST_CHECK(false);
+  }
+  else if (!z) {
+    BOOST_CHECK(false);
+  }
+  else {
+    BOOST_CHECK(true);
+  }
+
+  z = true;
+  if (z) {
+    BOOST_CHECK(true);
+  }
+  else if (!z) {
+    BOOST_CHECK(false);
+  }
+  else {
+    BOOST_CHECK(false);
+  }
+
+  z = false;
+  if (z) {
+    BOOST_CHECK(false);
+  }
+  else if (!z) {
+    BOOST_CHECK(true);
+  }
+  else {
+    BOOST_CHECK(false);
+  }
+
+#ifndef BOOST_NO_CXX11_CONSTEXPR
+  constexpr bool res_ors = indeterminate(false || tribool(false) || false || indeterminate); // true
+  BOOST_CHECK(res_ors);
+  char array_ors[res_ors ? 2 : 3];
+  BOOST_CHECK(sizeof(array_ors) / sizeof(char) == 2);
+
+  constexpr bool res_ands = !indeterminate(!(true && tribool(true) && true && indeterminate)); // false
+  BOOST_CHECK(!res_ands);
+  char array_ands[res_ands ? 2 : 3];
+  BOOST_CHECK(sizeof(array_ands) / sizeof(char) == 3);
+
+  // We avoid checking the tribool::operator safe_bool(),
+  // because GCC-4.8 fails to evaluate it at compile-time.
+  // Clang compiles well.
+  //
+  // constexpr bool res_safe_bool = tribool(true); // false
+  // constexpr tribool xxx = (tribool(true) || tribool(indeterminate));
+  // static_assert(xxx, "Must be true!");
+#endif
+
+  std::cout << "no errors detected\n";
+  return 0;
+}