# Headers

false
true

An enumeration used to indicate whether the underlying data have a contiguous or discontiguous layout when instantiating `view_interface` and `sequence_container_interface`.

A type for granting access to the private members of an iterator derived from `iterator_interface`.

IteratorConcept
iterator_concept
std::remove_const_t< ValueType >
Reference
unspecified
DifferenceType
decltype(*access::base(std::declval< D & >())) Derived
decltype(*access::base(std::declval< D const & >())) Derived
unspecified Derived
unspecified Derived
decltype(std::declval< D & >()+=i, *std::declval< D & >()) Derived `difference_type`
decltype(++access::base(std::declval< D & >()), std::declval< D & >()) Derived std::enable_if_t<!v1_dtl::plus_eq<D, difference_type>::value>
decltype(std::declval< D & >()+=difference_type(1), std::declval< D & >()) Derived
std::remove_reference_t< decltype(D(std::declval< D & >()),++std::declval< D & >(), std::declval< D & >())> Derived `int`
decltype(access::base(std::declval< D & >())+=n, std::declval< D & >()) Derived `difference_type`
std::remove_reference_t< decltype(D(std::declval< D & >()), std::declval< D & >()+=i, std::declval< D & >())> Derived `difference_type`
decltype(--access::base(std::declval< D & >()), std::declval< D & >()) Derived std::enable_if_t<!v1_dtl::plus_eq<D, difference_type>::value>
decltype(std::declval< D & >()+=-difference_type(1), std::declval< D & >()) Derived
std::remove_reference_t< decltype(D(std::declval< D & >()), --std::declval< D & >(), std::declval< D & >())> Derived `int`
D & Derived `difference_type`
decltype(access::base(std::declval< D const & >()) - access::base(other)) Derived `D`

The return type of `operator->()` in a proxy iterator.

This template is used as the default `Pointer` template parameter in the `proxy_iterator_interface` template alias. Note that the use of this template implies a copy or move of the underlying object of type `T`.

T const &
T &&
T const *
T *
void
std::false_type
Iterator
DifferenceType
void_t< decltype(std::declval< Iterator & >()+=std::declval< DifferenceType >())>
std::true_type
void
std::false_type
Iterator
void_t< typename Iterator::iterator_concept >
std::integral_constant< bool, std::is_base_of< std::random_access_iterator_tag, Iterator::iterator_concept >::value >
void ``iterator_interface`< D, IteratorConcept, ValueType, Reference, Pointer, DifferenceType > const &`
void `v2::iterator_interface< D, IteratorConcept, ValueType, Reference, Pointer, DifferenceType > const &`
void `v3::iterator_interface< IteratorConcept, ValueType, Reference, Pointer, DifferenceType > const &`

A template alias useful for defining proxy iterators.

# See Also:

`iterator_interface`.

`iterator_interface`< Derived, IteratorConcept, ValueType, Reference, `proxy_arrow_result`< Reference >, DifferenceType >
decltype(access::base(std::declval< IteratorInterface1 & >())==access::base(std::declval< IteratorInterface2 & >())) std::enable_if_t<!v1_dtl::ra_iter<IteratorInterface1>::value> `IteratorInterface1` `IteratorInterface2`

Implementation of `operator==()`, implemented in terms of the iterator underlying IteratorInterface, for all iterators derived from `iterator_interface`, except those with an iterator category derived from `std::random_access_iterator_tag`.

Implementation of `operator==()` for all iterators derived from `iterator_interface` that have an iterator category derived from `std::random_access_iterator_tag`.

decltype(v1_dtl::derived_iterator(lhs), !(lhs==rhs)) `IteratorInterface1` `IteratorInterface2`

Implementation of `operator!=()` for all iterators derived from `iterator_interface`.

unspecified `IteratorInterface1` `IteratorInterface2`

Implementation of `operator<()` for all iterators derived from `iterator_interface` that have an iterator category derived from `std::random_access_iterator_tag`.

unspecified `IteratorInterface1` `IteratorInterface2`

Implementation of `operator<=()` for all iterators derived from `iterator_interface` that have an iterator category derived from `std::random_access_iterator_tag`.

unspecified `IteratorInterface1` `IteratorInterface2`

Implementation of `operator>()` for all iterators derived from `iterator_interface` that have an iterator category derived from `std::random_access_iterator_tag`.

unspecified `IteratorInterface1` `IteratorInterface2`

Implementation of `operator>=()` for all iterators derived from `iterator_interface` that have an iterator category derived from `std::random_access_iterator_tag`.

auto `D` `typename D::difference_type`
auto `typename D::difference_type` `D`
auto `D1` `D2`
auto `D` `typename D::difference_type`
bool `D1` `D2`
bool `D1` `D2`
bool `D1` `D2`
bool `D1` `D2`
bool `D1` `D2`
decltype(!(lhs==rhs)) `D1` `D2`
auto `D` `typename D::difference_type`
auto `typename D::difference_type` `D`
auto `D1` `D2`
auto `D` `typename D::difference_type`
bool `D1` `D2`
bool `D1` `D2`
bool `D1` `D2`
bool `D1` `D2`
bool `D1` `D2`
decltype(!(lhs==rhs)) `D1` `D2`

