Fix eol-style and mime-types

[SVN r7564]
Remove the broken reference_wrapper
2007-07-27 00:28:00 +00:00 · 2005-11-20 18:07:53 +00:00 · 2005-11-20 14:37:12 +00:00 · 2005-06-27 11:41:45 +00:00 · 2005-06-27 11:26:57 +00:00 · 2005-06-14 13:41:43 +00:00
20 changed files with 662 additions and 524 deletions
--- a/build/Jamfile.v2
+++ b/build/Jamfile.v2
@@ -0,0 +1,13 @@
 project
    :
    : default-build debug
    ;
 lib debug
    : #sources
      ../src/obj_id.cpp
      ../src/object_tracked.cpp
      ../src/trace_scope_stk.cpp
    ;
--- a/doc/Jamfile.v2
+++ b/doc/Jamfile.v2
@@ -1,6 +0,0 @@
 project boost-sandbox/utility/doc ;
 import boostbook ;
 import doxygen ;
 doxygen reference : ../../../boost/tribool.hpp : <prefix>boost ;
 boostbook tribool : tribool.boostbook ;
--- a/doc/named_params.html
+++ b/doc/named_params.html
@@ -1,8 +1,8 @@
-<?xml version="1.0" encoding="utf-8" ?>
+<?xml version="1.0" encoding="Latin-1" ?>
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
 <head>
-<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+<meta http-equiv="Content-Type" content="text/html; charset=Latin-1" />
 <meta name="generator" content="Docutils 0.3.1: http://docutils.sourceforge.net/" />
 <title>The Boost.NamedParams Library Boost</title>
 <link rel="stylesheet" href="../../../rst.css" type="text/css" />
@@ -21,7 +21,7 @@
 </tr>
 <tr class="field"><th class="field-name">organizations:</th><td class="field-body"><a class="reference" href="http://www.boost-consulting.com">Boost Consulting</a>,</td>
 </tr>
-<tr class="field"><th class="field-name">date:</th><td class="field-body">$Date$</td>
+<tr class="field"><th class="field-name">date:</th><td class="field-body">$Date: 2004-04-17 05:51:12 -0500 (Sat, 17 Apr 2004) $</td>
 </tr>
 <tr class="field"><th class="field-name">copyright:</th><td class="field-body">Copyright David Abrahams, Daniel Wallin 2003.</td>
 </tr>
@@ -35,22 +35,22 @@ file LICENSE_1_0.txt or copy at
 <div class="contents topic" id="outline">
 <p class="topic-title"><a name="outline">Outline</a></p>
 <ul class="auto-toc simple">
-<li><a class="reference" href="#introduction" id="id7" name="id7">1   Introduction</a></li>
+<li><a class="reference" href="#introduction" id="id7" name="id7">1<EFBFBD><EFBFBD><EFBFBD>Introduction</a></li>
-<li><a class="reference" href="#tutorial" id="id8" name="id8">2   Tutorial</a><ul class="auto-toc">
+<li><a class="reference" href="#tutorial" id="id8" name="id8">2<EFBFBD><EFBFBD><EFBFBD>Tutorial</a><ul class="auto-toc">
-<li><a class="reference" href="#defining-the-keywords" id="id9" name="id9">2.1   Defining the keywords</a></li>
+<li><a class="reference" href="#defining-the-keywords" id="id9" name="id9">2.1<EFBFBD><EFBFBD><EFBFBD>Defining the keywords</a></li>
-<li><a class="reference" href="#defining-the-forwarding-functions" id="id10" name="id10">2.2   Defining the forwarding functions</a></li>
+<li><a class="reference" href="#defining-the-forwarding-functions" id="id10" name="id10">2.2<EFBFBD><EFBFBD><EFBFBD>Defining the forwarding functions</a></li>
-<li><a class="reference" href="#defining-the-implementation-function" id="id11" name="id11">2.3   Defining the implementation function</a></li>
+<li><a class="reference" href="#defining-the-implementation-function" id="id11" name="id11">2.3<EFBFBD><EFBFBD><EFBFBD>Defining the implementation function</a></li>
 </ul>
 </li>
-<li><a class="reference" href="#limitations-of-the-approach" id="id12" name="id12">3   Limitations of the Approach</a></li>
+<li><a class="reference" href="#limitations-of-the-approach" id="id12" name="id12">3<EFBFBD><EFBFBD><EFBFBD>Limitations of the Approach</a></li>
-<li><a class="reference" href="#controlling-overload-resolution" id="id13" name="id13">4   Controlling Overload Resolution</a></li>
+<li><a class="reference" href="#controlling-overload-resolution" id="id13" name="id13">4<EFBFBD><EFBFBD><EFBFBD>Controlling Overload Resolution</a></li>
-<li><a class="reference" href="#lazy-evaluation-of-defaults" id="id14" name="id14">5   Lazy Evaluation of Defaults</a></li>
+<li><a class="reference" href="#lazy-evaluation-of-defaults" id="id14" name="id14">5<EFBFBD><EFBFBD><EFBFBD>Lazy Evaluation of Defaults</a></li>
-<li><a class="reference" href="#automatic-overload-generation" id="id15" name="id15">6   Automatic Overload Generation</a></li>
+<li><a class="reference" href="#automatic-overload-generation" id="id15" name="id15">6<EFBFBD><EFBFBD><EFBFBD>Automatic Overload Generation</a></li>
-<li><a class="reference" href="#portability" id="id16" name="id16">7   Portability</a></li>
+<li><a class="reference" href="#portability" id="id16" name="id16">7<EFBFBD><EFBFBD><EFBFBD>Portability</a></li>
 </ul>
 </div>
 <div class="section" id="introduction">
-<h1><a class="toc-backref" href="#id7" name="introduction">1   Introduction</a></h1>
+<h1><a class="toc-backref" href="#id7" name="introduction">1<EFBFBD><EFBFBD><EFBFBD>Introduction</a></h1>
 <p>In C++ function arguments are given meaning by their position in
 the parameter list. This protocol is fine when there are few
 parameters with default values, but as the number of parameters
@@ -114,7 +114,7 @@ The tutorial has to come before all the nasty details below.
 I'm going to comment on that and leave the next stuff alone -->
 </div>
 <div class="section" id="tutorial">
