[/==============================================================================
    Copyright (C) 2003-2010 Thorsten Ottosen, Neil Groves

    Use, modification and distribution is subject to the Boost Software
    License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
    http://www.boost.org/LICENSE_1_0.txt
==============================================================================/]
[library Range
    [quickbook 1.5]
    [version 2.0]
    [authors [Ottosen, Thorsten], [Groves, Neil]]
    [copyright 2003-2010 Thorsten Ottosen, Neil Groves]
    [purpose Half-open range 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])
    ]
]

[/ Converted to Quickbook format by Darren Garvey, 2007]

[def __note__                   [$images/note.png]]
[def __alert__                  [$images/alert.png]]
[def __tip__                    [$images/tip.png]]
[def __caution__                [$images/caution.png]]

[def __boost_range_home__       [link range Boost.Range]]
[def __ranges__                 [link range.concepts Ranges]]
[def __range_concepts__         [link range.concepts Range concepts]]
[def __forward_range__          [link range.concepts.forward_range Forward Range]]
[def __single_pass_range__      [link range.concepts.single_pass_range Single Pass Range]]
[def __bidirectional_range__    [link range.concepts.bidirectional_range Bidirectional Range]]
[def __random_access_range__    [link range.concepts.random_access_range Random Access Range]]

[def __iterator_range__         [link range.reference.utilities.iterator_range `iterator_range`]]
[def __sub_range__              [link range.reference.utilities.sub_range `sub_range`]]
[def __minimal_interface__      [link range.reference.extending minimal interface]]
[def __range_result_iterator__  [link range.reference.concept_implementation.semantics.metafunctions `range_result_iterator`]]
[def __extending_for_udts__ [link range.reference.extending Extending the library for UDTs]]
[def __implementation_of_metafunctions__ [link range.reference.concept_implementation.semantics.metafunctions Implementation of metafunctions]]
[def __implementation_of_functions__     [link range.reference.concept_implementation.semantics.functions Implementation of functions]]

[def __range_value__            [link range.reference.concept_implementation.semantics.metafunctions `range_value`]]
[def __range_iterator__         [link range.reference.concept_implementation.semantics.metafunctions `range_iterator`]]
[def __range_difference__       [link range.reference.concept_implementation.semantics.metafunctions `range_difference`]]
[def __range_pointer__          [link range.reference.concept_implementation.semantics.metafunctions `range_pointer`]]
[def __range_category__         [link range.reference.concept_implementation.semantics.metafunctions `range_category`]]
[def __range_reverse_iterator__ [link range.reference.concept_implementation.semantics.metafunctions `range_reverse_iterator`]]
[def __begin__                  [link range.reference.concept_implementation.semantics.functions `begin`]]
[def __const_begin__            [link range.reference.concept_implementation.semantics.functions `const_begin`]]
[def __end__                    [link range.reference.concept_implementation.semantics.functions `end`]]
[def __const_end__              [link range.reference.concept_implementation.semantics.functions `const_end`]]
[def __empty__                  [link range.reference.concept_implementation.semantics.functions `empty`]]
[def __distance__               [link range.reference.concept_implementation.semantics.functions `distance`]]
[def __size__                   [link range.reference.concept_implementation.semantics.functions `size`]]
[def __rbegin__                 [link range.reference.concept_implementation.semantics.functions `rbegin`]]
[def __const_rbegin__           [link range.reference.concept_implementation.semantics.functions `const_rbegin`]]
[def __rend__                   [link range.reference.concept_implementation.semantics.functions `rend`]]
[def __const_rend__             [link range.reference.concept_implementation.semantics.functions `const_rend`]]
[def __as_array__               [link range.reference.concept_implementation.semantics.functions `as_array`]]
[def __as_literal__             [link range.reference.concept_implementation.semantics.functions `as_literal`]]
[def __counting_range__         [link range.reference.ranges.counting_range `counting_range`]]
[def __irange__                 [link range.reference.ranges.irange `irange`]]
[def __istream_range__          [link range.reference.ranges.istream_range `istream_range`]]
[def __combine__                [link range.reference.utilities.combine `combine`]]
[def __join__                   [link range.reference.utilities.join `join`]]

