libs/function/doc/reference.xml:

- Document target() member function
  - Documented new comparison operators

libs/function/doc/tests.xml: Include contains_test.cpp
libs/function/doc/function.xml: Use the new XInclude name


[SVN r21903]
This commit is contained in:
Douglas Gregor
2004-01-25 00:38:26 +00:00
parent 746676d274
commit c5d8d03b76
3 changed files with 444 additions and 67 deletions

View File

@ -3,7 +3,7 @@
"http://www.boost.org/tools/boostbook/dtd/boostbook.dtd"> "http://www.boost.org/tools/boostbook/dtd/boostbook.dtd">
<library name="Function" dirname="function" id="function" <library name="Function" dirname="function" id="function"
last-revision="$Date$" last-revision="$Date$"
xmlns:xi="http://www.w3.org/2001/XInclude"> xmlns:xi="http://www.w3.org/2003/XInclude">
<libraryinfo> <libraryinfo>
<author> <author>
<firstname>Douglas</firstname> <firstname>Douglas</firstname>

View File

@ -83,6 +83,30 @@
<throws><simpara>Will not throw.</simpara></throws> <throws><simpara>Will not throw.</simpara></throws>
</method> </method>
</method-group> </method-group>
<method-group name="target access">
<overloaded-method name="target">
<signature>
<template>
<template-type-parameter name="Functor"/>
</template>
<type>Functor*</type>
</signature>
<signature cv="const">
<template>
<template-type-parameter name="Functor"/>
</template>
<type>const Functor*</type>
</signature>
<returns><simpara>If <code>this</code> stores a target of type
<code>Functor</code>, returns the address of the
target. Otherwise, returns the NULL
pointer.</simpara></returns>
<throws><simpara>Will not throw.</simpara></throws>
</overloaded-method>
</method-group>
</class> </class>
<class name="functionN"> <class name="functionN">
@ -216,6 +240,30 @@
</method> </method>
</method-group> </method-group>
<method-group name="target access">
<overloaded-method name="target">
<signature>
<template>
<template-type-parameter name="Functor"/>
</template>
<type>Functor*</type>
</signature>
<signature cv="const">
<template>
<template-type-parameter name="Functor"/>
</template>
<type>const Functor*</type>
</signature>
<returns><simpara>If <code>this</code> stores a target of type
<code>Functor</code>, returns the address of the
target. Otherwise, returns the NULL
pointer.</simpara></returns>
<throws><simpara>Will not throw.</simpara></throws>
</overloaded-method>
</method-group>
<method-group name="invocation"> <method-group name="invocation">
<method name="operator()" cv="const"> <method name="operator()" cv="const">
<type>result_type</type> <type>result_type</type>
@ -246,8 +294,61 @@
</function> </function>
</free-function-group> </free-function-group>
<free-function-group name="undefined operators"> <free-function-group name="comparison operators">
<function name="operator=="> <overloaded-function name="operator==">
<signature>
<template>
<template-type-parameter name="T1"/>
<template-type-parameter name="T2"/>
<template-varargs/>
<template-type-parameter name="TN"/>
<template-type-parameter name="Allocator"/>
<template-type-parameter name="Functor"/>
</template>
<type>bool</type>
<parameter name="f"><paramtype>const <classname>functionN</classname>&lt;T1, T2, ..., TN, Allocator&gt;&amp;</paramtype></parameter>
<parameter name="g"><paramtype>Functor</paramtype></parameter>
</signature>
<signature>
<template>
<template-type-parameter name="T1"/>
<template-type-parameter name="T2"/>
<template-varargs/>
<template-type-parameter name="TN"/>
<template-type-parameter name="Allocator"/>
<template-type-parameter name="Functor"/>
</template>
<type>bool</type>
<parameter name="g"><paramtype>Functor</paramtype></parameter>
<parameter name="f"><paramtype>const <classname>functionN</classname>&lt;T1, T2, ..., TN, Allocator&gt;&amp;</paramtype></parameter>
</signature>
<signature>
<template>
<template-type-parameter name="T1"/>
<template-type-parameter name="T2"/>
<template-varargs/>
<template-type-parameter name="TN"/>
<template-type-parameter name="Allocator"/>
<template-type-parameter name="Functor"/>
</template>
<type>bool</type>
<parameter name="f"><paramtype>const <classname>functionN</classname>&lt;T1, T2, ..., TN, Allocator&gt;&amp;</paramtype></parameter>
<parameter name="g"><paramtype><classname>reference_wrapper</classname>&lt;Functor&gt;</paramtype></parameter>
</signature>
<signature>
<template>
<template-type-parameter name="T1"/>
<template-type-parameter name="T2"/>
<template-varargs/>
<template-type-parameter name="TN"/>
<template-type-parameter name="Allocator"/>
<template-type-parameter name="Functor"/>
</template>
<type>bool</type>
<parameter name="g"><paramtype><classname>reference_wrapper</classname>&lt;Functor&gt;</paramtype></parameter>
<parameter name="f"><paramtype>const <classname>functionN</classname>&lt;T1, T2, ..., TN, Allocator&gt;&amp;</paramtype></parameter>
</signature>
<signature>
<template> <template>
<template-type-parameter name="T1"/> <template-type-parameter name="T1"/>
<template-type-parameter name="T2"/> <template-type-parameter name="T2"/>
@ -263,11 +364,91 @@
<type>void</type> <type>void</type>
<parameter name="f1"><paramtype>const <classname>functionN</classname>&lt;T1, T2, ..., TN, Allocator1&gt;&amp;</paramtype></parameter> <parameter name="f1"><paramtype>const <classname>functionN</classname>&lt;T1, T2, ..., TN, Allocator1&gt;&amp;</paramtype></parameter>
<parameter name="f2"><paramtype>const <classname>functionN</classname>&lt;U1, U2, ..., UN, Allocator2&gt;&amp;</paramtype></parameter> <parameter name="f2"><paramtype>const <classname>functionN</classname>&lt;U1, U2, ..., UN, Allocator2&gt;&amp;</paramtype></parameter>
<notes><simpara>This function must be left undefined.</simpara></notes> </signature>
<rationale><simpara>The <code>safe_bool</code> conversion opens a loophole whereby two function instances can be compared via <code>==</code>. This undefined <code>void operator ==</code> closes the loophole and ensures a compile-time or link-time error.</simpara></rationale>
</function>
<function name="operator!="> <returns><simpara>True when <code>f</code> stores an object of
type <code>Functor</code> and one of the following conditions applies:
<itemizedlist>
<listitem><simpara><code>g</code> is of type
<code><classname>reference_wrapper</classname>&lt;Functor&gt;</code>
and <code>f.target&lt;Functor&gt;() == g.<methodname
alt="reference_wrapper::get_pointer">get_pointer</methodname>()</code>.</simpara></listitem>
<listitem><simpara><code>g</code> is not of type
<code><classname>reference_wrapper</classname>&lt;Functor&gt;</code>
and <code>*(f.target&lt;Functor&gt;()) ==
g</code>.</simpara></listitem>
</itemizedlist>
</simpara></returns>
<notes><simpara><code><classname>functionN</classname></code>
objects are not
<conceptname>EqualityComparable</conceptname>.</simpara></notes>
<rationale><simpara>The <code>safe_bool</code> conversion
opens a loophole whereby two <code>functionN</code>
instances can be compared via <code>==</code>, although this
is not feasible to implement. The undefined <code>void
operator==</code> closes the loophole and ensures a
compile-time or link-time error.</simpara></rationale>
</overloaded-function>
<overloaded-function name="operator!=">
<signature>
<template>
<template-type-parameter name="T1"/>
<template-type-parameter name="T2"/>
<template-varargs/>
<template-type-parameter name="TN"/>
<template-type-parameter name="Allocator"/>
<template-type-parameter name="Functor"/>
</template>
<type>bool</type>
<parameter name="f"><paramtype>const <classname>functionN</classname>&lt;T1, T2, ..., TN, Allocator&gt;&amp;</paramtype></parameter>
<parameter name="g"><paramtype>Functor</paramtype></parameter>
</signature>
<signature>
<template>
<template-type-parameter name="T1"/>
<template-type-parameter name="T2"/>
<template-varargs/>
<template-type-parameter name="TN"/>
<template-type-parameter name="Allocator"/>
<template-type-parameter name="Functor"/>
</template>
<type>bool</type>
<parameter name="g"><paramtype>Functor</paramtype></parameter>
<parameter name="f"><paramtype>const <classname>functionN</classname>&lt;T1, T2, ..., TN, Allocator&gt;&amp;</paramtype></parameter>
</signature>
<signature>
<template>
<template-type-parameter name="T1"/>
<template-type-parameter name="T2"/>
<template-varargs/>
<template-type-parameter name="TN"/>
<template-type-parameter name="Allocator"/>
<template-type-parameter name="Functor"/>
</template>
<type>bool</type>
<parameter name="f"><paramtype>const <classname>functionN</classname>&lt;T1, T2, ..., TN, Allocator&gt;&amp;</paramtype></parameter>
<parameter name="g"><paramtype><classname>reference_wrapper</classname>&lt;Functor&gt;</paramtype></parameter>
</signature>
<signature>
<template>
<template-type-parameter name="T1"/>
<template-type-parameter name="T2"/>
<template-varargs/>
<template-type-parameter name="TN"/>
<template-type-parameter name="Allocator"/>
<template-type-parameter name="Functor"/>
</template>
<type>bool</type>
<parameter name="g"><paramtype><classname>reference_wrapper</classname>&lt;Functor&gt;</paramtype></parameter>
<parameter name="f"><paramtype>const <classname>functionN</classname>&lt;T1, T2, ..., TN, Allocator&gt;&amp;</paramtype></parameter>
</signature>
<signature>
<template> <template>
<template-type-parameter name="T1"/> <template-type-parameter name="T1"/>
<template-type-parameter name="T2"/> <template-type-parameter name="T2"/>
@ -283,9 +464,38 @@
<type>void</type> <type>void</type>
<parameter name="f1"><paramtype>const <classname>functionN</classname>&lt;T1, T2, ..., TN, Allocator1&gt;&amp;</paramtype></parameter> <parameter name="f1"><paramtype>const <classname>functionN</classname>&lt;T1, T2, ..., TN, Allocator1&gt;&amp;</paramtype></parameter>
<parameter name="f2"><paramtype>const <classname>functionN</classname>&lt;U1, U2, ..., UN, Allocator2&gt;&amp;</paramtype></parameter> <parameter name="f2"><paramtype>const <classname>functionN</classname>&lt;U1, U2, ..., UN, Allocator2&gt;&amp;</paramtype></parameter>
<notes><simpara>This function must be left undefined.</simpara></notes> </signature>
<rationale><simpara>The <code>safe_bool</code> conversion opens a loophole whereby two function instances can be compared via <code>!=</code>. This undefined <code>void operator !=</code> closes the loophole and ensures a compile-time or link-time error.</simpara></rationale>
</function> <returns><simpara>True when <code>f</code> does not store an
object of type <code>Functor</code> or it stores an object of
type <code>Functor</code> and one of the following conditions
applies:
<itemizedlist>
<listitem><simpara><code>g</code> is of type
<code><classname>reference_wrapper</classname>&lt;Functor&gt;</code>
and <code>f.target&lt;Functor&gt;() != g.<methodname
alt="reference_wrapper::get_pointer">get_pointer</methodname>()</code>.</simpara></listitem>
<listitem><simpara><code>g</code> is not of type
<code><classname>reference_wrapper</classname>&lt;Functor&gt;</code>
and <code>*(f.target&lt;Functor&gt;()) !=
g</code>.</simpara></listitem>
</itemizedlist>
</simpara></returns>
<notes><simpara><code><classname>functionN</classname></code>
objects are not
<conceptname>EqualityComparable</conceptname>.</simpara></notes>
<rationale><simpara>The <code>safe_bool</code> conversion
opens a loophole whereby two <code>functionN</code>
instances can be compared via <code>!=</code>, although this
is not feasible to implement. The undefined <code>void
operator!=</code> closes the loophole and ensures a
compile-time or link-time error.</simpara></rationale>
</overloaded-function>
</free-function-group> </free-function-group>
</class> </class>
@ -441,6 +651,29 @@
</method> </method>
</method-group> </method-group>
<method-group name="target access">
<overloaded-method name="target">
<signature>
<template>
<template-type-parameter name="Functor"/>
</template>
<type>Functor*</type>
</signature>
<signature cv="const">
<template>
<template-type-parameter name="Functor"/>
</template>
<type>const Functor*</type>
</signature>
<returns><simpara>If <code>this</code> stores a target of type
<code>Functor</code>, returns the address of the
target. Otherwise, returns the NULL
pointer.</simpara></returns>
<throws><simpara>Will not throw.</simpara></throws>
</overloaded-method>
</method-group>
<method-group name="invocation"> <method-group name="invocation">
<method name="operator()" cv="const"> <method name="operator()" cv="const">
<type>result_type</type> <type>result_type</type>
@ -468,8 +701,49 @@
</function> </function>
</free-function-group> </free-function-group>
<free-function-group name="undefined operators"> <free-function-group name="comparison operators">
<function name="operator=="> <overloaded-function name="operator==">
<signature>
<template>
<template-type-parameter name="Signature"/>
<template-type-parameter name="Allocator"/>
<template-type-parameter name="Functor"/>
</template>
<type>bool</type>
<parameter name="f"><paramtype>const <classname>function</classname>&lt;Signature, Allocator&gt;&amp;</paramtype></parameter>
<parameter name="g"><paramtype>Functor</paramtype></parameter>
</signature>
<signature>
<template>
<template-type-parameter name="Signature"/>
<template-type-parameter name="Allocator"/>
<template-type-parameter name="Functor"/>
</template>
<type>bool</type>
<parameter name="g"><paramtype>Functor</paramtype></parameter>
<parameter name="f"><paramtype>const <classname>function</classname>&lt;Signature, Allocator&gt;&amp;</paramtype></parameter>
</signature>
<signature>
<template>
<template-type-parameter name="Signature"/>
<template-type-parameter name="Allocator"/>
<template-type-parameter name="Functor"/>
</template>
<type>bool</type>
<parameter name="f"><paramtype>const <classname>function</classname>&lt;Signature, Allocator&gt;&amp;</paramtype></parameter>
<parameter name="g"><paramtype><classname>reference_wrapper</classname>&lt;Functor&gt;</paramtype></parameter>
</signature>
<signature>
<template>
<template-type-parameter name="Signature"/>
<template-type-parameter name="Allocator"/>
<template-type-parameter name="Functor"/>
</template>
<type>bool</type>
<parameter name="g"><paramtype><classname>reference_wrapper</classname>&lt;Functor&gt;</paramtype></parameter>
<parameter name="f"><paramtype>const <classname>function</classname>&lt;Signature, Allocator&gt;&amp;</paramtype></parameter>
</signature>
<signature>
<template> <template>
<template-type-parameter name="Signature1"/> <template-type-parameter name="Signature1"/>
<template-type-parameter name="Allocator1"/> <template-type-parameter name="Allocator1"/>
@ -479,11 +753,79 @@
<type>void</type> <type>void</type>
<parameter name="f1"><paramtype>const <classname>function</classname>&lt;Signature1, Allocator1&gt;&amp;</paramtype></parameter> <parameter name="f1"><paramtype>const <classname>function</classname>&lt;Signature1, Allocator1&gt;&amp;</paramtype></parameter>
<parameter name="f2"><paramtype>const <classname>function</classname>&lt;Signature2, Allocator2&gt;&amp;</paramtype></parameter> <parameter name="f2"><paramtype>const <classname>function</classname>&lt;Signature2, Allocator2&gt;&amp;</paramtype></parameter>
<notes><simpara>This function must be left undefined.</simpara></notes> </signature>
<rationale><simpara>The <code>safe_bool</code> conversion opens a loophole whereby two function instances can be compared via <code>==</code>. This undefined <code>void operator ==</code> closes the loophole and ensures a compile-time or link-time error.</simpara></rationale>
</function>
<function name="operator!="> <returns><simpara>True when <code>f</code> stores an object of
type <code>Functor</code> and one of the following conditions applies:
<itemizedlist>
<listitem><simpara><code>g</code> is of type
<code><classname>reference_wrapper</classname>&lt;Functor&gt;</code>
and <code>f.target&lt;Functor&gt;() == g.<methodname
alt="reference_wrapper::get_pointer">get_pointer</methodname>()</code>.</simpara></listitem>
<listitem><simpara><code>g</code> is not of type
<code><classname>reference_wrapper</classname>&lt;Functor&gt;</code>
and <code>*(f.target&lt;Functor&gt;()) ==
g</code>.</simpara></listitem>
</itemizedlist>
</simpara></returns>
<notes><simpara><code><classname>function</classname></code>
objects are not
<conceptname>EqualityComparable</conceptname>.</simpara></notes>
<rationale><simpara>The <code>safe_bool</code> conversion
opens a loophole whereby two <code>function</code>
instances can be compared via <code>==</code>, although this
is not feasible to implement. The undefined <code>void
operator==</code> closes the loophole and ensures a
compile-time or link-time error.</simpara></rationale>
</overloaded-function>
<overloaded-function name="operator!=">
<signature>
<template>
<template-type-parameter name="Signature"/>
<template-type-parameter name="Allocator"/>
<template-type-parameter name="Functor"/>
</template>
<type>bool</type>
<parameter name="f"><paramtype>const <classname>function</classname>&lt;Signature, Allocator&gt;&amp;</paramtype></parameter>
<parameter name="g"><paramtype>Functor</paramtype></parameter>
</signature>
<signature>
<template>
<template-type-parameter name="Signature"/>
<template-type-parameter name="Allocator"/>
<template-type-parameter name="Functor"/>
</template>
<type>bool</type>
<parameter name="g"><paramtype>Functor</paramtype></parameter>
<parameter name="f"><paramtype>const <classname>function</classname>&lt;Signature, Allocator&gt;&amp;</paramtype></parameter>
</signature>
<signature>
<template>
<template-type-parameter name="Signature"/>
<template-type-parameter name="Allocator"/>
<template-type-parameter name="Functor"/>
</template>
<type>bool</type>
<parameter name="f"><paramtype>const <classname>function</classname>&lt;Signature, Allocator&gt;&amp;</paramtype></parameter>
<parameter name="g"><paramtype><classname>reference_wrapper</classname>&lt;Functor&gt;</paramtype></parameter>
</signature>
<signature>
<template>
<template-type-parameter name="Signature"/>
<template-type-parameter name="Allocator"/>
<template-type-parameter name="Functor"/>
</template>
<type>bool</type>
<parameter name="g"><paramtype><classname>reference_wrapper</classname>&lt;Functor&gt;</paramtype></parameter>
<parameter name="f"><paramtype>const <classname>function</classname>&lt;Signature, Allocator&gt;&amp;</paramtype></parameter>
</signature>
<signature>
<template> <template>
<template-type-parameter name="Signature1"/> <template-type-parameter name="Signature1"/>
<template-type-parameter name="Allocator1"/> <template-type-parameter name="Allocator1"/>
@ -493,9 +835,38 @@
<type>void</type> <type>void</type>
<parameter name="f1"><paramtype>const <classname>function</classname>&lt;Signature1, Allocator1&gt;&amp;</paramtype></parameter> <parameter name="f1"><paramtype>const <classname>function</classname>&lt;Signature1, Allocator1&gt;&amp;</paramtype></parameter>
<parameter name="f2"><paramtype>const <classname>function</classname>&lt;Signature2, Allocator2&gt;&amp;</paramtype></parameter> <parameter name="f2"><paramtype>const <classname>function</classname>&lt;Signature2, Allocator2&gt;&amp;</paramtype></parameter>
<notes><simpara>This function must be left undefined.</simpara></notes> </signature>
<rationale><simpara>The <code>safe_bool</code> conversion opens a loophole whereby two function instances can be compared via <code>!=</code>. This undefined <code>void operator !=</code> closes the loophole and ensures a compile-time or link-time error.</simpara></rationale>
</function> <returns><simpara>True when <code>f</code> does not store an
object of type <code>Functor</code> or it stores an object of
type <code>Functor</code> and one of the following conditions
applies:
<itemizedlist>
<listitem><simpara><code>g</code> is of type
<code><classname>reference_wrapper</classname>&lt;Functor&gt;</code>
and <code>f.target&lt;Functor&gt;() != g.<methodname
alt="reference_wrapper::get_pointer">get_pointer</methodname>()</code>.</simpara></listitem>
<listitem><simpara><code>g</code> is not of type
<code><classname>reference_wrapper</classname>&lt;Functor&gt;</code>
and <code>*(f.target&lt;Functor&gt;()) !=
g</code>.</simpara></listitem>
</itemizedlist>
</simpara></returns>
<notes><simpara><code><classname>function</classname></code>
objects are not
<conceptname>EqualityComparable</conceptname>.</simpara></notes>
<rationale><simpara>The <code>safe_bool</code> conversion
opens a loophole whereby two <code>function</code>
instances can be compared via <code>!=</code>, although this
is not feasible to implement. The undefined <code>void
operator!=</code> closes the loophole and ensures a
compile-time or link-time error.</simpara></rationale>
</overloaded-function>
</free-function-group> </free-function-group>
</class> </class>
</namespace> </namespace>

View File

@ -26,6 +26,12 @@
<if-fails><para>Either Boost.Lambda does not work on the platform, or Boost.Function cannot safely be applied without the use of <functionname>boost::unlambda</functionname>.</para></if-fails> <if-fails><para>Either Boost.Lambda does not work on the platform, or Boost.Function cannot safely be applied without the use of <functionname>boost::unlambda</functionname>.</para></if-fails>
</run-test> </run-test>
<run-test filename="contains_test.cpp">
<purpose><para>Test the operation of the
<code><methodname>target</methodname></code> member function and the
equality operators.</para></purpose>
</run-test>
<compile-fail-test filename="function_test_fail1.cpp"> <compile-fail-test filename="function_test_fail1.cpp">
<purpose><para>Test the (incorrect!) use of comparisons between Boost.Function function objects.</para></purpose> <purpose><para>Test the (incorrect!) use of comparisons between Boost.Function function objects.</para></purpose>
<if-fails><para>Intuitive (but incorrect!) code may compile and will give meaningless results.</para></if-fails> <if-fails><para>Intuitive (but incorrect!) code may compile and will give meaningless results.</para></if-fails>