boost_mirror/utility
1
0
Fork 0
mirror of https://github.com/boostorg/utility.git synced 2025-05-09 02:44:10 +00:00
Code Issues Packages Projects Releases Wiki Activity

Fixed references to Doxygen-generated reference and between sections.

Browse Source 
Since BoostBook stylesheets were updated to pass through Doxygen anchor
names to BoostBook output, references from QuickBook and manually
written BoostBook docs were broken. Fix this by using classref/classname
and similar tools to reference Doxygen-generated content.

Also, to avoid anchor clashes between different parts of Boost.Utility
docs, use proper anchor namespacing: avoid using manual anchors where
possible and use fully qualified namespace where not.

Fixes https://github.com/boostorg/utility/issues/110.
This commit is contained in:
Andrey Semashev 2025-05-03 05:17:00 +03:00
parent 67d8cbd243
commit 49cd132374
13 changed files with 575 additions and 619 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
doc/BOOST_BINARY.qbk
View File

@ -6,8 +6,7 @@
/]
[/===============]
[#sec:BOOST_BINARY]
[section Binary Integer Literals]
[section:BOOST_BINARY Binary Integer Literals]
[/===============]
[section Introduction]

1
doc/Jamfile.v2
View File

@ -285,6 +285,7 @@ doxygen result_of_reference
doxygen string_view_reference
:
$(INCLUDES)/boost/utility/string_view.hpp
$(INCLUDES)/boost/utility/string_ref.hpp
:
<location>tmp
<doxygen:param>ENABLE_PREPROCESSING=YES

26
doc/call_traits.qbk
View File

@ -7,7 +7,7 @@
/]
[/===============]
[section Call Traits]
[section:call_traits Call Traits]
[/===============]
[section Introduction]
@ -19,9 +19,9 @@ The template class __call_traits_T__ encapsulates the
"best" method to pass a parameter of some type `T` to or
from a function, and consists of a collection of `typedef`s defined
as in the table below. The purpose of __call_traits__ is to ensure
that problems like [link sec:refs "references to references"]
that problems like [link utility.utilities.call_traits.examples.refs "references to references"]
never occur, and that parameters are passed in the most efficient
manner possible, as in the [link sec:examples examples]. In each
manner possible, as in the [link utility.utilities.call_traits.examples examples]. In each
case, if your existing practice is to use the type defined on the
left, then replace it with the __call_traits__ defined type on the
right.
@ -100,7 +100,7 @@ used to solve the reference to reference problem.
Notes:
# If `T` is already reference type, then __call_traits__ is
defined such that [link sec:refs "references to references"]
defined such that [link utility.utilities.call_traits.examples.refs "references to references"]
do not occur (requires partial specialization).
# If `T` is an array type, then __call_traits__ defines `value_type`
as a "constant pointer to type" rather than an
@ -145,8 +145,7 @@ If `T` is an assignable type the following assignments are possible:
]
[endsect]
[#sec:examples]
[section Examples]
[section:examples Examples]
The following table shows the effect that __call_traits__ has on
various types.
@ -204,8 +203,7 @@ struct contained
```
[endsect]
[#sec:refs]
[section Example 2 (the reference to reference problem):]
[section:refs Example 2 (the reference to reference problem):]
Consider the definition of __std_binder1st__:
@ -241,8 +239,7 @@ the no "reference to reference" occurs.
[endsect]
[#sec:example3]
[section Example 3 (the `make_pair` problem):]
[section:example3 Example 3 (the `make_pair` problem):]
If we pass the name of an array as one (or both) arguments to `__std_make_pair__`,
then template argument deduction deduces the passed parameter as
@ -277,8 +274,7 @@ __std_make_pair__ are not expressed in terms of __call_traits__: doing so
would prevent template argument deduction from functioning.
[endsect]
[#sec:example4]
[section Example 4 (optimising fill):]
[section:example4 Example 4 (optimising fill):]
The __call_traits__ template will "optimize" the passing
of a small built-in type as a function parameter. This mainly has
@ -359,12 +355,12 @@ Small built-in types, what the standard calls [@https://en.cppreference.com/w/cp
types], differ from existing practice only in the `param_type`
`typedef`. In this case passing `T const` is compatible
with existing practice, but may improve performance in some cases
(see [link sec:example4 Example 4]). In any case this should never
(see [link utility.utilities.call_traits.examples.example4 Example 4]). In any case this should never
be any worse than existing practice.
Pointers follow the same rationale as small built-in types.
For reference types the rationale follows [link sec:refs Example 2]
For reference types the rationale follows [link utility.utilities.call_traits.examples.refs Example 2]
- references to references are not allowed, so the __call_traits__
members must be defined such that these problems do
not occur. There is a proposal to modify the language such that
@ -425,7 +421,7 @@ For `value_type` (return by value), again only a pointer may be
returned, not a copy of the whole array, and again __call_traits__
makes the degradation explicit. The `value_type` member is useful
whenever an array must be explicitly degraded to a pointer -
[link sec:example3 Example 3] provides the test case.
[link utility.utilities.call_traits.examples.example3 Example 3] provides the test case.
Footnote: the array specialisation for __call_traits__ is the least
well understood of all the __call_traits__ specialisations. If the given

2
doc/compressed_pair.qbk
View File

@ -8,7 +8,7 @@
or copy at http://boost.org/LICENSE_1_0.txt
]
[section Compressed Pair]
[section:compressed_pair Compressed Pair]
[section Introduction]

4
doc/in_place_factory.qbk
View File

@ -7,8 +7,7 @@
/]
[/===============]
[#sec:in_place_factory]
[section In-place Factory]
[section:in_place_factory In-place Factory]
[/===============]
[section Introduction]
@ -296,7 +295,6 @@ void foo()
[endsect]
[/===============]
[#boost.typed_in_place_factory_base]
[xinclude tmp/in_place_factory_reference.xml]
[/===============]

213
doc/main.qbk
View File

@ -57,113 +57,113 @@
[/ (Macros are defined here because these macros are often referenced in other components) ]
[/ (operators macros link to the a table of operators because there's no doxygen reference for the operators) ]
[def __BOOST_BINARY__ [link sec:BOOST_BINARY `BOOST_BINARY`]]
[def __in_place_factory__ [link sec:in_place_factory `in_place_factory`]]
[def __BOOST_BINARY__ [link utility.utilities.BOOST_BINARY `BOOST_BINARY`]]
[def __in_place_factory__ [link utility.utilities.in_place_factory `in_place_factory`]]
[def __boost_base_from_member__ [link boost.base_from_member `boost::base_from_member`]]
[def __boost_call_traits__ [link boost.call_traits `boost::call_traits`]]
[def __boost_result_of__ [link boost.result_of `boost::result_of`]]
[def __boost_tr1_result_of__ [link boost.tr1_result_of `boost::tr1_result_of`]]
[def __boost_string_view__ [link boost.basic_string_view `boost::string_view`]]
[def __boost_basic_string_view__ [link boost.basic_string_view `boost::basic_string_view`]]
[def __boost_base_from_member__ [classref boost::base_from_member `boost::base_from_member`]]
[def __boost_call_traits__ [classref boost::call_traits `boost::call_traits`]]
[def __boost_result_of__ [classref boost::result_of `boost::result_of`]]
[def __boost_tr1_result_of__ [classref boost::tr1_result_of `boost::tr1_result_of`]]
[def __boost_string_view__ [classref boost::basic_string_view `boost::string_view`]]
[def __boost_basic_string_view__ [classref boost::basic_string_view `boost::basic_string_view`]]
[def __additive1__ [link sec:arithmetic `additive1`]]
[def __additive2__ [link sec:arithmetic `additive2`]]
[def __arithmetic1__ [link sec:arithmetic `arithmetic1`]]
[def __arithmetic2__ [link sec:arithmetic `arithmetic2`]]
[def __base_from_member__ [link boost.base_from_member `base_from_member`]]
[def __basic_string_ref__ [link boost.basic_string_view `basic_string_ref`]]
[def __basic_string_view__ [link boost.basic_string_view `basic_string_view`]]
[def __bidirectional_iteratable__ [link sec:arithmetic `bidirectional_iteratable`]]
[def __bidirectional_iterator_helper__ [link sec:arithmetic `bidirectional_iterator_helper`]]
[def __bitwise1__ [link sec:arithmetic `bitwise1`]]
[def __bitwise2__ [link sec:arithmetic `bitwise2`]]
[def __call_traits__ [link boost.call_traits `call_traits`]]
[def __call_traits_T__ [link boost.call_traits `call_traits<T>`]]
[def __call_traits_lt__T___ [link boost.call_traits `call_traits<T&>`]]
[def __call_traits_lt__T_lb_N_rb__gt___ [link boost.call_traits `call_traits< T[N]>`]]
[def __call_traits_lt__const_T_lb_N_rb__gt___ [link boost.call_traits `call_traits< const T[N]>`]]
[def __compressed_pair__ [link boost.compressed_pair `compressed_pair`]]
[def __decrementable__ [link sec:arithmetic `decrementable`]]
[def __dereferenceable__ [link sec:arithmetic `dereferenceable`]]
[def __equal_pointees__ [link sec:arithmetic `equal_pointees`]]
[def __equal_pointees_t__ [link sec:arithmetic `equal_pointees_t`]]
[def __equality_comparable1__ [link sec:arithmetic `equality_comparable1`]]
[def __equality_comparable2__ [link sec:arithmetic `equality_comparable2`]]
[def __equivalent1__ [link sec:arithmetic `equivalent1`]]
[def __equivalent2__ [link sec:arithmetic `equivalent2`]]
[def __euclidean_ring_operators1__ [link sec:arithmetic `euclidean_ring_operators1`]]
[def __euclidean_ring_operators2__ [link sec:arithmetic `euclidean_ring_operators2`]]
[def __field_operators1__ [link sec:arithmetic `field_operators1`]]
[def __field_operators2__ [link sec:arithmetic `field_operators2`]]
[def __forward_iteratable__ [link sec:arithmetic `forward_iteratable`]]
[def __forward_iterator_helper__ [link sec:arithmetic `forward_iterator_helper`]]
[def __get__ [link boost.get `get`]]
[def __hash_range__ [link boost.hash_range `hash_range`]]
[def __hash_value__ [link boost.hash_value `hash_value`]]
[def __in_place_factory_base__ [link boost.in_place_factory_base `in_place_factory_base`]]
[def __incrementable__ [link sec:arithmetic `incrementable`]]
[def __indexable__ [link sec:arithmetic `indexable`]]
[def __initialized__ [link boost.initialized `initialized`]]
[def __initialized_value__ [link boost.initialized_value `initialized_value`]]
[def __initialized_value_t__ [link boost.initialized_value_t `initialized_value_t`]]
[def __input_iteratable__ [link sec:arithmetic `input_iteratable`]]
[def __input_iterator_helper__ [link sec:arithmetic `input_iterator_helper`]]
[def __integer_arithmetic1__ [link sec:arithmetic `integer_arithmetic1`]]
[def __integer_arithmetic2__ [link sec:arithmetic `integer_arithmetic2`]]
[def __integer_multiplicative1__ [link sec:arithmetic `integer_multiplicative1`]]
[def __integer_multiplicative2__ [link sec:arithmetic `integer_multiplicative2`]]
[def __is_chained_base__ [link sec:arithmetic `is_chained_base`]]
[def __less_pointees__ [link boost.less_pointees `less_pointees`]]
[def __less_pointees_t__ [link boost.less_pointees_t `less_pointees_t`]]
[def __less_than_comparable1__ [link sec:arithmetic `less_than_comparable1`]]
[def __less_than_comparable2__ [link sec:arithmetic `less_than_comparable2`]]
[def __multiplicative1__ [link sec:arithmetic `multiplicative1`]]
[def __multiplicative2__ [link sec:arithmetic `multiplicative2`]]
[def __operator_eq__eq__ [link sec:arithmetic `operator==`]]
[def __operator_gt__ [link sec:arithmetic `operator_gt_`]]
[def __operator_gt__eq__ [link sec:arithmetic `operator&gt;`]]
[def __operator_lt__ [link sec:arithmetic `operator&lt;`]]
[def __operator_lt__eq__ [link sec:arithmetic `operator&lt;=`]]
[def __operator_lt__lt__ [link sec:arithmetic `operator&lt;&lt;`]]
[def __operator_not__eq__ [link sec:arithmetic `operator!=`]]
[def __operators2__ [link sec:arithmetic `operators2`]]
[def __operators__ [link sec:arithmetic `operators`]]
[def __operators_lt_T__ [link sec:arithmetic `operators<T,T>`]]
[def __ordered_euclidean_ring_operators1__ [link sec:arithmetic `ordered_euclidean_ring_operators1`]]
[def __ordered_euclidean_ring_operators2__ [link sec:arithmetic `ordered_euclidean_ring_operators2`]]
[def __ordered_euclidian_ring_operators1__ [link sec:arithmetic `ordered_euclidian_ring_operators1`]]
[def __ordered_euclidian_ring_operators2__ [link sec:arithmetic `ordered_euclidian_ring_operators2`]]
[def __ordered_field_operators1__ [link sec:arithmetic `ordered_field_operators1`]]
[def __ordered_field_operators2__ [link sec:arithmetic `ordered_field_operators2`]]
[def __ordered_ring_operators1__ [link sec:arithmetic `ordered_ring_operators1`]]
[def __ordered_ring_operators2__ [link sec:arithmetic `ordered_ring_operators2`]]
[def __output_iteratable__ [link sec:arithmetic `output_iteratable`]]
[def __output_iterator_helper__ [link sec:arithmetic `output_iterator_helper`]]
[def __partially_ordered1__ [link sec:arithmetic `partially_ordered1`]]
[def __partially_ordered2__ [link sec:arithmetic `partially_ordered2`]]
[def __random_access_iteratable__ [link sec:arithmetic `random_access_iteratable`]]
[def __random_access_iterator_helper__ [link sec:arithmetic `random_access_iterator_helper`]]
[def __result_of__ [link boost.result_of `result_of`]]
[def __ring_operators1__ [link sec:arithmetic `ring_operators1`]]
[def __ring_operators2__ [link sec:arithmetic `ring_operators2`]]
[def __shiftable1__ [link sec:arithmetic `shiftable1`]]
[def __shiftable2__ [link sec:arithmetic `shiftable2`]]
[def __string_ref__ [link boost.basic_string_view `string_ref`]]
[def __string_view__ [link boost.basic_string_view `string_view`]]
[def __swap__ [link sec:arithmetic `swap`]]
[def __totally_ordered1__ [link sec:arithmetic `totally_ordered1`]]
[def __totally_ordered2__ [link sec:arithmetic `totally_ordered2`]]
[def __tr1_result_of__ [link boost.tr1_result_of `tr1_result_of`]]
[def __typed_in_place_factory_base__ [link boost.typed_in_place_factory_base `typed_in_place_factory_base`]]
[def __u16string_ref__ [link boost.basic_string_view `u16string_ref`]]
[def __u16string_view__ [link boost.basic_string_view `u16string_view`]]
[def __u32string_ref__ [link boost.basic_string_view `u32string_ref`]]
[def __u32string_view__ [link boost.basic_string_view `u32string_view`]]
[def __unit_steppable__ [link sec:arithmetic `unit_steppable`]]
[def __value_initialized__ [link boost.value_initialized `value_initialized`]]
[def __wstring_ref__ [link boost.basic_string_view `wstring_ref`]]
[def __wstring_view__ [link boost.basic_string_view `wstring_view`]]
[def __additive1__ [link utility.utilities.operators.arithmetic `additive1`]]
[def __additive2__ [link utility.utilities.operators.arithmetic `additive2`]]
[def __arithmetic1__ [link utility.utilities.operators.arithmetic `arithmetic1`]]
[def __arithmetic2__ [link utility.utilities.operators.arithmetic `arithmetic2`]]
[def __base_from_member__ [classref boost::base_from_member `base_from_member`]]
[def __basic_string_ref__ [classref boost::basic_string_ref `basic_string_ref`]]
[def __basic_string_view__ [classref boost::basic_string_view `basic_string_view`]]
[def __bidirectional_iteratable__ [link utility.utilities.operators.arithmetic `bidirectional_iteratable`]]
[def __bidirectional_iterator_helper__ [link utility.utilities.operators.arithmetic `bidirectional_iterator_helper`]]
[def __bitwise1__ [link utility.utilities.operators.arithmetic `bitwise1`]]
[def __bitwise2__ [link utility.utilities.operators.arithmetic `bitwise2`]]
[def __call_traits__ [classref boost::call_traits `call_traits`]]
[def __call_traits_T__ [classref boost::call_traits `call_traits<T>`]]
[def __call_traits_lt__T___ [classref boost::call_traits `call_traits<T&>`]]
[def __call_traits_lt__T_lb_N_rb__gt___ [classref boost::call_traits `call_traits< T[N]>`]]
[def __call_traits_lt__const_T_lb_N_rb__gt___ [classref boost::call_traits `call_traits< const T[N]>`]]
[def __compressed_pair__ [classref boost::compressed_pair `compressed_pair`]]
[def __decrementable__ [link utility.utilities.operators.arithmetic `decrementable`]]
[def __dereferenceable__ [link utility.utilities.operators.arithmetic `dereferenceable`]]
[def __equal_pointees__ [link utility.utilities.operators.arithmetic `equal_pointees`]]
[def __equal_pointees_t__ [link utility.utilities.operators.arithmetic `equal_pointees_t`]]
[def __equality_comparable1__ [link utility.utilities.operators.arithmetic `equality_comparable1`]]
[def __equality_comparable2__ [link utility.utilities.operators.arithmetic `equality_comparable2`]]
[def __equivalent1__ [link utility.utilities.operators.arithmetic `equivalent1`]]
[def __equivalent2__ [link utility.utilities.operators.arithmetic `equivalent2`]]
[def __euclidean_ring_operators1__ [link utility.utilities.operators.arithmetic `euclidean_ring_operators1`]]
[def __euclidean_ring_operators2__ [link utility.utilities.operators.arithmetic `euclidean_ring_operators2`]]
[def __field_operators1__ [link utility.utilities.operators.arithmetic `field_operators1`]]
[def __field_operators2__ [link utility.utilities.operators.arithmetic `field_operators2`]]
[def __forward_iteratable__ [link utility.utilities.operators.arithmetic `forward_iteratable`]]
[def __forward_iterator_helper__ [link utility.utilities.operators.arithmetic `forward_iterator_helper`]]
[def __get__ [funcref boost::get `get`]]
[def __hash_range__ [funcref boost::hash_range `hash_range`]]
[def __hash_value__ [funcref boost::hash_value `hash_value`]]
[def __in_place_factory_base__ [classref boost::in_place_factory_base `in_place_factory_base`]]
[def __incrementable__ [link utility.utilities.operators.arithmetic `incrementable`]]
[def __indexable__ [link utility.utilities.operators.arithmetic `indexable`]]
[def __initialized__ [classref boost::initialized `initialized`]]
[def __initialized_value__ [globalref boost::initialized_value `initialized_value`]]
[def __initialized_value_t__ [classref boost::initialized_value_t `initialized_value_t`]]
[def __input_iteratable__ [link utility.utilities.operators.arithmetic `input_iteratable`]]
[def __input_iterator_helper__ [link utility.utilities.operators.arithmetic `input_iterator_helper`]]
[def __integer_arithmetic1__ [link utility.utilities.operators.arithmetic `integer_arithmetic1`]]
[def __integer_arithmetic2__ [link utility.utilities.operators.arithmetic `integer_arithmetic2`]]
[def __integer_multiplicative1__ [link utility.utilities.operators.arithmetic `integer_multiplicative1`]]
[def __integer_multiplicative2__ [link utility.utilities.operators.arithmetic `integer_multiplicative2`]]
[def __is_chained_base__ [link utility.utilities.operators.arithmetic `is_chained_base`]]
[def __less_pointees__ [funcref boost::less_pointees `less_pointees`]]
[def __less_pointees_t__ [class boost::less_pointees_t `less_pointees_t`]]
[def __less_than_comparable1__ [link utility.utilities.operators.arithmetic `less_than_comparable1`]]
[def __less_than_comparable2__ [link utility.utilities.operators.arithmetic `less_than_comparable2`]]
[def __multiplicative1__ [link utility.utilities.operators.arithmetic `multiplicative1`]]
[def __multiplicative2__ [link utility.utilities.operators.arithmetic `multiplicative2`]]
[def __operator_eq__eq__ [link utility.utilities.operators.arithmetic `operator==`]]
[def __operator_gt__ [link utility.utilities.operators.arithmetic `operator_gt_`]]
[def __operator_gt__eq__ [link utility.utilities.operators.arithmetic `operator&gt;`]]
[def __operator_lt__ [link utility.utilities.operators.arithmetic `operator&lt;`]]
[def __operator_lt__eq__ [link utility.utilities.operators.arithmetic `operator&lt;=`]]
[def __operator_lt__lt__ [link utility.utilities.operators.arithmetic `operator&lt;&lt;`]]
[def __operator_not__eq__ [link utility.utilities.operators.arithmetic `operator!=`]]
[def __operators2__ [link utility.utilities.operators.arithmetic `operators2`]]
[def __operators__ [link utility.utilities.operators.arithmetic `operators`]]
[def __operators_lt_T__ [link utility.utilities.operators.arithmetic `operators<T,T>`]]
[def __ordered_euclidean_ring_operators1__ [link utility.utilities.operators.arithmetic `ordered_euclidean_ring_operators1`]]
[def __ordered_euclidean_ring_operators2__ [link utility.utilities.operators.arithmetic `ordered_euclidean_ring_operators2`]]
[def __ordered_euclidian_ring_operators1__ [link utility.utilities.operators.arithmetic `ordered_euclidian_ring_operators1`]]
[def __ordered_euclidian_ring_operators2__ [link utility.utilities.operators.arithmetic `ordered_euclidian_ring_operators2`]]
[def __ordered_field_operators1__ [link utility.utilities.operators.arithmetic `ordered_field_operators1`]]
[def __ordered_field_operators2__ [link utility.utilities.operators.arithmetic `ordered_field_operators2`]]
[def __ordered_ring_operators1__ [link utility.utilities.operators.arithmetic `ordered_ring_operators1`]]
[def __ordered_ring_operators2__ [link utility.utilities.operators.arithmetic `ordered_ring_operators2`]]
[def __output_iteratable__ [link utility.utilities.operators.arithmetic `output_iteratable`]]
[def __output_iterator_helper__ [link utility.utilities.operators.arithmetic `output_iterator_helper`]]
[def __partially_ordered1__ [link utility.utilities.operators.arithmetic `partially_ordered1`]]
[def __partially_ordered2__ [link utility.utilities.operators.arithmetic `partially_ordered2`]]
[def __random_access_iteratable__ [link utility.utilities.operators.arithmetic `random_access_iteratable`]]
[def __random_access_iterator_helper__ [link utility.utilities.operators.arithmetic `random_access_iterator_helper`]]
[def __result_of__ [classref boost::result_of `result_of`]]
[def __ring_operators1__ [link utility.utilities.operators.arithmetic `ring_operators1`]]
[def __ring_operators2__ [link utility.utilities.operators.arithmetic `ring_operators2`]]
[def __shiftable1__ [link utility.utilities.operators.arithmetic `shiftable1`]]
[def __shiftable2__ [link utility.utilities.operators.arithmetic `shiftable2`]]
[def __string_ref__ [classref boost::basic_string_ref `string_ref`]]
[def __string_view__ [classref boost::basic_string_view `string_view`]]
[def __swap__ [link utility.utilities.operators.arithmetic `swap`]]
[def __totally_ordered1__ [link utility.utilities.operators.arithmetic `totally_ordered1`]]
[def __totally_ordered2__ [link utility.utilities.operators.arithmetic `totally_ordered2`]]
[def __tr1_result_of__ [classref boost::tr1_result_of `tr1_result_of`]]
[def __typed_in_place_factory_base__ [classref boost::typed_in_place_factory_base `typed_in_place_factory_base`]]
[def __u16string_ref__ [classref boost::basic_string_ref `u16string_ref`]]
[def __u16string_view__ [classref boost::basic_string_view `u16string_view`]]
[def __u32string_ref__ [classref boost::basic_string_ref `u32string_ref`]]
[def __u32string_view__ [classref boost::basic_string_view `u32string_view`]]
[def __unit_steppable__ [link utility.utilities.operators.arithmetic `unit_steppable`]]
[def __value_initialized__ [classref boost::value_initialized `value_initialized`]]
[def __wstring_ref__ [classref boost::basic_string_ref `wstring_ref`]]
[def __wstring_view__ [classref boost::basic_string_view `wstring_view`]]
[/ std:: types ]
@ -219,8 +219,7 @@
[include other.qbk]
[#sec:reference]
[section:ref Quick Reference]
[section:reference Quick Reference]
[/ Reference table ]
[xinclude quickref.xml]

584
doc/operators.qbk
View File

File diff suppressed because it is too large Load Diff

2
doc/other.qbk
View File

@ -7,7 +7,7 @@
Official repository: https://github.com/boostorg/utility
]
[section:utilities More Utilities]
[section:more_utilities More Utilities]
Some utilities have been moved from Boost.Utilities to more appropriate Boost libraries:

16
doc/overview.qbk
View File

@ -20,14 +20,14 @@ Over time,
When the component has moved to another Boost library, Boost.Utility headers still lead to the appropriate headers
in other libraries.
[table:id Components
[table Components
[[Boost.Utility] [Moved to Boost] [C++ Standard variant]]
[[[@boost:/libs/core/doc/html/core/addressof.html `addressof`]] [[@boost:/libs/core/index.html Boost.Core]] [C++11 __std_addressof__]]
[[__base_from_member__] [] []]
[[[link utility.utilities.base_from_member `base_from_member`]] [] []]
[[__BOOST_BINARY__] [] [C++14 [@https://en.cppreference.com/w/cpp/language/integer_literal Binary integer literal]]]
[[__call_traits__] [] []]
[[[link utility.utilities.call_traits `call_traits`]] [] []]
[[[@boost:/libs/core/doc/html/core/checked_delete.html `checked_delete`]] [[@boost:/libs/core/index.html Boost.Core]] []]
[[__compressed_pair__] [] []]
[[[link utility.utilities.compressed_pair `compressed_pair`]] [] []]
[[[@boost:/libs/type_traits/doc/html/boost_typetraits/reference/declval.html `declval`]] [[@boost:/libs/type_traits/index.html Boost.TypeTraits]] [C++11 __std_declval__]]
[[[@boost:/libs/core/doc/html/core/enable_if.html `enable_if`]] [[@boost:/libs/core/index.html Boost.Core]] [C++11 __std_enable_if__]]
[[[@boost:/libs/iterator/doc/generator_iterator.htm generator iterator adaptors]] [[@boost:/libs/iterator/index.html Boost.Iterator]] []]
@ -35,12 +35,12 @@ in other libraries.
[[[@boost:/libs/iterator/index.html `iterator_adaptors`]] [[@boost:/libs/iterator/index.html Boost.Iterator]] []]
[[[@boost:/libs/iterator/doc/html/iterator/algorithms/next_prior.html `next` / `prior`]] [[@boost:/libs/iterator/index.html Boost.Iterator]] [C++11 __std_next__ / __std_prev__]]
[[[@boost:/libs/core/doc/html/core/noncopyable.html `noncopyable`]] [[@boost:/libs/core/index.html Boost.Core]] []]
[[[link sec:operators `operators`]] [] []]
[[[link utility.utilities.operators `operators`]] [] []]
[[[@boost:/libs/io/doc/html/io.html `ostream_string`]] [[@boost:/libs/io/index.html Boost.IO]] []]
[[__result_of__] [] [C++11 __std_result_of__]]
[[__string_view__] [] [C++17 __std_string_view__]]
[[[link utility.utilities.result_of `result_of`]] [] [C++11 __std_result_of__]]
[[[link utility.utilities.string_view `string_view`]] [] [C++17 __std_string_view__]]
[[[@boost:/libs/throw_exception/doc/html/throw_exception.html#using_boost_throw_exception `throw_exception`]] [[@boost:/libs/throw_exception/index.html Boost.ThrowException]] []]
[[[link sec:value_init `value_init`]] [] [C++11 [@https://en.cppreference.com/w/cpp/language/list_initialization List initialization]]]
[[[link utility.utilities.value_init `value_init`]] [] [C++11 [@https://en.cppreference.com/w/cpp/language/list_initialization List initialization]]]
]
[endsect]

261
doc/quickref.xml
View File

@ -43,7 +43,7 @@
<bridgehead renderas="sect3">Classes</bridgehead>
<simplelist type="vert" columns="1">
<member>
<link linkend="boost.base_from_member">base_from_member</link>
<classname alt="boost::base_from_member">base_from_member</classname>
</member>
</simplelist>
</entry>
@ -53,19 +53,16 @@
<bridgehead renderas="sect3">Type Traits</bridgehead>
<simplelist type="vert" columns="1">
<member>
<link linkend="boost.call_traits">call_traits</link>
<classname alt="boost::call_traits">call_traits</classname>
</member>
<member>
<link linkend="boost.call_traits">call_traits&lt;T&amp;&gt;</link>
<classname alt="boost::call_traits">call_traits&lt;T&amp;&gt;</classname>
</member>
<member>
<link linkend="boost.call_traits">call_traits&lt;T[N]&gt;
</link>
<classname alt="boost::call_traits">call_traits&lt;T[N]&gt;</classname>
</member>
<member>
<link linkend="boost.call_traits">call_traits&lt;const
T[N]&gt;
</link>
<classname alt="boost::call_traits">call_traits&lt;const T[N]&gt;</classname>
</member>
</simplelist>
</entry>
@ -75,14 +72,14 @@
<bridgehead renderas="sect3">Classes</bridgehead>
<simplelist type="vert" columns="1">
<member>
<link linkend="boost.compressed_pair">compressed_pair</link>
<classname alt="boost::compressed_pair">compressed_pair</classname>
</member>
</simplelist>
<bridgehead renderas="sect3">Functions</bridgehead>
<simplelist type="vert" columns="1">
<member>
<link linkend="header.boost.detail.compressed_pair_hpp">swap</link>
<headername alt="boost/detail/compressed_pair.hpp">swap</headername>
</member>
</simplelist>
</entry>
@ -92,11 +89,10 @@
<bridgehead renderas="sect3">Classes</bridgehead>
<simplelist type="vert" columns="1">
<member>
<link linkend="boost.in_place_factory_base">in_place_factory_base</link>
<classname alt="boost::in_place_factory_base">in_place_factory_base</classname>
</member>
<member>
<link linkend="boost.typed_in_place_factory_base">typed_in_place_factory_base
</link>
<classname alt="boost::typed_in_place_factory_base">typed_in_place_factory_base</classname>
</member>
</simplelist>
</entry>
@ -126,45 +122,45 @@
<bridgehead renderas="sect3">Classes (1 of 5)</bridgehead>
<simplelist type="vert" columns="1">
<member>
<link linkend="sec:arithmetic">additive1</link>
<link linkend="utility.utilities.operators.arithmetic.grpd_oprs.additive1">additive1</link>
</member>
<member>
<link linkend="sec:arithmetic">additive2</link>
<link linkend="utility.utilities.operators.arithmetic.grpd_oprs.additive2">additive2</link>
</member>
<member>
<link linkend="sec:arithmetic">arithmetic1</link>
<link linkend="utility.utilities.operators.arithmetic.grpd_oprs.arithmetic1">arithmetic1</link>
</member>
<member>
<link linkend="sec:arithmetic">arithmetic2</link>
<link linkend="utility.utilities.operators.arithmetic.grpd_oprs.arithmetic2">arithmetic2</link>
</member>
<member>
<link linkend="sec:arithmetic">bidirectional_iteratable</link>
<link linkend="utility.utilities.operators.deref.grpd_iter_oprs.bidirectional_iteratable">bidirectional_iteratable</link>
</member>
<member>
<link linkend="sec:arithmetic">
<link linkend="utility.utilities.operators.deref.iterator.bidirectional_iterator_helper">
bidirectional_iterator_helper
</link>
</member>
<member>
<link linkend="sec:arithmetic">bitwise1</link>
<link linkend="utility.utilities.operators.arithmetic.grpd_oprs.bitwise1">bitwise1</link>
</member>
<member>
<link linkend="sec:arithmetic">bitwise2</link>
<link linkend="utility.utilities.operators.arithmetic.grpd_oprs.bitwise2">bitwise2</link>
</member>
<member>
<link linkend="sec:arithmetic">decrementable</link>
<link linkend="utility.utilities.operators.arithmetic.smpl_oprs.decrementable">decrementable</link>
</member>
<member>
<link linkend="sec:arithmetic">dereferenceable</link>
<link linkend="utility.utilities.operators.deref.dereference.dereferenceable">dereferenceable</link>
</member>
<member>
<link linkend="sec:arithmetic">equality_comparable1</link>
<link linkend="utility.utilities.operators.arithmetic.smpl_oprs.equality_comparable1">equality_comparable1</link>
</member>
<member>
<link linkend="sec:arithmetic">equality_comparable2</link>
<link linkend="utility.utilities.operators.arithmetic.smpl_oprs.equality_comparable2">equality_comparable2</link>
</member>
<member>
<link linkend="sec:arithmetic">equivalent1</link>
<link linkend="utility.utilities.operators.arithmetic.smpl_oprs.equivalent1">equivalent1</link>
</member>
</simplelist>
</entry>
@ -173,45 +169,45 @@
<bridgehead renderas="sect3">Classes (2 of 5)</bridgehead>
<simplelist type="vert" columns="1">
<member>
<link linkend="sec:arithmetic">equivalent2</link>
<link linkend="utility.utilities.operators.arithmetic.smpl_oprs.equivalent2">equivalent2</link>
</member>
<member>
<link linkend="sec:arithmetic">euclidean_ring_operators1
<link linkend="utility.utilities.operators.arithmetic.grpd_oprs.euclidean_ring_operators1">euclidean_ring_operators1
</link>
</member>
<member>
<link linkend="sec:arithmetic">euclidean_ring_operators2
<link linkend="utility.utilities.operators.arithmetic.grpd_oprs.euclidean_ring_operators2">euclidean_ring_operators2
</link>
</member>
<member>
<link linkend="sec:arithmetic">field_operators1</link>
<link linkend="utility.utilities.operators.arithmetic.grpd_oprs.field_operators1">field_operators1</link>
</member>
<member>
<link linkend="sec:arithmetic">field_operators2</link>
<link linkend="utility.utilities.operators.arithmetic.grpd_oprs.field_operators2">field_operators2</link>
</member>
<member>
<link linkend="sec:arithmetic">forward_iteratable</link>
<link linkend="utility.utilities.operators.deref.grpd_iter_oprs.forward_iteratable">forward_iteratable</link>
</member>
<member>
<link linkend="sec:arithmetic">forward_iterator_helper</link>
<link linkend="utility.utilities.operators.deref.iterator.forward_iterator_helper">forward_iterator_helper</link>
</member>
<member>
<link linkend="sec:arithmetic">incrementable</link>
<link linkend="utility.utilities.operators.arithmetic.smpl_oprs.incrementable">incrementable</link>
</member>
<member>
<link linkend="sec:arithmetic">indexable</link>
<link linkend="utility.utilities.operators.deref.dereference.indexable">indexable</link>
</member>
<member>
<link linkend="sec:arithmetic">input_iteratable</link>
<link linkend="utility.utilities.operators.deref.grpd_iter_oprs.input_iteratable">input_iteratable</link>
</member>
<member>
<link linkend="sec:arithmetic">input_iterator_helper</link>
<link linkend="utility.utilities.operators.deref.iterator.input_iterator_helper">input_iterator_helper</link>
</member>
<member>
<link linkend="sec:arithmetic">integer_arithmetic1</link>
<link linkend="utility.utilities.operators.arithmetic.grpd_oprs.integer_arithmetic1">integer_arithmetic1</link>
</member>
<member>
<link linkend="sec:arithmetic">integer_arithmetic2</link>
<link linkend="utility.utilities.operators.arithmetic.grpd_oprs.integer_arithmetic2">integer_arithmetic2</link>
</member>
</simplelist>
</entry>
@ -220,49 +216,47 @@
<bridgehead renderas="sect3">Classes (3 of 5)</bridgehead>
<simplelist type="vert" columns="1">
<member>
<link linkend="sec:arithmetic">integer_multiplicative1</link>
<link linkend="utility.utilities.operators.arithmetic.grpd_oprs.integer_multiplicative1">integer_multiplicative1</link>
</member>
<member>
<link linkend="sec:arithmetic">integer_multiplicative2</link>
<link linkend="utility.utilities.operators.arithmetic.grpd_oprs.integer_multiplicative2">integer_multiplicative2</link>
</member>
<member>
<link linkend="sec:arithmetic">is_chained_base</link>
<link linkend="utility.utilities.operators.arithmetic.smpl_oprs.less_than_comparable1">less_than_comparable1</link>
</member>
<member>
<link linkend="sec:arithmetic">less_than_comparable1</link>
<link linkend="utility.utilities.operators.arithmetic.smpl_oprs.less_than_comparable2">less_than_comparable2</link>
</member>
<member>
<link linkend="sec:arithmetic">less_than_comparable2</link>
<link linkend="utility.utilities.operators.arithmetic.grpd_oprs.multiplicative1">multiplicative1</link>
</member>
<member>
<link linkend="sec:arithmetic">multiplicative1</link>
<link linkend="utility.utilities.operators.arithmetic.grpd_oprs.multiplicative2">multiplicative2</link>
</member>
<member>
<link linkend="sec:arithmetic">multiplicative2</link>
<link linkend="utility.utilities.operators.arithmetic.ex_oprs.operators1">operators1</link>
</member>
<member>
<link linkend="sec:arithmetic">operators</link>
<link linkend="utility.utilities.operators.arithmetic.ex_oprs.operators2">operators2</link>
</member>
<member>
<link linkend="sec:arithmetic">operators2</link>
<link linkend="utility.utilities.operators.arithmetic.ex_oprs.operators2">operators&lt;T,T&gt;</link>
</member>
<member>
<link linkend="sec:arithmetic">operators&lt;T,T&gt;</link>
</member>
<member>
<link linkend="sec:arithmetic">
<link linkend="utility.utilities.operators.arithmetic.grpd_oprs.ordered_euclidean_ring_operators1">
ordered_euclidean_ring_operators1
</link>
</member>
<member>
<link linkend="sec:arithmetic">
<link linkend="utility.utilities.operators.arithmetic.grpd_oprs.ordered_euclidean_ring_operators2">
ordered_euclidean_ring_operators2
</link>
</member>
<member>
<link linkend="sec:arithmetic">
ordered_euclidian_ring_operators1
</link>
<link linkend="utility.utilities.operators.arithmetic.grpd_oprs.ordered_field_operators1">ordered_field_operators1</link>
</member>
<member>
<link linkend="utility.utilities.operators.arithmetic.grpd_oprs.ordered_field_operators2">ordered_field_operators2</link>
</member>
</simplelist>
</entry>
@ -271,47 +265,45 @@
<bridgehead renderas="sect3">Classes (4 of 5)</bridgehead>
<simplelist type="vert" columns="1">
<member>
<link linkend="sec:arithmetic">
ordered_euclidian_ring_operators2
</link>
<link linkend="utility.utilities.operators.arithmetic.grpd_oprs.ordered_ring_operators1">ordered_ring_operators1</link>
</member>
<member>
<link linkend="sec:arithmetic">ordered_field_operators1</link>
<link linkend="utility.utilities.operators.arithmetic.grpd_oprs.ordered_ring_operators2">ordered_ring_operators2</link>
</member>
<member>
<link linkend="sec:arithmetic">ordered_field_operators2</link>
<link linkend="utility.utilities.operators.deref.grpd_iter_oprs.output_iteratable">output_iteratable</link>
</member>
<member>
<link linkend="sec:arithmetic">ordered_ring_operators1</link>
<link linkend="utility.utilities.operators.deref.iterator.output_iterator_helper">output_iterator_helper</link>
</member>
<member>
<link linkend="sec:arithmetic">ordered_ring_operators2</link>
<link linkend="utility.utilities.operators.arithmetic.smpl_oprs.partially_ordered1">partially_ordered1</link>
</member>
<member>
<link linkend="sec:arithmetic">output_iteratable</link>
<link linkend="utility.utilities.operators.arithmetic.smpl_oprs.partially_ordered2">partially_ordered2</link>
</member>
<member>
<link linkend="sec:arithmetic">output_iterator_helper</link>
<link linkend="utility.utilities.operators.deref.grpd_iter_oprs.random_access_iteratable">random_access_iteratable</link>
</member>
<member>
<link linkend="sec:arithmetic">partially_ordered1</link>
</member>
<member>
<link linkend="sec:arithmetic">partially_ordered2</link>
</member>
<member>
<link linkend="sec:arithmetic">random_access_iteratable</link>
</member>
<member>
<link linkend="sec:arithmetic">
<link linkend="utility.utilities.operators.deref.iterator.random_access_iterator_helper">
random_access_iterator_helper
</link>
</member>
<member>
<link linkend="sec:arithmetic">ring_operators1</link>
<link linkend="utility.utilities.operators.arithmetic.grpd_oprs.ring_operators1">ring_operators1</link>
</member>
<member>
<link linkend="sec:arithmetic">ring_operators2</link>
<link linkend="utility.utilities.operators.arithmetic.grpd_oprs.ring_operators2">ring_operators2</link>
</member>
<member>
<link linkend="utility.utilities.operators.arithmetic.grpd_oprs.shiftable1">shiftable1</link>
</member>
<member>
<link linkend="utility.utilities.operators.arithmetic.grpd_oprs.shiftable2">shiftable2</link>
</member>
<member>
<link linkend="utility.utilities.operators.arithmetic.grpd_oprs.totally_ordered1">totally_ordered1</link>
</member>
</simplelist>
</entry>
@ -320,25 +312,10 @@
<bridgehead renderas="sect3">Classes (5 of 5)</bridgehead>
<simplelist type="vert" columns="1">
<member>
<link linkend="sec:arithmetic">shiftable1</link>
<link linkend="utility.utilities.operators.arithmetic.grpd_oprs.totally_ordered2">totally_ordered2</link>
</member>
<member>
<link linkend="sec:arithmetic">shiftable2</link>
</member>
<member>
<link linkend="sec:arithmetic">totally_ordered1</link>
</member>
<member>
<link linkend="sec:arithmetic">totally_ordered2</link>
</member>
<member>
<link linkend="sec:arithmetic">unit_steppable</link>
</member>
</simplelist>
<bridgehead renderas="sect3">Type Traits</bridgehead>
<simplelist type="vert" columns="1">
<member>
<link linkend="sec:arithmetic">is_chained_base</link>
<link linkend="utility.utilities.operators.arithmetic.grpd_oprs.unit_steppable">unit_steppable</link>
</member>
</simplelist>
</entry>
@ -374,10 +351,10 @@
<bridgehead renderas="sect3">Type Traits</bridgehead>
<simplelist type="vert" columns="1">
<member>
<link linkend="boost.result_of">result_of</link>
<classname alt="boost::result_of">result_of</classname>
</member>
<member>
<link linkend="boost.tr1_result_of">tr1_result_of</link>
<classname alt="boost::tr1_result_of">tr1_result_of</classname>
</member>
</simplelist>
</entry>
@ -387,28 +364,28 @@
<bridgehead renderas="sect3">Aliases</bridgehead>
<simplelist type="vert" columns="1">
<member>
<link linkend="boost.basic_string_view">string_view</link>
<classname alt="boost::basic_string_view">string_view</classname>
</member>
<member>
<link linkend="boost.basic_string_view">u16string_ref</link>
<classname alt="boost::basic_string_ref">u16string_ref</classname>
</member>
<member>
<link linkend="boost.basic_string_view">u16string_view</link>
<classname alt="boost::basic_string_view">u16string_view</classname>
</member>
<member>
<link linkend="boost.basic_string_view">u32string_ref</link>
<classname alt="boost::basic_string_ref">u32string_ref</classname>
</member>
<member>
<link linkend="boost.basic_string_view">u32string_view</link>
<classname alt="boost::basic_string_view">u32string_view</classname>
</member>
<member>
<link linkend="boost.basic_string_view">wstring_ref</link>
<classname alt="boost::basic_string_ref">wstring_ref</classname>
</member>
<member>
<link linkend="boost.basic_string_view">wstring_view</link>
<classname alt="boost::basic_string_view">wstring_view</classname>
</member>
<member>
<link linkend="boost.basic_string_view">string_ref</link>
<classname alt="boost::basic_string_ref">string_ref</classname>
</member>
</simplelist>
</entry>
@ -417,19 +394,19 @@
<bridgehead renderas="sect3">Classes</bridgehead>
<simplelist type="vert" columns="1">
<member>
<link linkend="boost.basic_string_view">basic_string_ref</link>
<classname alt="boost::basic_string_ref">basic_string_ref</classname>
</member>
<member>
<link linkend="boost.basic_string_view">basic_string_view</link>
<classname alt="boost::basic_string_view">basic_string_view</classname>
</member>
</simplelist>
<bridgehead renderas="sect3">Functions</bridgehead>
<simplelist type="vert" columns="1">
<member>
<link linkend="boost.hash_range">hash_range</link>
<functionname alt="boost::hash_range">hash_range</functionname>
</member>
<member>
<link linkend="boost.hash_value">hash_value</link>
<functionname alt="boost::hash_value">hash_value</functionname>
</member>
</simplelist>
</entry>
@ -438,58 +415,58 @@
<bridgehead renderas="sect3">Operators</bridgehead>
<simplelist type="vert" columns="1">
<member>
<link linkend="header.boost.utility.string_view_hpp">operator==</link>
<headername alt="boost/utility/string_view.hpp">operator==</headername>
</member>
<member>
<link linkend="header.boost.utility.string_view_hpp">operator!=</link>
<headername alt="boost/utility/string_view.hpp">operator!=</headername>
</member>
<member>
<link linkend="header.boost.utility.string_view_hpp">operator&lt;</link>
<headername alt="boost/utility/string_view.hpp">operator&lt;</headername>
</member>
<member>
<link linkend="header.boost.utility.string_view_hpp">operator&lt;=</link>
<headername alt="boost/utility/string_view.hpp">operator&lt;=</headername>
</member>
<member>
<link linkend="header.boost.utility.string_view_hpp">operator&gt;</link>
<headername alt="boost/utility/string_view.hpp">operator&gt;</headername>
</member>
<member>
<link linkend="header.boost.utility.string_view_hpp">operator&gt;=</link>
<headername alt="boost/utility/string_view.hpp">operator&gt;=</headername>
</member>
<member>
<link linkend="header.boost.utility.string_view_hpp">operator&lt;&lt;</link>
<headername alt="boost/utility/string_view.hpp">operator&lt;&lt;</headername>
</member>
</simplelist>
</entry>
<!-- value_init -->
<entry valign="top">
<bridgehead renderas="sect3">Classes</bridgehead>
<simplelist type="vert" columns="1">
<member>
<link linkend="boost.initialized">initialized</link>
</member>
<member>
<link linkend="boost.initialized_value_t">initialized_value_t</link>
</member>
<member>
<link linkend="boost.value_initialized">value_initialized</link>
</member>
</simplelist>
<bridgehead renderas="sect3">Functions</bridgehead>
<simplelist type="vert" columns="1">
<member>
<link linkend="header.boost.utility.value_init_hpp">get</link>
</member>
<member>
<link linkend="header.boost.utility.value_init_hpp">swap</link>
</member>
</simplelist>
<bridgehead renderas="sect3">Constants</bridgehead>
<simplelist type="vert" columns="1">
<member>
<link linkend="boost.initialized_value">initialized_value</link>
</member>
</simplelist>
<bridgehead renderas="sect3">Classes</bridgehead>
<simplelist type="vert" columns="1">
<member>
<classname alt="boost::initialized">initialized</classname>
</member>
<member>
<classname alt="boost::initialized_value_t">initialized_value_t</classname>
</member>
<member>
<classname alt="boost::value_initialized">value_initialized</classname>
</member>
</simplelist>
<bridgehead renderas="sect3">Functions</bridgehead>
<simplelist type="vert" columns="1">
<member>
<headername alt="boost/utility/value_init.hpp">get</headername>
</member>
<member>
<headername alt="boost/utility/value_init.hpp">swap</headername>
</member>
</simplelist>
<bridgehead renderas="sect3">Constants</bridgehead>
<simplelist type="vert" columns="1">
<member>
<globalname alt="boost::initialized_value">initialized_value</globalname>
</member>
</simplelist>
</entry>
</row>
</tbody>

20
doc/result_of.qbk
View File

@ -7,7 +7,7 @@
/]
[/===============]
[section Result of]
[section:result_of Result of]
[/===============]
[section Introduction]
@ -122,7 +122,7 @@ and is not implemented by some compilers.
the actual result type deduced by __decltype__, then using TR1 with a __decltype__ fallback
will allow you to work with both your existing TR1 function objects and new C++11
function object. This situation could occur if your legacy function objects
misused the TR1 protocol. See the documentation on known [link sec:result_of_tr1_diff differences]
misused the TR1 protocol. See the documentation on known [link utility.utilities.result_of.result_of_tr1_diff differences]
between __boost_result_of__ and TR1.
* [#BOOST_NO_RESULT_OF] This implementation of __result_of__ requires class template
@ -138,8 +138,7 @@ or, for motivation and design rationale, the __result_of__
[endsect]
[#sec:result_of_guidelines]
[section Usage guidelines for __boost_result_of__]
[section:result_of_guidelines Usage guidelines for __boost_result_of__]
The following are general suggestions about when and how to use __boost_result_of__.
@ -151,7 +150,7 @@ there's no reason to stop using it.
# If you are targeting C++11 but may port your code to legacy compilers
at some time in the future, then use __boost_result_of__ with __decltype__.
When __decltype__ is used __boost_result_of__ and `__std_result_of__` are usually
interchangeable. See the documentation on known [link sec:result_of_cxx11_diff differences]
interchangeable. See the documentation on known [link utility.utilities.result_of.result_of_cxx11_diff differences]
between __boost_result_of__ and C++11 __std_result_of__.
# If compiler portability is required, use __boost_result_of__ with the TR1 protocol
@ -195,8 +194,7 @@ typedef __boost_result_of__<
[endsect]
[#sec:result_of_tr1_protocol_guidelines]
[section Usage guidelines for the TR1 result_of protocol]
[section:result_of_tr1_protocol_guidelines Usage guidelines for the TR1 result_of protocol]
On compliant C++11 compilers, __boost_result_of__ can
use __decltype__ to deduce the type of any
@ -212,7 +210,7 @@ argument types or the cv-qualification of the
function object, simply
define `result_type`. There is no need
to use the `result` template unless the
return type varies.</li>
return type varies.
* Use the protocol specified type when defining
function prototypes. This can help ensure the
@ -274,8 +272,7 @@ struct functor {
[endsect]
[#sec:result_of_tr1_diff]
[section Known differences between __boost_result_of__ and __boost_tr1_result_of__]
[section:result_of_tr1_diff Known differences between __boost_result_of__ and __boost_tr1_result_of__]
When using __decltype__, __boost_result_of__ ignores the TR1 protocol and instead deduces the
return type of function objects directly via __decltype__. In most situations, users
@ -399,8 +396,7 @@ BOOST_STATIC_ASSERT((
[endsect]
[#sec:result_of_cxx11_diff]
[section Known differences between __boost_result_of__ and C++11 result_of]
[section:result_of_cxx11_diff Known differences between __boost_result_of__ and C++11 result_of]
When using __decltype__, __boost_result_of__ implements most of the C++11 __std_result_of__
specification. One known exception is that __boost_result_of__ does not implement the

2
doc/string_view.qbk
View File

@ -7,7 +7,7 @@
/]
[/===============]
[section String View]
[section:string_view String View]
[/===============]
[section Introduction]

60
doc/value_init.qbk
View File

@ -7,9 +7,7 @@
/]
[/===============]
[#sec:value_init]
[section Value Init]
[section:value_init Value Init]
[/===============]
[section Introduction]
@ -61,7 +59,7 @@ the syntax did not allow for a class that has an explicitly declared constructor
The fourth form is the most generic form of them, as it can be used to initialize
arithmetic types, class types, aggregates, pointers, and other types.
The declaration, `T4 var4 = T4()`, should be read as follows: First a temporary
object is created, by `T4()`. This object is [link sec:valueinit value-initialized].
object is created, by `T4()`. This object is [link utility.utilities.value_init.details.value_initialization value-initialized].
Next the temporary object is copied to the named variable, `var4`. Afterwards,
the temporary is destroyed. While the copying and the destruction are likely to
be optimized away, C++ still requires the type `T4` to be __CopyConstructible__.
@ -69,11 +67,11 @@ So `T4` needs to be ['both] __DefaultConstructible__ ['and] __CopyConstructible_
A class may not be CopyConstructible, for example because it may have a
private and undefined copy constructor, or because it may be derived from
`boost::noncopyable`. Scott Meyers \[[link sec:references 2]\] explains why a
`boost::noncopyable`. Scott Meyers \[[link utility.utilities.value_init.references 2]\] explains why a
class would be defined like that.
There is another, less obvious disadvantage to the fourth form, `T4 var4 = T4()`:
It suffers from various [link sec:compiler_issues compiler issues], causing
It suffers from various [link utility.utilities.value_init.details.compiler_issues compiler issues], causing
a variable to be left uninitialized in some compiler specific cases.
The template __value_initialized__ offers a generic way to initialize
@ -103,13 +101,12 @@ but robust against the aforementioned compiler issues.
[endsect]
[#sec:details]
[section Details]
[section:details Details]
The C++ standard \[[link sec:references 3]\] contains the definitions
The C++ standard \[[link utility.utilities.value_init.references 3]\] contains the definitions
of `zero-initialization` and `default-initialization`. Informally, zero-initialization
means that the object is given the initial value `0` converted to the type and
default-initialization means that [@https://en.cppreference.com/w/cpp/named_req/PODType POD] \[[link sec:references 4]\] types are zero-initialized,
default-initialization means that [@https://en.cppreference.com/w/cpp/named_req/PODType POD] \[[link utility.utilities.value_init.references 4]\] types are zero-initialized,
while non-POD class types are initialized with their corresponding default constructors.
A ['declaration] can contain an ['initializer], which specifies the
@ -136,8 +133,7 @@ foo ( __std_string__() ) ;
// as indicated by the initializer ()
```
[#sec:valueinit]
[h5 value-initialization]
[section:value_initialization value-initialization]
The first [@http://www.open-std.org/JTC1/SC22/WG21/docs/cwg_defects.html Technical
Corrigendum for the C++ Standard] (TC1), whose draft was released to the public in
@ -173,8 +169,9 @@ eat ( int() ) ; // value-initialized
eat ( __std_string__() ) ; // value-initialized
```
[#sec:valueinitsyn]
[h5 value-initialization syntax]
[endsect]
[section:syntax value-initialization syntax]
Value initialization is specified using `()`. However, the empty set of
parentheses is not permitted by the syntax of initializers because it is
@ -224,8 +221,9 @@ This is the solution as it was supplied by earlier versions of the
`__value_initialized__<T>` template class. Unfortunately this approach
suffered from various compiler issues.
[#sec:compiler_issues]
[h5 Compiler issues]
[endsect]
[section:compiler_issues Compiler issues]
Various compilers have not yet fully implemented value-initialization.
So when an object should be ['value-initialized] according to the C++ Standard,
@ -242,8 +240,6 @@ go wrong on various compilers.
At the moment of writing, May 2010, the following reported issues regarding
value-initialization are still there in current compiler releases:
* [@https://connect.microsoft.com/VisualStudio/feedback/details/100744 Microsoft Visual Studio Feedback ID 100744, Value-initialization in new-expression]: Reported by Pavel Kuznetsov (MetaCommunications Engineering), 2005.
* [@http://connect.microsoft.com/VisualStudio/feedback/details/484295 Microsoft Visual Studio Feedback ID 484295, VC++ does not value-initialize members of derived classes without user-declared constructor] Reported by Sylvester Hesp, 2009.
* [@https://connect.microsoft.com/VisualStudio/feedback/details/499606 Microsoft Visual Studio Feedback ID 499606, Presence of copy constructor breaks member class initialization] Reported by Alex Vakulenko, 2009
@ -267,11 +263,11 @@ compiler defect macro] `BOOST_NO_COMPLETE_VALUE_INITIALIZATION`.
[endsect]
[#sec:types]
[section Types and objects]
[endsect]
[#sec:val_init]
[section `template class value_initialized<T>`]
[section:types Types and objects]
[section:val_init `template class value_initialized<T>`]
```
namespace boost {
@ -323,7 +319,7 @@ void swap ( __value_initialized__<T>& lhs, __value_initialized__<T>& rhs )
```
An object of this template class is a `T`-wrapper convertible to `'T&'` whose
wrapped object (data member of type `T`) is [link sec:valueinit value-initialized] upon default-initialization
wrapped object (data member of type `T`) is [link utility.utilities.value_init.details.value_initialization value-initialized] upon default-initialization
of this wrapper class:
```
@ -338,7 +334,7 @@ assert( y == def ) ;
The purpose of this wrapper is to provide a consistent syntax for value initialization
of scalar, union and class types (POD and non-POD) since the correct syntax for value
initialization varies (see [link sec:valueinitsyn value-initialization syntax]).
initialization varies (see [link utility.utilities.value_init.details.syntax value-initialization syntax]).
The wrapped object can be accessed either through the conversion operator
`T&`, the member function `data()`, or the non-member function `get()`:
@ -404,7 +400,7 @@ supports the idea of logical constness.
]
[h5 Recommended practice: The non-member get() idiom]
[section Recommended practice: The non-member get() idiom]
The obscure behavior of being able to modify a non-`const`
wrapped object from within a constant wrapper (as was supported by previous
@ -426,8 +422,9 @@ get(cx_c) = 1; // ERROR: Cannot modify a const object
[endsect]
[#sec:initialized]
[section `template class initialized<T>`]
[endsect]
[section:initialized `template class initialized<T>`]
```
@ -491,8 +488,7 @@ direct-initialized, none of the two wrappers really needs to be used.
[endsect]
[#sec:initialized_value]
[section `initialized_value`]
[section:initialized_value `initialized_value`]
```
namespace boost {
@ -538,8 +534,7 @@ T var = __initialized_value__;
[endsect]
[endsect]
[#sec:references]
[section References]
[section:references References]
# Bjarne Stroustrup, Gabriel Dos Reis, and J. Stephen Adamczyk wrote various papers,
proposing to extend the support for brace-enclosed ['initializer lists]
@ -561,8 +556,7 @@ compiler-generated functions you do not want], [@http://www.aristeia.com/books.h
[xinclude tmp/value_init_reference.xml]
[/===============]
[#sec:acknowledgements]
[section Acknowledgements]
[section:acknowledgements Acknowledgements]
__value_initialized__ was developed by Fernando Cacciola, with help and suggestions
from David Abrahams and Darin Adler.