[def __range_adaptors__                   [link range.reference.adaptors Range adaptors]]
[def __range_adaptors_adjacent_filtered__ [link range.reference.adaptors.reference.adjacent_filtered adjacent_filtered]]
[def __range_adaptors_copied__            [link range.reference.adaptors.reference.copied copied]]
[def __range_adaptors_filtered__          [link range.reference.adaptors.reference.filtered filtered]]
[def __range_adaptors_formatted__         [link.range.reference.adaptors.reference.formatted formatted]]
[def __range_adaptors_indexed__           [link range.reference.adaptors.reference.indexed indexed]]
[def __range_adaptors_indirected__        [link range.reference.adaptors.reference.indirected indirected]]
[def __range_adaptors_map_keys__          [link range.reference.adaptors.reference.map_keys map_keys]]
[def __range_adaptors_map_values__        [link range.reference.adaptors.reference.map_values map_values]]
[def __range_adaptors_replaced__          [link range.reference.adaptors.reference.replaced replaced]]
[def __range_adaptors_replaced_if__       [link range.reference.adaptors.reference.replaced_if replaced_if]]
[def __range_adaptors_reversed__          [link range.reference.adaptors.reference.reversed reversed]]
[def __range_adaptors_sliced__            [link range.reference.adaptors.reference.sliced sliced]]
[def __range_adaptors_strided__           [link range.reference.adaptors.reference.strided strided]]
[def __range_adaptors_type_erased__       [link range.reference.adaptors.reference.type_erased type_erased]]
[def __range_adaptors_tokenized__         [link range.reference.adaptors.reference.tokenized tokenized]]
[def __range_adaptors_transformed__       [link range.reference.adaptors.reference.transformed transformed]]
[def __range_adaptors_uniqued__           [link range.reference.adaptors.reference.uniqued uniqued]]


[def __range_algorithms__                         [link range.reference.algorithms Range algorithms]]
[def __range_algorithms_adjacent_find__           [link range.reference.algorithms.non_mutating.adjacent_find adjacent_find]]
[def __range_algorithms_binary_search__           [link range.reference.algorithms.non_mutating.binary_search binary_search]]
[def __range_algorithms_count__                   [link range.reference.algorithms.non_mutating.count count]]
[def __range_algorithms_count_if__                [link range.reference.algorithms.non_mutating.count_if count_if]]
[def __range_algorithms_equal__                   [link range.reference.algorithms.non_mutating.equal equal]]
[def __range_algorithms_equal_range__             [link range.reference.algorithms.non_mutating.equal_range equal_range]]
[def __range_algorithms_for_each__                [link range.reference.algorithms.non_mutating.for_each for_each]]
[def __range_algorithms_find__                    [link range.reference.algorithms.non_mutating.find find]]
[def __range_algorithms_find_end__                [link range.reference.algorithms.non_mutating.find_end find_end]]
[def __range_algorithms_find_first_of__           [link range.reference.algorithms.non_mutating.find_first_of find_first_of]]
[def __range_algorithms_find_if__                 [link range.reference.algorithms.non_mutating.find_if find_if]]
[def __range_algorithms_lexicographical_compare__ [link range.reference.algorithms.non_mutating.lexicographical_compare lexicographical_compare]]
[def __range_algorithms_lower_bound__             [link range.reference.algorithms.non_mutating.lower_bound lower_bound]]
[def __range_algorithms_max_element__             [link range.reference.algorithms.non_mutating.max_element max_element]]
[def __range_algorithms_min_element__             [link range.reference.algorithms.non_mutating.min_element min_element]]
[def __range_algorithms_mismatch__                [link range.reference.algorithms.non_mutating.mismatch mismatch]]
[def __range_algorithms_search__                  [link range.reference.algorithms.non_mutating.search search]]
[def __range_algorithms_search_n__                [link range.reference.algorithms.non_mutating.search_n search_n]]
[def __range_algorithms_upper_bound__             [link range.reference.algorithms.non_mutating.upper_bound upper_bound]]