-<h1><a class="toc-backref" href="#id8" name="tutorial">2   Tutorial</a></h1>
+<h1><a class="toc-backref" href="#id8" name="tutorial">2<EFBFBD><EFBFBD><EFBFBD>Tutorial</a></h1>
 <!-- DWA you need some set-up here describing the problem you're
 going to solve. -->
 <p>This example shows how to wrap a function:</p>
@@ -123,7 +123,7 @@ void foo(char const* name, float value);
 </pre>
 <p>to give both parameters names and default values.</p>
 <div class="section" id="defining-the-keywords">
-<h2><a class="toc-backref" href="#id9" name="defining-the-keywords">2.1   Defining the keywords</a></h2>
+<h2><a class="toc-backref" href="#id9" name="defining-the-keywords">2.1<EFBFBD><EFBFBD><EFBFBD>Defining the keywords</a></h2>
 <p>First we define the named parameter keywords. This is done by creating
 &quot;tag&quot; types for each keyword, and declaring <tt class="literal"><span class="pre">keyword&lt;</span></tt><em>tag</em><tt class="literal"><span class="pre">&gt;</span></tt> objects:</p>
 <pre class="literal-block">
@@ -154,31 +154,31 @@ struct foo_keywords
 </pre>
 </div>
 <div class="section" id="defining-the-forwarding-functions">
-<h2><a class="toc-backref" href="#id10" name="defining-the-forwarding-functions">2.2   Defining the forwarding functions</a></h2>
+<h2><a class="toc-backref" href="#id10" name="defining-the-forwarding-functions">2.2<EFBFBD><EFBFBD><EFBFBD>Defining the forwarding functions</a></h2>
 <pre class="literal-block">
 template&lt;class Params&gt;
 void foo_impl(const Params&amp;);
 void foo()
 {
-    foo_impl(foo_keywords());
+    foo_impl(foo_keywords()());
 }
 template&lt;class A0&gt;
 void foo(const A0&amp; a0)
 {
-    foo_impl(foo_keywords(a0));
+    foo_impl(foo_keywords()(a0));
 }
 template&lt;class A0, class A1&gt;
 void foo(const A0&amp; a0, const A1&amp; a1)
 {
-    foo_impl(foo_keywords(a0, a1));
+    foo_impl(foo_keywords()(a0, a1));
 }
 </pre>
 </div>
 <div class="section" id="defining-the-implementation-function">
-<h2><a class="toc-backref" href="#id11" name="defining-the-implementation-function">2.3   Defining the implementation function</a></h2>
+<h2><a class="toc-backref" href="#id11" name="defining-the-implementation-function">2.3<EFBFBD><EFBFBD><EFBFBD>Defining the implementation function</a></h2>
 <pre class="literal-block">
 template&lt;class Params&gt;
 void foo_impl(const Params&amp; params)
@@ -232,7 +232,7 @@ unnamed = 3
 </div>
 </div>
 <div class="section" id="limitations-of-the-approach">
-<h1><a class="toc-backref" href="#id12" name="limitations-of-the-approach">3   Limitations of the Approach</a></h1>
+<h1><a class="toc-backref" href="#id12" name="limitations-of-the-approach">3<EFBFBD><EFBFBD><EFBFBD>Limitations of the Approach</a></h1>
 <p>Because the keywords' <tt class="literal"><span class="pre">operator=</span></tt> returns a temporary, and
 temporaries cannot be bound to non-<tt class="literal"><span class="pre">const</span></tt> reference parameters,
 our forwarding functions need to take their arguments by <tt class="literal"><span class="pre">const</span></tt>
@@ -253,7 +253,7 @@ foo(boost::ref(x)); // held type is float&amp;
 <tt class="literal"><span class="pre">boost::ref</span></tt> will be unwrapped automatically by the library.</p>
 </div>
 <div class="section" id="controlling-overload-resolution">
-<h1><a class="toc-backref" href="#id13" name="controlling-overload-resolution">4   Controlling Overload Resolution</a></h1>
+<h1><a class="toc-backref" href="#id13" name="controlling-overload-resolution">4<EFBFBD><EFBFBD><EFBFBD>Controlling Overload Resolution</a></h1>
 <p>The parameters of our templated forwarding functions are completely
 general; in fact, they're a perfect match for any argument type
 whatsoever.  The problems with exposing such general function
@@ -330,7 +330,7 @@ by callers; they merely trigger SFINAE by becoming illegal types
 when the <tt class="literal"><span class="pre">name</span></tt> argument is not convertible to <tt class="literal"><span class="pre">const</span> <span class="pre">char*</span></tt>.</p>
 </div>
 <div class="section" id="lazy-evaluation-of-defaults">
-<h1><a class="toc-backref" href="#id14" name="lazy-evaluation-of-defaults">5   Lazy Evaluation of Defaults</a></h1>
+<h1><a class="toc-backref" href="#id14" name="lazy-evaluation-of-defaults">5<EFBFBD><EFBFBD><EFBFBD>Lazy Evaluation of Defaults</a></h1>
 <p>If computing an argument's default value is expensive, it's best
 avoided when the argument is supplied by the user. In that case,
 the default value can be lazily evaluated using the following
@@ -359,7 +359,7 @@ void bar_impl(Params const&amp; params)
 </pre>
 </div>
 <div class="section" id="automatic-overload-generation">
-<h1><a class="toc-backref" href="#id15" name="automatic-overload-generation">6   Automatic Overload Generation</a></h1>
+<h1><a class="toc-backref" href="#id15" name="automatic-overload-generation">6<EFBFBD><EFBFBD><EFBFBD>Automatic Overload Generation</a></h1>
 <p>To reduce the work needed to write functions with named parameters,
 we supply a macro that generates the boilerplate code.</p>
 <p>Synopsis:</p>
@@ -382,7 +382,7 @@ BOOST_NAMED_PARAMS_FUN(void, foo, 0, 2, foo_keywords)
 </pre>
 </div>
 <div class="section" id="portability">
-<h1><a class="toc-backref" href="#id16" name="portability">7   Portability</a></h1>
+<h1><a class="toc-backref" href="#id16" name="portability">7<EFBFBD><EFBFBD><EFBFBD>Portability</a></h1>
 <p>Boost.NamedParams has been confirmed to work on the following compilers:</p>
 <blockquote>
 <ul class="simple">
@@ -437,7 +437,7 @@ of lack of SFINAE support.</td></tr>
 <hr class="footer" />
 <div class="footer">
 <a class="reference" href="named_params.rst">View document source</a>.
