[/
    Copyright (c) 2021, Alan Freitas

    Distributed under the Boost Software License, Version 1.0. (See accompanying
    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

    Official repository: https://github.com/boostorg/utility
]

[/#############################################
                  DOCUMENT INFO
###############################################]

[library Boost.Utility
    [id utility]
    [quickbook 1.6]
    [copyright 2001 Beman Dawes]
    [purpose Utility Library]
    [license
        Distributed under the Boost Software License, Version 1.0.
        (See accompanying file LICENSE_1_0.txt or copy at
        [@http://www.boost.org/LICENSE_1_0.txt])
    ]
    [authors [Dawes, Beman]]
    [category template]
    [category generic]
]

[template mdash[]'''&mdash;''']
[template ndash[]'''&ndash;''']
[template sect[]'''&sect;''']
[template hellip[]'''&hellip;''']

[template indexterm1[term1]'''<indexterm><primary>'''[term1]'''</primary></indexterm>''']
[template indexterm2[term1 term2]'''<indexterm><primary>'''[term1]'''</primary><secondary>'''[term2]'''</secondary></indexterm>''']

[template include_file[path][^<'''<ulink url="https://github.com/boostorg/utility/blob/master/include/'''[path]'''">'''[path]'''</ulink>'''>]]
[template issue[n]'''<ulink url="https://github.com/boostorg/utility/issues/'''[n]'''">#'''[n]'''</ulink>''']

[/ Named Requirements ]

[def __Handler__                ['Handler]]
[def __Allocator__              [@https://en.cppreference.com/w/cpp/named_req/Allocator ['Allocator]]]
[def __CopyAssignable__         [@https://en.cppreference.com/w/cpp/named_req/CopyAssignable ['CopyAssignable]]]
[def __CopyConstructible__      [@https://en.cppreference.com/w/cpp/named_req/CopyConstructible ['CopyConstructible]]]
[def __Copyable__               [@https://en.cppreference.com/w/cpp/concepts/copyable ['Copyable]]]
[def __DefaultConstructible__   [@https://en.cppreference.com/w/cpp/named_req/DefaultConstructible ['DefaultConstructible]]]
[def __Hash__                   [@https://en.cppreference.com/w/cpp/named_req/Hash ['Hash]]]
[def __InputIterator__          [@https://en.cppreference.com/w/cpp/named_req/InputIterator ['InputIterator]]]
[def __MoveAssignable__         [@https://en.cppreference.com/w/cpp/named_req/MoveAssignable ['MoveAssignable]]]
[def __MoveConstructible__      [@https://en.cppreference.com/w/cpp/named_req/MoveConstructible ['MoveConstructible]]]
[def __RandomAccessIterator__   [@https://en.cppreference.com/w/cpp/named_req/RandomAccessIterator ['RandomAccessIterator]]]
[def __Regular__                [@https://en.cppreference.com/w/cpp/concepts/regular ['Regular]]]
[def __Swappable__              [@https://en.cppreference.com/w/cpp/named_req/Swappable ['Swappable]]]

[/ Boost types ]
[/ (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_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 __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`]]

[/ std:: types ]

[def __assert__       [@https://en.cppreference.com/w/cpp/error/assert `assert`]]
[def __decltype__       [@https://en.cppreference.com/w/cpp/language/decltype `decltype`]]
[def __initializer_list__       [@https://en.cppreference.com/w/cpp/utility/initializer_list `std::initializer_list`]]
[def __nullptr__       [@https://en.cppreference.com/w/cpp/language/nullptr `nullptr`]]
[def __std_addressof__              [@https://en.cppreference.com/w/cpp/memory/addressof `std::addressof`]]
[def __std_array__              [@https://en.cppreference.com/w/cpp/container/array `std::array`]]
[def __std_basic_string__             [@https://en.cppreference.com/w/cpp/string/basic_string `std::basic_string`]]
[def __std_basic_string_view__                   [@https://en.cppreference.com/w/cpp/string/basic_string_view `std::basic_string_view`]]
[def __std_binder1st__                [@https://en.cppreference.com/w/cpp/utility/functional/binder12 `std::binder1st`]]
[def __std_complex__            [@https://en.cppreference.com/w/cpp/numeric/complex `std::complex`]]
[def __std_declval__            [@https://en.cppreference.com/w/cpp/utility/declval `std::declval`]]
[def __std_enable_if__            [@https://en.cppreference.com/w/cpp/types/enable_if `std::enable_if`]]
[def __std_enable_if_t__            [@https://en.cppreference.com/w/cpp/types/enable_if `std::enable_if_t`]]
[def __std_fill__                     [@https://en.cppreference.com/w/cpp/algorithm/fill `std::fill`]]
[def __std_hash__               [@https://en.cppreference.com/w/cpp/utility/hash `std::hash`]]
[def __std_initializer_list__       [@https://en.cppreference.com/w/cpp/utility/initializer_list `std::initializer_list`]]
[def __std_is_nothrow_constructible__ [@https://en.cppreference.com/w/cpp/types/is_constructible `std::is_nothrow_constructible`]]
[def __std_make_pair__                [@https://en.cppreference.com/w/cpp/utility/pair/make_pair `std::make_pair`]]
[def __std_memory_resource__    [@https://en.cppreference.com/w/cpp/memory/memory_resource `std::pmr::memory_resource`]]
[def __std_memset__                   [@https://en.cppreference.com/w/cpp/string/byte/memset `std::memset`]]
[def __std_next__                   [@https://en.cppreference.com/w/cpp/iterator/next `std::next`]]
[def __std_nullptr_t__                [@https://en.cppreference.com/w/cpp/types/nullptr_t `std::nullptr_t`]]
[def __std_ostream__                  [@https://en.cppreference.com/w/cpp/io/basic_ostream `std::ostream`]]
[def __std_ostream__            [@https://en.cppreference.com/w/cpp/io/basic_ostream `__std_ostream__`]]
[def __std_pair__                     [@https://en.cppreference.com/w/cpp/utility/pair `std::pair`]]
[def __std_polymorphic_allocator__ [@https://en.cppreference.com/w/cpp/memory/polymorphic_allocator `std::pmr::polymorphic_allocator`]]
[def __std_prev__                   [@https://en.cppreference.com/w/cpp/iterator/prev `std::prev`]]
[def __std_ptrdiff_t__                [@https://en.cppreference.com/w/cpp/types/ptrdiff_t `std::ptrdiff_t`]]
[def __std_remove__                [@https://en.cppreference.com/w/cpp/algorithm/remove `std::remove`]]
[def __std_result_of__                [@https://en.cppreference.com/w/cpp/types/result_of `std::result_of`]]
[def __std_sort__          [@https://en.cppreference.com/w/cpp/algorithm/sort `std::sort`]]
[def __std_streambuf__          [@https://en.cppreference.com/w/cpp/header/streambuf `std::streambuf`]]
[def __std_string__                   [@https://en.cppreference.com/w/cpp/string/basic_string `std::string`]]
[def __std_string_view__                   [@https://en.cppreference.com/w/cpp/string/basic_string_view `std::string_view`]]
[def __std_unary_function__      [@https://en.cppreference.com/w/cpp/utility/functional/unary_function `std::unary_function`]]
[def __std_unordered_map__      [@https://en.cppreference.com/w/cpp/container/unordered_map `std::unordered_map`]]
[def __std_uses_allocator__     [@https://en.cppreference.com/w/cpp/memory/uses_allocator `std::uses_allocator`]]
[def __std_vector__             [@https://en.cppreference.com/w/cpp/container/vector `std::vector`]]

[/ Dingbats ]

[def __good__ [role green \u2714]]
[def __bad__  [role red   \u2718]]

[/-----------------------------------------------------------------------------]

[include overview.qbk]

[include utilities.qbk]

[include other.qbk]

[#sec:reference]
[section:ref Quick Reference]

[/ Reference table ]
[xinclude quickref.xml]

[/ Generated reference files ]
[/ [include reference.qbk] ]

[/ Generated index ]
[/ [xinclude index.xml] ]

[endsect]