[def __range_algorithms_copy__                    [link range.reference.algorithms.mutating.copy copy]]
[def __range_algorithms_copy_backward__           [link range.reference.algorithms.mutating.copy_backward copy_backward]]
[def __range_algorithms_fill__                    [link range.reference.algorithms.mutating.fill fill]]
[def __range_algorithms_fill_n__                  [link range.reference.algorithms.mutating.fill_n fill_n]]
[def __range_algorithms_generate__                [link range.reference.algorithms.mutating.generate generate]]
[def __range_algorithms_inplace_merge__           [link range.reference.algorithms.mutating.inplace_merge inplace_merge]]
[def __range_algorithms_merge__                   [link range.reference.algorithms.mutating.merge merge]]
[def __range_algorithms_nth_element__             [link range.reference.algorithms.mutating.nth_element nth_element]]
[def __range_algorithms_partial_sort__            [link range.reference.algorithms.mutating.partial_sort partial_sort]]
[def __range_algorithms_partition__               [link range.reference.algorithms.mutating.partition partition]]
[def __range_algorithms_random_shuffle__          [link range.reference.algorithms.mutating.random_shuffle random_shuffle]]
[def __range_algorithms_remove__                  [link range.reference.algorithms.mutating.remove remove]]
[def __range_algorithms_remove_copy__             [link range.reference.algorithms.mutating.remove_copy remove_copy]]
[def __range_algorithms_remove_copy_if__          [link range.reference.algorithms.mutating.remove_copy_if remove_copy_if]]
[def __range_algorithms_remove_if__               [link range.reference.algorithms.mutating.remove_if remove_if]]
[def __range_algorithms_replace__                 [link range.reference.algorithms.mutating.replace replace]]
[def __range_algorithms_replace_copy__            [link range.reference.algorithms.mutating.replace_copy replace_copy]]
[def __range_algorithms_replace_copy_if__         [link range.reference.algorithms.mutating.replace_copy_if replace_copy_if]]
[def __range_algorithms_replace_if__              [link range.reference.algorithms.mutating.replace_if replace_if]]
[def __range_algorithms_reverse__                 [link range.reference.algorithms.mutating.reverse reverse]]
[def __range_algorithms_reverse_copy__            [link range.reference.algorithms.mutating.reverse_copy reverse_copy]]
[def __range_algorithms_rotate__                  [link range.reference.algorithms.mutating.rotate rotate]]
[def __range_algorithms_rotate_copy__             [link range.reference.algorithms.mutating.rotate_copy rotate_copy]]
[def __range_algorithms_sort__                    [link range.reference.algorithms.mutating.sort sort]]
[def __range_algorithms_stable_partition__        [link range.reference.algorithms.mutating.stable_partition stable_partition]]
[def __range_algorithms_stable_sort__             [link range.reference.algorithms.mutating.stable_sort stable_sort]]
[def __range_algorithms_swap_ranges__             [link range.reference.algorithms.mutating.swap_ranges swap_ranges]]
[def __range_algorithms_transform__               [link range.reference.algorithms.mutating.transform transform]]
[def __range_algorithms_unique__                  [link range.reference.algorithms.mutating.unique unique]]
[def __range_algorithms_unique_copy__             [link range.reference.algorithms.mutating.unique_copy unique_copy]]

[def __range_algorithms_includes__                 [link range.reference.algorithms.set.includes includes]]
[def __range_algorithms_set_union__                [link range.reference.algorithms.set.set_union set_union]]
[def __range_algorithms_set_intersection__         [link range.reference.algorithms.set.set_intersection set_intersection]]
[def __range_algorithms_set_difference__           [link range.reference.algorithms.set.set_difference set_difference]]
[def __range_algorithms_set_symmetric_difference__ [link range.reference.algorithms.set.set_symmetric_difference set_symmetric_difference]]