-Generated on: 2004-03-04 10:40 UTC.
+Generated on: 2004-04-17 10:54 UTC.
 Generated by <a class="reference" href="http://docutils.sourceforge.net/">Docutils</a> from <a class="reference" href="http://docutils.sourceforge.net/rst.html">reStructuredText</a> source.
 </div>
 </body>
--- a/doc/named_params.rst
+++ b/doc/named_params.rst
@@ -14,7 +14,7 @@ __ ../../../index.htm
 :Authors: David Abrahams, Daniel Wallin
 :Contact: dave@boost-consulting.com, dalwan01@student.umu.se
 :organizations: `Boost Consulting`_, 
-:date: $Date$
+:date: $Date: 2005-03-27 23:35:50 -0500 (Sun, 27 Mar 2005) $
 :copyright: Copyright David Abrahams, Daniel Wallin 2003. 
 :license: Use, modification and distribution is subject to the
          Boost Software License, Version 1.0. (See accompanying
@@ -124,8 +124,8 @@ function.  These keywords should be declared in the same order as
 their corresponding parameters appear in the function's parameter
 list::
-     struct foo_keywords
+     struct foo_parameters
-       : boost::keywords<
+       : boost::parameters<
             name_t
           , value_t
         >
@@ -141,19 +141,19 @@ Defining the forwarding functions
     void foo()
     {
-         foo_impl(foo_keywords());
+         foo_impl(foo_parameters()());
     }
     template<class A0>
     void foo(const A0& a0)
     {
-         foo_impl(foo_keywords(a0));
+         foo_impl(foo_parameters()(a0));
     }
     template<class A0, class A1>
     void foo(const A0& a0, const A1& a1)
     {
-         foo_impl(foo_keywords(a0, a1));
+         foo_impl(foo_parameters()(a0, a1));
     }
 Defining the implementation function
@@ -293,8 +293,8 @@ of ``boost::named_param``:
 .. parsed-literal::
-     struct foo_keywords
+     struct foo_parameters
-       : boost::keywords<
+       : boost::parameters<
             **boost::named_param<
                 name_t
               , mpl::false\_
@@ -312,7 +312,7 @@ Now we can add an additional optional argument to each of our
     template<class A0>
     void foo(
         const A0& a0
-       , **foo_keywords::restrict<A0>::type x = foo_keywords()**
+       , **foo_parameters::restrict<A0>::type x = foo_parameters()**
     )
     {
         foo_impl(x(a0));
@@ -321,7 +321,7 @@ Now we can add an additional optional argument to each of our
     template<class A0, class A1>
     void foo(
         const A0& a0, const A1& a1
-       , **foo_keywords::restrict<A0,A1>::type x = foo_keywords()**
+       , **foo_parameters::restrict<A0,A1>::type x = foo_parameters()**
     )
     {
         foo_impl(x(a0, a1));
@@ -372,14 +372,14 @@ Synopsis::
     BOOST_NAMED_PARAMS_FUN(
         return_type, function_name
-       , min_arity, max_arity, keywords_type
+       , min_arity, max_arity, parameters_type
     );
 To generate all the forwarding functions and the implementation
 function for our example, we need only apply
 ``BOOST_NAMED_PARAMS_FUN`` this way::
-     BOOST_NAMED_PARAMS_FUN(void, foo, 0, 2, foo_keywords)
+     BOOST_NAMED_PARAMS_FUN(void, foo, 0, 2, foo_parameters)
     {
         std::cout
             << p[name | "unnamed"] << " = "
--- a/doc/named_params_ref.rst
+++ b/doc/named_params_ref.rst
@@ -0,0 +1,192 @@
 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 The Boost.NamedParams Library Reference |(logo)|__ INCOMPLETE
 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 .. |(logo)| image:: ../../../c++boost.gif
   :alt: Boost
   :class: boost-logo
 __ ../../../index.htm
 -------------------------------------
 :Authors: David Abrahams, Daniel Wallin
 :Contact: dave@boost-consulting.com, dalwan01@student.umu.se
 :organizations: `Boost Consulting`_, 
 :date: $Date: 2005-03-27 23:35:50 -0500 (Sun, 27 Mar 2005) $
 :copyright: Copyright David Abrahams, Daniel Wallin 2003. 
 :license: 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)
 .. _`Boost Consulting`: http://www.boost-consulting.com
 .. contents::
 concept ``keyword-expression``
 ------------------------------
 .. parsed-literal::
    template<class Tag>
    *bound-argument* operator[](*keyword-expression*, keyword<Tag>)
 **Requires**
    An argument tagged with ``Tag`` must be bound in the object.
 **Returns**
    A reference to the bound argument tagged with ``Tag``.
 **Throws**
    Nothrow.
 **Complexity**
    O(1) runtime. O(1) compile time on good compilers. O(N), where N is
    the number of bound arguments, on old compilers such as VC6.
 .. parsed-literal::
    *bound-argument* operator[](*keyword-expression*, *named-default-expression*)
 **Requires**
    Nothing.
 **Returns**
    A reference to the bound argument tagged with 
    *named-default-expression*::key_type. If no such argument is bound, the
    default value as given by the *named-default-expression* instance is 
    returned.
 **Throws**
    Nothrow.
 **Complexity**
    O(1) runtime. O(1) compile time on good compilers. O(N), where N is
    the number of bound arguments, on old compilers such as VC6.
 concept ``named-default-expression``
 ------------------------------------
 ...
 concept ``lazy-default-expression``
 -----------------------------------
 ...
 class template ``keyword``
 --------------------------
 .. parsed-literal::
    template<class Tag>
    struct keyword
    {
        template<class T>
        *keyword-expression* operator=(T&) const;
        template<class T>
        *keyword-expression* operator=(T const&) const;
        template<class Default>
        *named-default-expression* operator|(Default&) const;
        template<class Default>
        *named-default-expression* operator|(Default const&) const;
        template<class LazyDefault>
        *unspecified* operator||(LazyDefault const&) const;
    };
 Denotes a argument keyword. ``Tag`` is a tag class, typically an incomplete type.
 ::
    template<class T> operator=(T&)
    template<class T> operator=(T const&)
 **Requires**
    Nothing.
 **Returns**
    An object that holds a cv reference to ``x``, tagged with the keyword
    ``Tag`` type. If ``T`` is an instance of ``boost::reference_wrapper<U cv>``
    the tagged result will hold a reference to ``U cv``.
 **Complexity**
    O(1) compile time and run time.
 **Throws**
    Nothrow.
 .. parsed-literal::
    template<class Default>
    *named-default-expression* operator|(Default&) const
    template<class Default>
    *named-default-expression* operator|(Default const&) const
 **Requires**
    Nothing.
 **Returns**
    An object holding a reference to the given default value, tagged
    with ``Tag``.
 .. parsed-literal::
    template<class LazyDefault>
    *lazy-default-expression* operator||(LazyDefault const& x) const;
 **Requires**
    ``LazyDefault`` is a nullary function object, with the following
    properties:
    ======================== =======================================
    Expression               Result
    ======================== =======================================
    LazyDefault::result_type Must to Copyable
    x()                      Convertible to LazyDefault::result_type
    ======================== =======================================
 **Returns**
    ...
 .. parsed-literal::
    template<
        class Tag
      , class HasDefault = mpl::true\_
      , class Predicate = mpl::always<mpl::true\_>
    >
    struct named_param
    {
        typedef Tag key_type;
        typedef HasDefault has_default;
        typedef Predicate predicate;
    };
    template<class K0, class K1, ..., class KN>
    struct parameters
    {
        template<class T0, class T1, ..., class TN>
        *keyword-expression* operator()(T0 const&, T1 const&, ..., TN const&) const;
    };
 * <K0, ..., KN> is either a tag type, as specified in ``keyword``, or an instantiation of
  ``named_param``.
 ::
   template<class T0, class T1, ..., class TN> operator()(T0 const&, T1 const&, ..., TN const&) const;
 Composes all parameters, named and positional, into an object that can be used to query
 for specific keywords.
--- a/doc/tribool.boostbook
+++ b/doc/tribool.boostbook
@@ -1,167 +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="utility/tribool" id="tribool"
         last-revision="$Date$" xmlns:xi="http://www.w3.org/2001/XInclude">
  <libraryinfo>
    <author>
      <firstname>Douglas</firstname>
      <surname>Gregor</surname>
      <email>gregod@cs.rpi.edu</email>
    </author>
    <copyright>
      <year>2002</year>
      <year>2003</year>
      <holder>Douglas Gregor</holder>
    </copyright>    
    <legalnotice>
      <para>Permission to copy, use, sell and distribute this software
      is granted provided this copyright notice appears in all copies.
      Permission to modify the code and to distribute modified code is
      granted provided this copyright notice appears in all copies, and
      a notice that the code was modified is included with the copyright
      notice. </para>
      <para> This software is provided "as is" without express or
      implied warranty, and with no claim as to its suitability for any
      purpose. </para>
    </legalnotice>
    <librarypurpose>Three-state boolean type</librarypurpose>
    <librarycategory name="category:misc"/>
  </libraryinfo>
  <section id="tribool.introduction">
    <title>Introduction</title>
    <para>The 3-state boolean library contains a single class,
    <code><classname>boost::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"/>
    <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.</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, or both
  }
 }</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
  example:</para>
 <programlisting><classname>tribool</classname> x(true);
 <classname>tribool</classname> y(<functionname>indeterminate</functionname>);
 assert(x == x); // okay, x == x returns true
 assert(!(y == y)); // okay, because y == y is <functionname>indeterminate</functionname> 
 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> 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)</programlisting>
  </section>
  <xi:include href="reference.boostbook"/>
  <testsuite>
    <run-test filename="tribool_test.cpp">
      <purpose><para>Test all features of the
      <code><classname>boost::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>
  </testsuite>
 </library>
