This commit was manufactured by cvs2svn to create branch

'thread_rewrite'.

[SVN r30953]

doc/Jamfile.v2

@@ -1,36 +0,0 @@
-# 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
-    ;
-
-###############################################################################
-alias boostdoc
-    : tribool/<format>docbook
-    :
-    :
-    : ;
-explicit boostdoc ;
-alias boostrelease ;
-explicit boostrelease ;

doc/tribool.boostbook

@@ -1,231 +0,0 @@
-<?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>
 
-#ifdef BOOST_HAS_PRAGMA_ONCE
+#if BOOST_WORKAROUND(_MSC_VER, >= 1200)
 #  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
  */
-BOOST_CONSTEXPR inline bool
+inline bool
 indeterminate(tribool x,
-              detail::indeterminate_t dummy = detail::indeterminate_t()) BOOST_NOEXCEPT;
+              detail::indeterminate_t dummy = detail::indeterminate_t());
 
 /**
  * \brief A 3-state boolean type.
@@ -85,7 +85,7 @@ public:
    *
    * \throws nothrow
    */
-  BOOST_CONSTEXPR tribool() BOOST_NOEXCEPT : value(false_value) {}
+  tribool() : value(false_value) {}
 
   /**
    * Construct a new 3-state boolean value with the given boolean
@@ -93,14 +93,14 @@ public:
    *
    * \throws nothrow
    */
-  BOOST_CONSTEXPR tribool(bool initial_value) BOOST_NOEXCEPT : value(initial_value? true_value : false_value) {}
+  tribool(bool value) : value(value? true_value : false_value) {}
 
   /**
    * Construct a new 3-state boolean value with an indeterminate value.
    *
    * \throws nothrow
    */
-  BOOST_CONSTEXPR tribool(indeterminate_keyword_t) BOOST_NOEXCEPT : value(indeterminate_value) {}
+  tribool(indeterminate_keyword_t) : 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
    */