[def __range_algorithms_push_heap__         [link range.reference.algorithms.heap.push_heap push_heap]]
[def __range_algorithms_pop_heap__          [link range.reference.algorithms.heap.pop_heap pop_heap]]
[def __range_algorithms_make_heap__         [link range.reference.algorithms.heap.make_heap make_heap]]
[def __range_algorithms_sort_heap__         [link range.reference.algorithms.heap.sort_heap sort_heap]]

[def __range_algorithms_next_permutation__  [link range.reference.algorithms.permutation.next_permutation next_permutation]]
[def __range_algorithms_prev_permutation__ [link range.reference.algorithms.permutation.prev_permutation prev_permutation]]

[def __range_algorithm_ext_copy_n__         [link range.reference.algorithms.new.copy_n copy_n]]
[def __range_algorithm_ext_erase__          [link range.reference.algorithms.new.erase erase]]
[def __range_algorithm_ext_for_each__       [link range.reference.algorithms.new.for_each for_each]]
[def __range_algorithm_ext_insert__         [link range.reference.algorithms.new.insert insert]]
[def __range_algorithm_ext_iota__           [link range.reference.algorithms.new.iota iota]]
[def __range_algorithm_ext_is_sorted__      [link range.reference.algorithms.new.is_sorted is_sorted]]
[def __range_algorithm_ext_overwrite__      [link range.reference.algorithms.new.overwrite overwrite]]
[def __range_algorithm_ext_push_back__      [link range.reference.algorithms.new.push_back push_back]]
[def __range_algorithm_ext_push_front__     [link range.reference.algorithms.new.push_front push_front]]

[def __single_pass_iterator__   [@boost:/libs/iterator/doc/new-iter-concepts.html#singls-pass-iterators-lib-single-pass-iterators Single Pass Iterator]]
[def __forward_traversal_iterator__ [@boost:/libs/iterator/doc/new-iter-concepts.html#forward-traversal-iterators-lib-forward-traversal-iterators Forward Traversal Iterator]]
[def __bidirectional_traversal_iterator__ [@boost:/libs/iterator/doc/new-iter-concepts.html#bidirectional-traversal-iterators-lib-bidirectional-traversal-iterators Bidirectional Traversal Iterator]]
[def __random_access_traversal_iterator__ [@boost:/libs/iterator/doc/new-iter-concepts.html#random-access-traversal-iterators-lib-random-access-traversal-iterators Random Access Traversal Iterator]]
[def __new_style_iterators__    [@boost:/libs/iterator/doc/new-iter-concepts.html new style iterators]]
[def __iterator_concepts__      [@boost:/libs/iterator/doc/iterator_concepts.html Iterator concepts]]

[def __container__              [@http://www.sgi.com/Technology/STL/Container.html Container]]
[def __metafunctions__          [@boost:/libs/mpl/doc/refmanual/metafunction.html metafunctions]]
[def __concept_check__          [@boost:/libs/concept_check/index.html Boost Concept Check library]]
[def __boost_array__            [@boost:/libs/array/index.html boost::array]]
[def __the_forwarding_problem__ [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2002/n1385.htm The Forwarding Problem]]

[def __sgi_inner_product__      [@http://www.sgi.com/tech/stl/inner_product.html inner_product]]
[def __sgi_partial_sum__        [@http://www.sgi.com/tech/stl/partial_sum.html partial_sum]]
[def __type_erasure_article__   [@http://www.artima.com/cppsource/type_erasure.html type erasure article]]

Boost.Range is a collection of concepts and utilities, range-based algorithms,
as well as range adaptors that allow for efficient and expressive code.

Using Boost.Range inplace of the standard library alternatives results in more
readable code and in many cases greater efficiency.

[include introduction.qbk]
[include concepts.qbk]
[include reference.qbk]
[include style.qbk]
[include headers.qbk]
[include examples.qbk]
[include mfc_atl.qbk]
[include upgrade.qbk]
[include portability.qbk]
[include faq.qbk]
[include history_ack.qbk]