--- a/include/boost/ref.hpp
+++ b/include/boost/ref.hpp
@@ -1,249 +0,0 @@
 #ifndef BOOST_REF_HPP_INCLUDED
 # define BOOST_REF_HPP_INCLUDED
 # if _MSC_VER+0 >= 1020
 #  pragma once
 # endif
 # include <boost/config.hpp>
 # include <boost/utility/addressof.hpp>
 # include <boost/type_traits/ice.hpp>
 # include <boost/type.hpp>
 # ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 #  include <boost/result_of.hpp>
 # endif
 # include <boost/preprocessor/iterate.hpp>
 # include <boost/pending/ct_if.hpp>
 //
 //  ref.hpp - ref/cref, useful helper functions
 //
 //  Copyright (C) 1999, 2000 Jaakko J<>rvi (jaakko.jarvi@cs.utu.fi)
 //  Copyright (C) 2001, 2002 Peter Dimov
 //  Copyright (C) 2002 David Abrahams
 //  Copyright (C) 2003 Doug Gregor
 //
 //  Permission to copy, use, modify, sell and distribute this software
 //  is granted provided this copyright notice appears in all copies.
 //  This software is provided "as is" without express or implied
 //  warranty, and with no claim as to its suitability for any purpose.
 //
 //  See http://www.boost.org/libs/bind/ref.html for documentation.
 //
 # ifndef BOOST_REF_NUM_ARGS
 #  define BOOST_REF_NUM_ARGS 10
 # endif
 namespace boost
 {
 namespace detail { namespace ref {
 template<typename T>
 class reference_wrapper_without_result_type
 {
 public:
  template<typename F>
  struct result_of
 # ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
      : boost::result_of<F>
 # endif 
  {
  };
  operator T& () const { return *(this->t_); }
  T& get() const { return *(this->t_); }
  T* get_pointer() const { return this->t_; }
 # if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)         \
    && !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551))
 #  define BOOST_PP_ITERATION_PARAMS_1 (3,(0,BOOST_REF_NUM_ARGS,<boost/detail/ref_iterate.hpp>))
 #  include BOOST_PP_ITERATE()
 # endif 
 protected:
 # if defined(BOOST_MSVC) && (BOOST_MSVC < 1300)
  explicit reference_wrapper_without_result_type(T& t) : t_(&t) {}
 # else
  explicit reference_wrapper_without_result_type(T& t) : t_(addressof(t)) {}
 # endif
 private:
  T* t_;
 };
 # ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 template<typename T>
 class reference_wrapper_with_result_type
 {
 public:
  typedef typename T::result_type result_type;
  operator T& () const { return *(this->t_); }
  T& get() const { return *(this->t_); }
  T* get_pointer() const { return this->t_; }
  result_type operator()() const { return get()(); }
 #  if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551))
 #   define BOOST_PP_ITERATION_PARAMS_1 (3,(0,BOOST_REF_NUM_ARGS,<boost/detail/ref_iterate.hpp>))
 #   include BOOST_PP_ITERATE()
 #  endif 
 protected:
 #  if defined(BOOST_MSVC) && (BOOST_MSVC < 1300)
  explicit reference_wrapper_with_result_type(T& t) : t_(&t) {}
 #  else
  explicit reference_wrapper_with_result_type(T& t) : t_(addressof(t)) {}
 #  endif
 private:
  T* t_;
 };
 template<typename T>
 class reference_wrapper_impl :
  public ct_if<(has_result_type<T>::value),
               reference_wrapper_with_result_type<T>,
               reference_wrapper_without_result_type<T> >::type
 {
  typedef typename ct_if<(has_result_type<T>::value),
                         reference_wrapper_with_result_type<T>,
                         reference_wrapper_without_result_type<T> >::type
    inherited;
 protected:
  reference_wrapper_impl(T& t) : inherited(t) {}
 };
 # else
 template<typename T>
 class reference_wrapper_impl : public reference_wrapper_without_result_type<T>
 {
  typedef reference_wrapper_without_result_type<T> inherited;
 protected:
  reference_wrapper_impl(T& t) : inherited(t) {}
 };
 # endif
 } } // end namespace detail::ref
 template<class T>
 class reference_wrapper : public detail::ref::reference_wrapper_impl<T>
 {
  typedef detail::ref::reference_wrapper_impl<T> inherited;
 public:
  typedef T type;
  explicit reference_wrapper(T& t) : inherited(t) {}
 };
 # if defined(__BORLANDC__) && (__BORLANDC__ <= 0x570)
 #  define BOOST_REF_CONST
 # else
 #  define BOOST_REF_CONST const
 # endif
 template<class T> inline reference_wrapper<T> BOOST_REF_CONST ref(T & t)
 {
    return reference_wrapper<T>(t);
 }
 template<class T> inline reference_wrapper<T const> BOOST_REF_CONST cref(T const & t)
 {
    return reference_wrapper<T const>(t);
 }
 # undef BOOST_REF_CONST
 # ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 template<typename T>
 class is_reference_wrapper
 {
 public:
    BOOST_STATIC_CONSTANT(bool, value = false);
 };
 template<typename T>
 class is_reference_wrapper<reference_wrapper<T> >
 {
 public:
    BOOST_STATIC_CONSTANT(bool, value = true);
 };
 template<typename T>
 class unwrap_reference
 {
 public:
    typedef T type;
 };
 template<typename T>
 class unwrap_reference<reference_wrapper<T> >
 {
 public:
    typedef T type;
 };
 # else // no partial specialization
 } // namespace boost
 namespace boost
 {
 namespace detail
 {
  typedef char (&yes_reference_wrapper_t)[1];
  typedef char (&no_reference_wrapper_t)[2];
  no_reference_wrapper_t is_reference_wrapper_test(...);
  template<typename T>
  yes_reference_wrapper_t
  is_reference_wrapper_test(type< reference_wrapper<T> >);
  template<bool wrapped>
  struct reference_unwrapper
  {
      template <class T>
      struct apply
      {
          typedef T type;
      };
  };
  template<>
  struct reference_unwrapper<true>
  {
      template <class T>
      struct apply
      {
          typedef typename T::type type;
      };
  };
 }
 template<typename T>
 class is_reference_wrapper
 {
 public:
    BOOST_STATIC_CONSTANT(
        bool, value = (
            sizeof(detail::is_reference_wrapper_test(type<T>()))
            == sizeof(detail::yes_reference_wrapper_t)));
 };
 template <typename T>
 class unwrap_reference
    : public detail::reference_unwrapper<
        is_reference_wrapper<T>::value
      >::template apply<T>
 {};
 # endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 } // namespace boost
 #endif // #ifndef BOOST_REF_HPP_INCLUDED
--- a/include/boost/utility/chk_dbl_die.hpp
+++ b/include/boost/utility/chk_dbl_die.hpp
@@ -0,0 +1,17 @@
 //object_tracked with DTOR check for double destruction (death)
 #ifndef BOOST_DEBUG_UTILITY_CHK_DBL_DELETE_HPP_LJE20040129
 #define BOOST_UTILITY_CHK_DBL_DELETE_HPP_LJE20040129
 #include "boost/utility/object_tracked.hpp"
 #include <boost/test/test_tools.hpp>
 namespace utility
 {
 struct chk_dbl_die
 : public object_tracked
 {
    ~chk_dbl_die(void)
    {
        BOOST_CHECK(am_i_live());
    }
 };
 }//exit utility namespace
 #endif
--- a/include/boost/utility/obj_id.hpp
+++ b/include/boost/utility/obj_id.hpp
@@ -0,0 +1,49 @@
 #ifndef UTILITY_OBJ_ID_HPP
 #define UTILITY_OBJ_ID_HPP
 namespace utility
  {
  struct obj_id
   /**@class obj_id
    * @brief Provide unique id for objects
    */
    {
          typedef
        unsigned
      id_type
        ;
      ~obj_id(void)
        {}
      obj_id(void)
        :m_id(the_last_id()++)
        {}
      obj_id(obj_id const&)
        :m_id(the_last_id()++)
        {}
        void
      operator=(obj_id const&)
        {}
        id_type
      id_get(void)const
        { return m_id
        ;}
          static
        id_type&
      the_last_id(void)
        //reference to count if id's created
        ;
    private:
        id_type
      m_id
        ;
    };//end obj_id struct
  }//exit utility namespace
 //----------------------------  
 //ChangeLog:
 //  2005-06-17: Larry Evans
 //    WHAT:
 //      rm'ed virtual DTOR
 //    WHY:
 //      comment that had accompanied it and justified use of
 //      virtual DTOR is no longer relevant.
 #endif
--- a/include/boost/utility/object_tracked.hpp
+++ b/include/boost/utility/object_tracked.hpp
@@ -0,0 +1,118 @@
 //Simple class which keeps track of members
 #ifndef UTILITY_OBJECT_TRACKED_HPP_LJE20040112
 #define UTILITY_OBJECT_TRACKED_HPP_LJE20040112
 //#define UTILITY_OBJECT_TRACKED_SET_OF_OBJECTS_TRACE_MODE
 //#define UTILITY_OBJECT_TRACKED_TRACE_MODE
 #include <set>
 #include "boost/utility/obj_id.hpp"
 #if defined(UTILITY_OBJECT_TRACKED_SET_OF_OBJECTS_TRACE_MODE)\
 || defined(UTILITY_OBJECT_TRACKED_TRACE_MODE)
 #include "boost/io/filters/mout.hpp"
 #endif
 namespace utility
 {
 class object_tracked
 : public obj_id
 {
 private:
      struct 
    set_of_objects_tracked
      : public std::set<object_tracked const*>
    {
            typedef 
          std::set<object_tracked const*>
        super_type
        ;
        ~set_of_objects_tracked(void)
        {
          #ifdef UTILITY_OBJECT_TRACKED_SET_OF_OBJECTS_TRACE_MODE
            mout()<<"set_of_objects_tracked-\n";
          #endif
        }
        set_of_objects_tracked(void)
        {
          #ifdef UTILITY_OBJECT_TRACKED_SET_OF_OBJECTS_TRACE_MODE
            mout()<<"set_of_objects_tracked+\n";
          #endif
        }
          void
        reset(void)
        {
            super_type::clear();
            obj_id::the_last_id() = 0;
        }
          bool
        contains(object_tracked const*& a_obj)const
        {
            return find(a_obj) != end();
        }
    };
        static
      set_of_objects_tracked
    our_members
    ;
 public:
        static
      void
    reset(void)
    {
        our_members.reset();
    }
        static
      unsigned
    members_size(void)
    {
          return our_members.size();
    }
    object_tracked(void)
    {
        our_members.insert(this);
      #ifdef UTILITY_OBJECT_TRACKED_TRACE_MODE
        mout()<<"object_tracked+:id="<<id_get()<<":default\n";
      #endif
    }
    object_tracked(object_tracked const& a_obj)
    {
        our_members.insert(this);
      #ifdef UTILITY_OBJECT_TRACKED_TRACE_MODE
        mout()<<"object_tracked+:id="<<id_get()<<":copy\n";
      #endif
    }
        virtual 
    ~object_tracked(void) 
    { 
      #ifdef UTILITY_OBJECT_TRACKED_TRACE_MODE
        mout()<<"object_tracked-:id="<<id_get()<<":am_i_live="<<am_i_live()<<"\n";
      #endif  
        utility::object_tracked const*me=this;
        our_members.erase(me); 
    }
        bool
    am_i_live(void)const
    //Purpose:
    //  Used to check for multiple destructor calls.  Should always return true
    //  if only place where our_members.erase is called is in
    //  ~object_tracked.
    {
        utility::object_tracked const*me=this;
        bool result=utility::object_tracked::our_members.contains(me);
        return result;
    }
        static
      bool
    is_live(utility::object_tracked const*a_ot)
    {
        bool result=utility::object_tracked::our_members.contains(a_ot);
        return result;
    }
 };
 }//exit utility namespace
 #endif
--- a/include/boost/utility/trace_scope.hpp
+++ b/include/boost/utility/trace_scope.hpp
@@ -0,0 +1,40 @@
 #ifndef UTILITY_TRACE_SCOPE_HPP
 #define UTILITY_TRACE_SCOPE_HPP
 #include "boost/io/filters/mout.hpp"
 #include <string>
 namespace utility
 {
  class
 trace_scope
  //Purpose:
  //  Indicate on cout when a scope entered and exited.
  {
  public:
    trace_scope(char const* a_scopeName)
      : m_scopeName(a_scopeName)
      { init()
      ;}
    trace_scope(std::string const& a_scopeName)
      : m_scopeName(a_scopeName)
      { init()
      ;}
    ~trace_scope(void)
      {
      ; --mout()
      ; std::string l_context("===>Exit:")
      ; mout()<<l_context<<m_scopeName<<std::endl
      ;}
  private:
      void
    init(void)
      { 
      ; std::string l_context("===>Enter:")
      ; mout()<<l_context<<m_scopeName<<std::endl
      ; ++mout()
      ;}
      std::string
    m_scopeName
      ;
  };//end trace_scope class
 }//exit utility namespace
 #endif
--- a/include/boost/utility/trace_scope_stk.hpp
+++ b/include/boost/utility/trace_scope_stk.hpp
@@ -0,0 +1,46 @@
 #ifndef UTILITY_TRACE_SCOPE_STK_HPP
 #define UTILITY_TRACE_SCOPE_STK_HPP
 #include <vector>
 #include "boost/utility/trace_scope.hpp"
 namespace utility
 {
 struct trace_scope_stk
  : public trace_scope
  //Purpose:
  //  Simply keeps a stack variables of
  //  type trace_scope_stk
  {
  public:
        static
      std::string const&
    top_name(void)
      { return c_scope_names.back()
      ;}
        static
      std::string const
    top_result(bool result_bool)
      { std::string  result_string(c_scope_names.back())
      ; result_string += std::string(":result=")
      ; result_string += c_test_results[result_bool]
      ; return result_string
      ;}
    trace_scope_stk(std::string const& a_name)
      : trace_scope(a_name)
      { c_scope_names.push_back(a_name)
      ;}
    ~trace_scope_stk(void)
      { c_scope_names.pop_back()
      ;}
  private:
        static
      std::vector<std::string>
    c_scope_names
      ;
        static
      std::string const
    c_test_results[2]
      ;
  };
 }//exit utility namespace
 #endif
--- a/result_of_test.cpp
+++ b/result_of_test.cpp
@@ -3,14 +3,14 @@
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/is_same.hpp>
-class int_result_type { typedef int result_type; };
+struct int_result_type { typedef int result_type; };
-class int_result_of
+struct int_result_of
 {
  template<typename F> struct result { typedef int type; };
 };
-class int_result_type_and_float_result_of
+struct int_result_type_and_float_result_of
 {
  typedef int result_type;
  template<typename F> struct result { typedef float type; };
@@ -23,13 +23,23 @@ int main()
  using namespace boost;
  typedef int (*func_ptr)(float, double);
  typedef int (&func_ref)(float, double);
  typedef int (X::*mem_func_ptr)(float);
  typedef int (X::*mem_func_ptr_c)(float) const;
  typedef int (X::*mem_func_ptr_v)(float) volatile;
  typedef int (X::*mem_func_ptr_cv)(float) const volatile;
  BOOST_STATIC_ASSERT((is_same<result_of<int_result_type(float)>::type, int>::value));
  BOOST_STATIC_ASSERT((is_same<result_of<int_result_of(double)>::type, int>::value));
  BOOST_STATIC_ASSERT((is_same<result_of<int_result_of(void)>::type, void>::value));
  BOOST_STATIC_ASSERT((is_same<result_of<const int_result_of(double)>::type, int>::value));
  BOOST_STATIC_ASSERT((is_same<result_of<volatile int_result_of(void)>::type, void>::value));
  BOOST_STATIC_ASSERT((is_same<result_of<int_result_type_and_float_result_of(char)>::type, int>::value));
  BOOST_STATIC_ASSERT((is_same<result_of<func_ptr(char, float)>::type, int>::value));
  BOOST_STATIC_ASSERT((is_same<result_of<func_ref(char, float)>::type, int>::value));
  BOOST_STATIC_ASSERT((is_same<result_of<mem_func_ptr(X,char)>::type, int>::value));
  BOOST_STATIC_ASSERT((is_same<result_of<mem_func_ptr_c(X,char)>::type, int>::value));
  BOOST_STATIC_ASSERT((is_same<result_of<mem_func_ptr_v(X,char)>::type, int>::value));
  BOOST_STATIC_ASSERT((is_same<result_of<mem_func_ptr_cv(X,char)>::type, int>::value));
  return 0;
 }
--- a/src/obj_id.cpp
+++ b/src/obj_id.cpp
@@ -0,0 +1,10 @@
 #include "boost/utility/obj_id.hpp"
 using namespace utility;
 //          static
 obj_id::
        id_type&
 obj_id::
      the_last_id(void)
        { static id_type last_id=0
        ; return last_id
        ;}
--- a/src/object_tracked.cpp
+++ b/src/object_tracked.cpp
@@ -0,0 +1,6 @@
 #include "boost/utility/object_tracked.hpp"
 using namespace utility;
  utility::object_tracked::set_of_objects_tracked
 utility::object_tracked::our_members
 ;
--- a/src/trace_scope_stk.cpp
+++ b/src/trace_scope_stk.cpp
@@ -0,0 +1,12 @@
 #include "boost/utility/trace_scope_stk.hpp"
 //        static
      std::vector<std::string>
 utility::trace_scope_stk::
    c_scope_names
      ;
 //        static
      std::string const
 utility::trace_scope_stk::
    c_test_results[2]
      = {"failed", "passed"}
      ;
--- a/test/Jamfile
+++ b/test/Jamfile
@@ -6,18 +6,17 @@ subproject libs/utility/test ;
 import testing ;
 {
-    test-suite "utility"
+    test-suite "lexicographic"
       : [ run lexicographic_test.cpp ]
         [ run lex_performance_test.cpp ]
-         [ run named_params_test.cpp ]
+           ;
    test-suite "named_params"
      :  [ run named_params_test.cpp ]
         [ run named_params_sfinae.cpp ]
-	 [ run enable_if_constructors.cpp ]
+       ;
-         [ run enable_if_member_templates.cpp ]
+
-         [ run enable_if_dummy_arg_disambiguation.cpp ]
+    test-suite "result_check"
-         [ run enable_if_namespace_disambiguation.cpp ]
+      :  [ compile result_check_test.cpp ]
         [ run enable_if_lazy.cpp ]
         [ run enable_if_no_disambiguation.cpp ]
         [ run enable_if_lazy_test.cpp ]                
         [ run enable_if_partial_specializations.cpp ]
       ;
 }
--- a/test/named_params_sfinae.cpp
+++ b/test/named_params_sfinae.cpp
@@ -11,55 +11,54 @@
 namespace test
 {
-  using boost::keyword;
+  using namespace boost::named_params;
  using boost::keywords;
  using boost::named_param;
-  struct name_t; keyword<name_t> name;
+  keyword<struct name_> name;
-  struct value_t; keyword<value_t> value;
+  keyword<struct value_> value;
-  struct f_keywords
+  struct f_parameters
-      : keywords<
+    : parameters<
-            named_param<
+          optional<
-                name_t
+              name_
-              , boost::mpl::true_
+            , boost::is_convertible<boost::mpl::_, std::string>
-              , boost::is_convertible<boost::mpl::_, std::string>
+          >
-            >
+        , optional<
-          , named_param<
+              value_
-                value_t
+            , boost::is_convertible<boost::mpl::_, float>
-              , boost::mpl::true_
+          >
              , boost::is_convertible<boost::mpl::_, float>
            >
      >
  {};
  template <class T> struct not_implemented;
  template<class P>
  void f_impl(P const& p)
  {
      std::string s = p[name | "bar"];
      float v = p[value | 3.f];
      std::cout << "s is " << s << std::endl;
      assert(s == "foo");
      assert(v == 3.f);
  }
-  void f()
+  void f(...)
  {
-      f_impl(f_keywords()());
+      f_impl(f_parameters()());
  }
  template<class A0>
  void f(A0 const& a0
-      , typename f_keywords::restrict<A0>::type = f_keywords())
+      , typename f_parameters::restrict<A0>::type = f_parameters())
  {
-      f_impl(f_keywords()(a0));
+      f_impl(f_parameters()(a0));
  }
  template<class A0, class A1>
  void f(A0 const& a0, A1 const& a1
-      , typename f_keywords::restrict<A0, A1>::type = f_keywords())
+      , typename f_parameters::restrict<A0, A1>::type = f_parameters())
  {
-      f_impl(f_keywords()(a0, a1));
+      f_impl(f_parameters()(a0, a1));
  }
 } // namespace test