`static_asserts` that type `type` models concept `concept_name`. This is useful for checking that an iterator, view, etc. that you write using one of the *`_interface` templates models the right C++ concept.

For example: `BOOST_STL_INTERFACES_STATIC_ASSERT_CONCEPT(my_iter, std::input_iterator)`.

This macro expands to nothing when `__cpp_lib_concepts` is not defined.

`static_asserts` that the types of all typedefs in `std::iterator_traits<iter>` match the remaining macro parameters. This is useful for checking that an iterator you write using `iterator_interface` has the correct iterator traits.

For example: `BOOST_STL_INTERFACES_STATIC_ASSERT_ITERATOR_TRAITS(my_iter, std::input_iterator_tag, std::input_iterator, int, int &, int *, std::ptrdiff_t)`.

This macro ignores the `concept` parameter when `__cpp_lib_concepts` is not defined.

decltype(rhs.base()==lhs.base()) `reverse_iterator< BidiIter >` `reverse_iterator< BidiIter >`
decltype(rhs.base()==lhs.base()) `reverse_iterator< BidiIter1 >` `reverse_iterator< BidiIter2 >`
auto `BidiIter`

Makes a `reverse_iterator<BidiIter>` from an iterator of type `BidiIter`.

Makes a `reverse_iterator<BidiIter>` from an iterator of type `BidiIter`. This only exists to make migration from Boost.STLInterfaces to C++20 easier; switch to the one in `std` as soon as you can.

element_layout
decltype(std::declval< D & >().begin()==std::declval< D & >().end()) Derived
decltype(std::declval< D const & >().begin()==std::declval< D const & >().end()) Derived
decltype(std::addressof(*std::declval< D & >().begin())) Derived element_layout Contiguity std::enable_if_t<C == element_layout::contiguous>
decltype(std::addressof(*std::declval< D const & >().begin())) Derived element_layout Contiguity std::enable_if_t<C == element_layout::contiguous>
decltype(typename D::size_type(std::declval< D & >().end() - std::declval< D & >().begin())) Derived
decltype(typename D::size_type(std::declval< D const & >().end() - std::declval< D const & >().begin())) Derived
decltype(*std::declval< D & >().begin()) Derived
decltype(*std::declval< D const & >().begin()) Derived
decltype((void) std::declval< D & >().emplace_front(x)) Derived `typename D::value_type const &`
decltype((void) std::declval< D & >().emplace_front(std::move(x))) Derived `typename D::value_type &&`
decltype(std::declval< D & >().emplace_front(std::declval< typename D::value_type & >()),(void) std::declval< D & >().erase(std::declval< D & >().begin())) Derived
decltype(*std::prev(std::declval< D & >().end())) Derived std::enable_if_t< v1_dtl::decrementable_sentinel<D>::value && v1_dtl::common_range<D>::value>
decltype(*std::prev(std::declval< D const & >().end())) Derived std::enable_if_t< v1_dtl::decrementable_sentinel<D>::value && v1_dtl::common_range<D>::value>
decltype((void) std::declval< D & >().emplace_back(x)) Derived `typename D::value_type const &`
decltype((void) std::declval< D & >().emplace_back(std::move(x))) Derived `typename D::value_type &&`
decltype(std::declval< D & >().emplace_back(std::declval< typename D::value_type >()),(void) std::declval< D & >().erase(std::prev(std::declval< D & >().end()))) Derived
decltype(std::declval< D & >().begin()[n]) Derived `typename D::size_type`
decltype(std::declval< D const & >().begin()[n]) Derived `typename D::size_type`
decltype(std::declval< D & >().size(), std::declval< D & >()[i]) Derived `typename D::size_type`
decltype(std::declval< D const & >().size(), std::declval< D const & >()[i]) Derived `typename D::size_type`
Iter Derived typename D::const_iterator
Iter Derived typename D::const_iterator
decltype(std::declval< D const & >().begin()) Derived
decltype(std::declval< D const & >().end()) Derived
auto Derived std::enable_if_t<v1_dtl::common_range<D>::value>
auto Derived std::enable_if_t<v1_dtl::common_range<D>::value>
auto Derived
auto Derived
decltype(std::declval< D const & >().rbegin()) Derived
decltype(std::declval< D const & >().rend()) Derived
decltype(std::declval< D & >().emplace(pos, x)) Derived `typename D::const_iterator` `typename D::value_type const &`
decltype(std::declval< D & >().emplace(pos, std::move(x))) Derived `typename D::const_iterator` `typename D::value_type &&`
auto Derived `typename D::const_iterator` `typename D::size_type` `typename D::value_type const &`
decltype(std::declval< D & >().insert(pos, il.begin(), il.end())) Derived `typename D::const_iterator` `std::initializer_list< typename D::value_type >`
decltype(std::declval< D & >().erase(pos, std::next(pos))) Derived `typename D::const_iterator`
decltype(std::declval< D & >().erase(std::declval< D & >().begin(), std::declval< D & >().end()),(void) std::declval< D & >().insert(std::declval< D & >().begin(), first, last)) Derived std::enable_if_t<v1_dtl::in_iter<InputIterator>::value> `InputIterator` `InputIterator`
unspecified Derived `typename D::size_type` `typename D::value_type const &`
decltype((void) std::declval< D & >().assign(il.begin(), il.end())) Derived `std::initializer_list< typename D::value_type >`
decltype(std::declval< D & >().assign(il.begin(), il.end()), std::declval< D & >()) Derived `std::initializer_list< typename D::value_type >`
decltype((void) std::declval< D & >().erase(std::declval< D & >().begin(), std::declval< D & >().end())) Derived
void
void `D &`
D
void_t< decltype(std::declval< D >().clear())>
void `D &`
std::is_convertible< typename std::iterator_traits< Iter >::iterator_category, std::input_iterator_tag >
void element_layout ``sequence_container_interface`< D, Contiguity > const &`
decltype(v1_dtl::derived_container(lhs), lhs.swap(rhs)) `ContainerInterface &` `ContainerInterface &`

