mirror of
https://github.com/boostorg/iterator.git
synced 2025-07-20 08:02:10 +02:00
118 lines
3.6 KiB
ReStructuredText
118 lines
3.6 KiB
ReStructuredText
::
|
|
|
|
template <
|
|
class Iterator
|
|
, class Value = use_default
|
|
, class CategoryOrTraversal = use_default
|
|
, class Reference = use_default
|
|
, class Difference = use_default
|
|
>
|
|
class indirect_iterator
|
|
: public iterator_adaptor<
|
|
indirect_iterator<Iterator, Value, Access, Traversal,
|
|
Reference, Difference>,
|
|
Iterator,
|
|
/* Value = see below */,
|
|
CategoryOrTraversal,
|
|
Reference,
|
|
Difference>
|
|
{
|
|
friend class iterator_core_access;
|
|
public:
|
|
indirect_iterator();
|
|
indirect_iterator(Iterator x);
|
|
|
|
template <
|
|
class Iterator2, class Value2, class Category2
|
|
, class Reference2, class Difference2
|
|
>
|
|
indirect_iterator(
|
|
indirect_iterator<
|
|
Iterator2, Value2, Category2, Reference2, Difference2
|
|
> const& y
|
|
, typename enable_if_convertible<Iterator2, Iterator>::type* = 0 // exposition
|
|
);
|
|
private: // as-if specification
|
|
typename indirect_iterator::reference dereference() const
|
|
{
|
|
return **this->base();
|
|
}
|
|
};
|
|
|
|
template <class Dereferenceable>
|
|
struct referent {
|
|
typedef /* see below */ type;
|
|
};
|
|
|
|
|
|
If ``Value`` is not ``use_default`` then the the argument for the
|
|
``iterator_adaptor`` base class' ``Value`` parameter is ``Value`` with
|
|
cv-qualifiers removed. If ``Value`` is ``use_default``, then the
|
|
argument for the ``iterator_adaptor`` base class' ``Value`` parameter
|
|
is computed as follows. We use the abbreviation
|
|
``V=iterator_traits<Iterator>::value_type`` and ``v`` is an object of
|
|
type ``V``.::
|
|
|
|
if (*v returns a constant lvalue or an rvalue) then
|
|
referent<V>::type
|
|
else
|
|
add_const<referent<V>::type>::type
|
|
|
|
The algorithm for the ``type`` member of ``referent`` traits class is
|
|
as follows::
|
|
|
|
if (Dereferenceable is a class and has member element_type)
|
|
Dereferenceable::element_type
|
|
else
|
|
iterator_traits<Dereferenceable>::value_type
|
|
|
|
|
|
``indirect_iterator`` requirements
|
|
..................................
|
|
|
|
The ``Iterator`` type must meet the requirements of Readable
|
|
Iterator. Also, the following requirements are placed on
|
|
``iterator_traits<Iterator>::value_type``. Let ``i`` be an object of
|
|
type ``iterator_traits<Iterator>::value_type``. Then ``*i`` must be a
|
|
valid expression, and the type of ``*i`` must be convertible to
|
|
``iterator_adaptor::reference``. Also, there are further requirements
|
|
on the ``iterator_traits<Iterator>::value_type`` if the ``Value``
|
|
parameter is not ``use_default``, as implied by the algorithm for deducing
|
|
the default.
|
|
|
|
|
|
|
|
``indirect_iterator`` operations
|
|
................................
|
|
|
|
``indirect_iterator();``
|
|
|
|
:Requires: ``Iterator`` must be Default Constructible.
|
|
:Returns: An instance of ``indirect_iterator`` with
|
|
a default-constructed ``iterator_adaptor`` subobject.
|
|
|
|
|
|
``indirect_iterator(Iterator x);``
|
|
|
|
:Returns: An instance of ``indirect_iterator`` with
|
|
the ``iterator_adaptor`` subobject copy constructed from ``x``.
|
|
|
|
::
|
|
|
|
template <
|
|
class Iterator2, class Value2, unsigned Access, class Traversal
|
|
, class Reference2, class Difference2
|
|
>
|
|
indirect_iterator(
|
|
indirect_iterator<
|
|
Iterator2, Value2, Access, Traversal, Reference2, Difference2
|
|
> const& y
|
|
, typename enable_if_convertible<Iterator2, Iterator>::type* = 0 // exposition
|
|
);
|
|
|
|
:Requires: ``Iterator2`` is implicitly convertible to ``Iterator``.
|
|
:Returns: An instance of ``indirect_iterator`` whose
|
|
``iterator_adaptor`` subobject is constructed from ``y.base()``.
|
|
|
|
|