--- a/test/named_params_test.cpp
+++ b/test/named_params_test.cpp
@@ -8,32 +8,23 @@
 #include <string.h>
 #include <boost/bind.hpp>
 #include <boost/ref.hpp>
 #include <boost/static_assert.hpp>
 namespace test
 {
  using namespace boost::named_params;
-  using boost::keyword;
+  keyword<struct name_> name;
-  using boost::keywords;
+  keyword<struct value_> value;
-  using boost::named_param;
+  keyword<struct index_> index;
  keyword<struct tester_> tester;
-  struct name_t;
+  struct f_parameters // vc6 is happier with inheritance than with a typedef
-  keyword<name_t> name;
+    : parameters<
-
+          tester_
-  struct value_t;
+        , name_
-  keyword <value_t> value;
+        , value_
-
+        , index_
  struct index_t;
  keyword<index_t> index;
  struct tester_t;
  keyword<tester_t> tester;
  struct f_keywords // vc6 is happier with inheritance than with a typedef
    : keywords<
          tester_t
        , name_t
        , value_t
        , index_t
      >
  {};
@@ -48,7 +39,8 @@ namespace test
      p[tester](
          p[name]
        , p[value || boost::bind(&value_default) ]
-        , p[index | 999]
+//        , p[value | 666.222 ]
        , p[index | 999 ]
      );
      return 1;
  }