Implementation of free function `swap()` for all containers derived from `sequence_container_interface`.

decltype(v1_dtl::derived_container(lhs), lhs.size()==rhs.size(), *lhs.begin()== *rhs.begin(), true) `ContainerInterface const &` `ContainerInterface const &`

Implementation of `operator==()` for all containers derived from `sequence_container_interface`.

decltype(v1_dtl::derived_container(lhs), lhs==rhs) `ContainerInterface const &` `ContainerInterface const &`

Implementation of `operator!=()` for all containers derived from `sequence_container_interface`.

decltype(v1_dtl::derived_container(lhs), *lhs.begin()< *rhs.begin(), true) `ContainerInterface const &` `ContainerInterface const &`

Implementation of `operator<()` for all containers derived from `sequence_container_interface`.

decltype(v1_dtl::derived_container(lhs), lhs< rhs) `ContainerInterface const &` `ContainerInterface const &`

Implementation of `operator<=()` for all containers derived from `sequence_container_interface`.

decltype(v1_dtl::derived_container(lhs), lhs< rhs) `ContainerInterface const &` `ContainerInterface const &`

Implementation of `operator>()` for all containers derived from `sequence_container_interface`.

decltype(v1_dtl::derived_container(lhs), lhs< rhs) `ContainerInterface const &` `ContainerInterface const &`

Implementation of `operator>=()` for all containers derived from `sequence_container_interface`.

Adapts an invocable `f` as a view adaptor. Calling `operator(args...)` will either: call `f(args...)` and return the result, if `f(args...)` is well-formed; or return `closure(stl_interfaces::bind_back(f, args...))` otherwise.

F
auto typename... `Args &&...`
boost::stl_interfaces::range_adaptor_closure< closure< F > >

An invocable consisting of a contained invocable `f`. Calling `operator()` with some argument `t` calls `f(t)` and returns the result. This type is typically used to capture a the result of a call to `bind_back()`.

F
decltype(auto) unspecified `T &&`
decltype(auto) unspecified `T &&`

A backwards-compatible implementation of C++23's `std::ranges::range_adaptor_closure`. `range_adaptor_closure` may be a struct template or may be an alias, as required to maintain compatibility with the standard library's view adaptors.

int
auto typename... `Func &&` `Args &&...`

An implementation of `std::bind_back()` from C++23.

element_layout
decltype(std::declval< D & >().begin()==std::declval< D & >().end()) Derived
decltype(std::declval< D const & >().begin()==std::declval< D const & >().end()) Derived
constexpr Derived decltype(std::declval<D &>().empty())
constexpr Derived decltype(std::declval<D const &>().empty())
decltype(std::addressof(*std::declval< D & >().begin())) Derived element_layout Contiguity std::enable_if_t<C == element_layout::contiguous>
decltype(std::addressof(*std::declval< D const & >().begin())) Derived element_layout Contiguity std::enable_if_t<C == element_layout::contiguous>
decltype(std::declval< D & >().end() - std::declval< D & >().begin()) Derived
decltype(std::declval< D const & >().end() - std::declval< D const & >().begin()) Derived
decltype(*std::declval< D & >().begin()) Derived
decltype(*std::declval< D const & >().begin()) Derived
decltype(*std::prev(std::declval< D & >().end())) Derived std::enable_if_t< v1_dtl::decrementable_sentinel<D>::value && v1_dtl::common_range<D>::value>
decltype(*std::prev(std::declval< D const & >().end())) Derived std::enable_if_t< v1_dtl::decrementable_sentinel<D>::value && v1_dtl::common_range<D>::value>
decltype(std::declval< D & >().begin()[n]) Derived `v1_dtl::range_difference_t< D >`
decltype(std::declval< D const & >().begin()[n]) Derived `v1_dtl::range_difference_t< D >`
void element_layout ``view_interface`< D, Contiguity > const &`
decltype(v1_dtl::derived_view(lhs), !(lhs==rhs)) `ViewInterface` `ViewInterface`

Implementation of `operator!=()` for all views derived from `view_interface`.