-  BOOST_CONSTEXPR operator safe_bool() const BOOST_NOEXCEPT
+  operator safe_bool() const
   {
     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
-BOOST_CONSTEXPR inline bool indeterminate(tribool x, detail::indeterminate_t) BOOST_NOEXCEPT
+inline bool indeterminate(tribool x, detail::indeterminate_t)
 {
   return x.value == tribool::indeterminate_value;
 }
@@ -156,7 +156,7 @@ BOOST_CONSTEXPR inline bool indeterminate(tribool x, detail::indeterminate_t) BO
  *  </table>
  * \throws nothrow
  */
-BOOST_CONSTEXPR inline tribool operator!(tribool x) BOOST_NOEXCEPT
+inline tribool operator!(tribool x)
 {
   return x.value == tribool::false_value? tribool(true)
         :x.value == tribool::true_value? tribool(false)
@@ -196,36 +196,38 @@ BOOST_CONSTEXPR inline tribool operator!(tribool x) BOOST_NOEXCEPT
  *       </table>
  * \throws nothrow
  */
-BOOST_CONSTEXPR inline tribool operator&&(tribool x, tribool y) BOOST_NOEXCEPT
+inline tribool operator&&(tribool x, tribool y)
 {
-  return (static_cast<bool>(!x) || static_cast<bool>(!y))
-    ? tribool(false)
-    : ((static_cast<bool>(x) && static_cast<bool>(y)) ? tribool(true) : indeterminate)
-  ;
+  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;
 }
 
 /**
  * \overload
  */
-BOOST_CONSTEXPR inline tribool operator&&(tribool x, bool y) BOOST_NOEXCEPT
+inline tribool operator&&(tribool x, bool y)
 { return y? x : tribool(false); }
 
 /**
  * \overload
  */
-BOOST_CONSTEXPR inline tribool operator&&(bool x, tribool y) BOOST_NOEXCEPT
+inline tribool operator&&(bool x, tribool y)
 { return x? y : tribool(false); }
 
 /**
  * \overload
  */
-BOOST_CONSTEXPR inline tribool operator&&(indeterminate_keyword_t, tribool x) BOOST_NOEXCEPT
+inline tribool operator&&(indeterminate_keyword_t, tribool x)
 { return !x? tribool(false) : tribool(indeterminate); }
 
 /**
  * \overload
  */
-BOOST_CONSTEXPR inline tribool operator&&(tribool x, indeterminate_keyword_t) BOOST_NOEXCEPT
+inline tribool operator&&(tribool x, indeterminate_keyword_t)
 { return !x? tribool(false) : tribool(indeterminate); }
 
 /**
@@ -261,36 +263,38 @@ BOOST_CONSTEXPR inline tribool operator&&(tribool x, indeterminate_keyword_t) BO
  *       </table>
  *  \throws nothrow
  */
-BOOST_CONSTEXPR inline tribool operator||(tribool x, tribool y) BOOST_NOEXCEPT
+inline tribool operator||(tribool x, tribool y)
 {
-  return (static_cast<bool>(!x) && static_cast<bool>(!y))
-    ? tribool(false)
-    : ((static_cast<bool>(x) || static_cast<bool>(y)) ? tribool(true) : tribool(indeterminate))
-  ;
+  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;
 }
 
 /**
  * \overload
  */
-BOOST_CONSTEXPR inline tribool operator||(tribool x, bool y) BOOST_NOEXCEPT
+inline tribool operator||(tribool x, bool y)
 { return y? tribool(true) : x; }
 
 /**
  * \overload
  */
-BOOST_CONSTEXPR inline tribool operator||(bool x, tribool y) BOOST_NOEXCEPT
+inline tribool operator||(bool x, tribool y)
 { return x? tribool(true) : y; }
 
 /**
  * \overload
  */
-BOOST_CONSTEXPR inline tribool operator||(indeterminate_keyword_t, tribool x) BOOST_NOEXCEPT
+inline tribool operator||(indeterminate_keyword_t, tribool x)
 { return x? tribool(true) : tribool(indeterminate); }
 
 /**
  * \overload
  */
-BOOST_CONSTEXPR inline tribool operator||(tribool x, indeterminate_keyword_t) BOOST_NOEXCEPT
+inline tribool operator||(tribool x, indeterminate_keyword_t)
 { return x? tribool(true) : tribool(indeterminate); }
 //@}
 
@@ -327,34 +331,34 @@ BOOST_CONSTEXPR inline tribool operator||(tribool x, indeterminate_keyword_t) BO
  *      </table>
  * \throws nothrow
  */
-BOOST_CONSTEXPR inline tribool operator==(tribool x, tribool y) BOOST_NOEXCEPT
+inline tribool operator==(tribool x, tribool y)
 {
-  return (indeterminate(x) || indeterminate(y))
-    ? indeterminate
-    : ((x && y) || (!x && !y))
-  ;
+  if (indeterminate(x) || indeterminate(y))
+    return indeterminate;
+  else
+    return x && y || !x && !y;
 }
 
 /**
  * \overload
  */
-BOOST_CONSTEXPR inline tribool operator==(tribool x, bool y) BOOST_NOEXCEPT { return x == tribool(y); }
+inline tribool operator==(tribool x, bool y) { return x == tribool(y); }
 
 /**
  * \overload
  */
-BOOST_CONSTEXPR inline tribool operator==(bool x, tribool y) BOOST_NOEXCEPT { return tribool(x) == y; }
+inline tribool operator==(bool x, tribool y) { return tribool(x) == y; }
 
 /**
  * \overload
  */
-BOOST_CONSTEXPR inline tribool operator==(indeterminate_keyword_t, tribool x) BOOST_NOEXCEPT
+inline tribool operator==(indeterminate_keyword_t, tribool x)
 { return tribool(indeterminate) == x; }
 
 /**
  * \overload
  */
-BOOST_CONSTEXPR inline tribool operator==(tribool x, indeterminate_keyword_t) BOOST_NOEXCEPT
+inline tribool operator==(tribool x, indeterminate_keyword_t)
 { return tribool(indeterminate) == x; }
 
 /**
@@ -390,34 +394,34 @@ BOOST_CONSTEXPR inline tribool operator==(tribool x, indeterminate_keyword_t) BO
  *       </table>
  * \throws nothrow
  */
-BOOST_CONSTEXPR inline tribool operator!=(tribool x, tribool y) BOOST_NOEXCEPT
+inline tribool operator!=(tribool x, tribool y)
 {
-  return (indeterminate(x) || indeterminate(y))
-    ? indeterminate
-    : !((x && y) || (!x && !y))
-  ;
+  if (indeterminate(x) || indeterminate(y))
+    return indeterminate;
+  else
+    return !(x && y || !x && !y);
 }
 
 /**
  * \overload
  */
-BOOST_CONSTEXPR inline tribool operator!=(tribool x, bool y) BOOST_NOEXCEPT { return x != tribool(y); }
+inline tribool operator!=(tribool x, bool y) { return x != tribool(y); }
 
 /**
  * \overload
  */
-BOOST_CONSTEXPR inline tribool operator!=(bool x, tribool y) BOOST_NOEXCEPT { return tribool(x) != y; }
+inline tribool operator!=(bool x, tribool y) { return tribool(x) != y; }
 
 /**
  * \overload
  */
-BOOST_CONSTEXPR inline tribool operator!=(indeterminate_keyword_t, tribool x) BOOST_NOEXCEPT
+inline tribool operator!=(indeterminate_keyword_t, tribool x)
 { return tribool(indeterminate) != x; }
 
 /**
  * \overload
  */
-BOOST_CONSTEXPR inline tribool operator!=(tribool x, indeterminate_keyword_t) BOOST_NOEXCEPT
+inline tribool operator!=(tribool x, indeterminate_keyword_t)
 { return x != tribool(indeterminate); }
 
 } } // end namespace boost::logic
@@ -448,7 +452,7 @@ namespace boost {
 #define BOOST_TRIBOOL_THIRD_STATE(Name)                                 \
 inline bool                                                             \
 Name(boost::logic::tribool x,                                           \
-     boost::logic::detail::indeterminate_t =                            \
+     boost::logic::detail::indeterminate_t dummy =                      \
        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 defined(_MSC_VER)
+#if BOOST_WORKAROUND(_MSC_VER, >= 1200)
 #  pragma once
 #endif
 
@@ -104,11 +104,17 @@ template<>
 inline std::basic_string<char> get_default_indeterminate_name<char>()
 { return "indeterminate"; }
 
-#ifndef BOOST_NO_WCHAR_T
+#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
@@ -134,8 +140,7 @@ 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& initial_name)
-  : name_(initial_name) {}
+  explicit indeterminate_name(const string_type& name) : name_(name) {}
 
   /// Returns the name for the indeterminate value
   string_type name() const { return name_; }
@@ -279,9 +284,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

@@ -1,16 +0,0 @@
-
-<!--
-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

@@ -1,15 +0,0 @@
-{
-    "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

@@ -1,17 +0,0 @@
-# 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

@@ -1,198 +0,0 @@
-// 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

@@ -1,123 +0,0 @@
-// 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

@@ -1,139 +0,0 @@
-// 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;
-}