@@ -57,19 +49,25 @@ namespace test
  int f(Tester const& t, const Name& name_, 
      const Value& value_, const Index& index_)
  {
-      return f_impl(f_keywords()(t, name_, value_, index_));
+      return f_impl(f_parameters()(t, name_, value_, index_));
  }
  template<class Tester, class Name, class Value>
  int f(Tester const& t, const Name& name_, const Value& value_)
  {
-      return f_impl(f_keywords()(t, name_, value_));
+      return f_impl(f_parameters()(t, name_, value_));
  }
  template<class Tester, class Name>
  int f(Tester const& t, const Name& name_)
  {
-      return f_impl(f_keywords()(t, name_));
+      return f_impl(f_parameters()(t, name_));
  }
  template<class Params>
  int f_list(Params const& params)
  {
      return f_impl(params);
  }
  template <class T>
@@ -121,6 +119,26 @@ namespace test
  {
      return values_t<Name,Value,Index>(n,v,i);
  }
  typedef f_parameters g_parameters;
  template<class Args>
  int g_impl(Args const& args)
  {
      return f(args);
  }
  template<class A0>
  int g(A0 const& a0)
  {
      return g_impl(g_parameters(a0));
  }
  template<class A0, class A1>
  int g(A0 const& a0, A1 const& a1)
  {
      return g_impl(g_parameters(a0, a1));
  }
 }
 // GCC2 has a problem with char (&)[] deduction, so we'll cast string
@@ -135,6 +153,7 @@ namespace test
 int main()
 {
   using test::f;
   using test::f_list;
   using test::name;
   using test::value;
   using test::index;
@@ -151,6 +170,12 @@ int main()
     , index = boost::ref(x), name = "foo"
   );
   f_list((
       tester = test::values("foo", 666.222, 56)
     , index = boost::ref(x)
     , name = "foo"
   ));
   //f(index = 56, name = 55); // won't compile
   return 0;
 }
--- a/test/result_check_test.cpp
+++ b/test/result_check_test.cpp
@@ -0,0 +1,24 @@
 // Copyright Daniel Wallin 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/result_check.hpp>
 #include <boost/type_traits/is_same.hpp>
 BOOST_RESULT_CHECK(2, add, operator+, _1 + _2)
 struct X
 {
 };
 X operator+(X const&, X const&);
 X& operator+(X&, X&);
 int main()
 {
    using namespace boost;
    BOOST_MPL_ASSERT((check_add<X const&, X const&, is_same<mpl::_, X> >));
    BOOST_MPL_ASSERT((check_add<X&, X&, is_same<mpl::_, X&> >));
 }
Author	SHA1	Message	Date
Douglas Gregor	6d50998347	Fix eol-style and mime-types [SVN r7564]	2007-07-27 00:28:00 +00:00
Douglas Gregor	2bc5f0cb06	Remove the broken reference_wrapper [SVN r2754]	2005-11-20 18:07:53 +00:00
Douglas Gregor	0e3d2ccb2c	tribool has been in Boost proper for ages [SVN r2753]	2005-11-20 14:37:12 +00:00
Larry Joe Evans	21bc200ca0	* empty log message * [SVN r2655]	2005-06-27 11:41:45 +00:00
Larry Joe Evans	103b0a719f	* empty log message * [SVN r2654]	2005-06-27 11:26:57 +00:00
Larry Joe Evans	85a6825e74	Added file needed by utility/build/Jamfile.v2 [SVN r2631]	2005-06-14 13:41:43 +00:00
Larry Joe Evans	c346d99b84	Adding Jamfile.v2 needed by libs/policy_ptr/test/Jamfile.v2 [SVN r2630]	2005-06-14 13:31:37 +00:00
Larry Joe Evans	72088f2b04	* empty log message * [SVN r2628]	2005-06-13 21:12:57 +00:00
Dave Abrahams	43b68a7b11	Continuesd cleanups and clarification [SVN r2556]	2005-03-28 04:35:50 +00:00
Dave Abrahams	2c3c79aec5	Cleanups and clarification [SVN r2555]	2005-03-28 03:11:26 +00:00
Daniel Wallin	c5826cb47b	NamedParams renaming [SVN r2547]	2005-03-26 08:44:37 +00:00
Daniel Wallin	f7631d89a7	reference docs for named_params, incomplete [SVN r2337]	2004-11-08 13:28:17 +00:00
Douglas Gregor	e595c9b77b	Add the include for static asserts [SVN r2333]	2004-11-05 14:09:28 +00:00
Daniel Wallin	e219b65cf3	* empty log message * [SVN r2312]	2004-09-13 10:21:22 +00:00
Larry Joe Evans	018bb60d47	* empty log message * [SVN r2266]	2004-07-28 03:12:26 +00:00
Douglas Gregor	532c8aa06d	boost/result_of.hpp, boost/detail/result_of_iterate.hpp: - Deal with function references - Deal with cv-qualified member pointers libs/utility/result_of_test.cpp: - Test all of those things above [SVN r2157]	2004-05-02 14:49:44 +00:00
Dave Abrahams	824e94e2f6	Clean up Jamfile; fix for no koenig lookup. [SVN r2154]	2004-04-20 16:18:49 +00:00
Daniel Wallin	e4b9ac6a30	operator, on named args produce a list automatically [SVN r2142]	2004-04-17 11:08:24 +00:00
Daniel Wallin	2bc1676024	fixed code example errors in docs [SVN r2141]	2004-04-17 10:51:12 +00:00
Daniel Wallin	9c3296ef74	* empty log message * [SVN r2140]	2004-04-17 10:46:07 +00:00
Dave Abrahams	4f9b64125a	Try latin-1 encoding. [SVN r2135]	2004-04-14 14:41:29 +00:00