From a2bfab97136dd01c8b855d096931590a68e2d5f6 Mon Sep 17 00:00:00 2001 From: nobody Date: Thu, 29 Jan 2004 05:55:27 +0000 Subject: [PATCH] This commit was manufactured by cvs2svn to create branch 'RC_1_31_0'. [SVN r22044] --- doc/BidirectionalTraversal.html | 71 + doc/BidirectionalTraversal.rst | 37 + doc/ForwardTraversal.html | 62 + doc/ForwardTraversal.rst | 27 + doc/IncrementableIterator.html | 61 + doc/IncrementableIterator.rst | 28 + doc/InteroperableIterator.rst | 57 + doc/LvalueIterator.html | 51 + doc/LvalueIterator.rst | 21 + doc/RandomAccessTraversal.html | 129 + doc/RandomAccessTraversal.rst | 63 + doc/ReadableIterator.html | 59 + doc/ReadableIterator.rst | 23 + doc/SinglePassIterator.html | 63 + doc/SinglePassIterator.rst | 28 + doc/SwappableIterator.html | 49 + doc/SwappableIterator.rst | 19 + doc/WritableIterator.html | 47 + doc/WritableIterator.rst | 17 + doc/docutils.sty | 54 + doc/filter_iterator_ref.html | 241 ++ doc/indirect_iterator_ref.html | 147 + doc/iter-issue-list.html | 5271 +++++++++++++++++++++++++++++++ doc/iterator_adaptor_ref.html | 230 ++ doc/iterator_concepts.html | 123 + doc/iterator_concepts.pdf | Bin 0 -> 67049 bytes doc/iterator_concepts.rst | 128 + doc/iterator_traits.html | 120 + doc/iterator_traits.pdf | Bin 0 -> 53847 bytes doc/iterator_traits.rst | 94 + doc/make_filter_iterator.html | 53 + doc/ref_problem.html | 70 + doc/rst2latex | 4 + doc/syscmd.py | 14 + index.html | 9 + 35 files changed, 7470 insertions(+) create mode 100644 doc/BidirectionalTraversal.html create mode 100755 doc/BidirectionalTraversal.rst create mode 100644 doc/ForwardTraversal.html create mode 100755 doc/ForwardTraversal.rst create mode 100644 doc/IncrementableIterator.html create mode 100755 doc/IncrementableIterator.rst create mode 100644 doc/InteroperableIterator.rst create mode 100644 doc/LvalueIterator.html create mode 100755 doc/LvalueIterator.rst create mode 100644 doc/RandomAccessTraversal.html create mode 100644 doc/RandomAccessTraversal.rst create mode 100644 doc/ReadableIterator.html create mode 100755 doc/ReadableIterator.rst create mode 100644 doc/SinglePassIterator.html create mode 100755 doc/SinglePassIterator.rst create mode 100644 doc/SwappableIterator.html create mode 100755 doc/SwappableIterator.rst create mode 100644 doc/WritableIterator.html create mode 100755 doc/WritableIterator.rst create mode 100755 doc/docutils.sty create mode 100755 doc/filter_iterator_ref.html create mode 100755 doc/indirect_iterator_ref.html create mode 100755 doc/iter-issue-list.html create mode 100755 doc/iterator_adaptor_ref.html create mode 100644 doc/iterator_concepts.html create mode 100755 doc/iterator_concepts.pdf create mode 100755 doc/iterator_concepts.rst create mode 100755 doc/iterator_traits.html create mode 100755 doc/iterator_traits.pdf create mode 100755 doc/iterator_traits.rst create mode 100755 doc/make_filter_iterator.html create mode 100755 doc/ref_problem.html create mode 100755 doc/rst2latex create mode 100644 doc/syscmd.py create mode 100755 index.html diff --git a/doc/BidirectionalTraversal.html b/doc/BidirectionalTraversal.html new file mode 100644 index 0000000..0daa77e --- /dev/null +++ b/doc/BidirectionalTraversal.html @@ -0,0 +1,71 @@ + + + + + + +Bidirectional Traversal Concept + + + +
+

Bidirectional Traversal Concept

+

A class or built-in type X models the Bidirectional Traversal +concept if, in addition to X meeting the requirements of Forward +Traversal Iterator, the following expressions are valid and respect +the stated semantics.

+ +++++ + + + + + + + + + + + + + + + + + + + + + + +
Bidirectional Traversal Iterator Requirements (in addition to Forward Traversal +Iterator)
ExpressionReturn TypeAssertion/Semantics / +Pre-/Post-condition
--rX&pre: there exists +s such that r +== ++s. post: +s is +dereferenceable. +--(++r) == r. +--r == --s +implies r == +s. &r == &--r.
r--convertible to const X&
+{
+  X tmp = r;
+  --r;
+  return tmp;
+}
+
+
iterator_traversal<X>::typeConvertible to +bidirectional_traversal_tag 
+
+
+
+View document source. +Generated by Docutils from reStructuredText source. +
+ + diff --git a/doc/BidirectionalTraversal.rst b/doc/BidirectionalTraversal.rst new file mode 100755 index 0000000..8655c63 --- /dev/null +++ b/doc/BidirectionalTraversal.rst @@ -0,0 +1,37 @@ +Bidirectional Traversal Concept +............................... + +A class or built-in type ``X`` models the *Bidirectional Traversal* +concept if, in addition to ``X`` meeting the requirements of Forward +Traversal Iterator, the following expressions are valid and respect +the stated semantics. + ++--------------------------------------------------------------------------------------+ +|Bidirectional Traversal Iterator Requirements (in addition to Forward Traversal | +|Iterator) | ++--------------------------------+-------------------------------+---------------------+ +|Expression |Return Type |Assertion/Semantics /| +| | |Pre-/Post-condition | ++================================+===============================+=====================+ +|``--r`` |``X&`` |pre: there exists | +| | |``s`` such that ``r | +| | |== ++s``. post: | +| | |``s`` is | +| | |dereferenceable. | +| | |``--(++r) == r``. | +| | |``--r == --s`` | +| | |implies ``r == | +| | |s``. ``&r == &--r``. | ++--------------------------------+-------------------------------+---------------------+ +|``r--`` |convertible to ``const X&`` |:: | +| | | | +| | | { | +| | | X tmp = r; | +| | | --r; | +| | | return tmp; | +| | | } | ++--------------------------------+-------------------------------+---------------------+ +|``iterator_traversal::type`` |Convertible to | | +| |``bidirectional_traversal_tag``| | +| | | | ++--------------------------------+-------------------------------+---------------------+ diff --git a/doc/ForwardTraversal.html b/doc/ForwardTraversal.html new file mode 100644 index 0000000..abe055f --- /dev/null +++ b/doc/ForwardTraversal.html @@ -0,0 +1,62 @@ + + + + + + +Forward Traversal Concept + + + +
+

Forward Traversal Concept

+

A class or built-in type X models the Forward Traversal +concept if, in addition to X meeting the requirements of Default +Constructible and Single Pass Iterator, the following expressions are +valid and respect the stated semantics.

+ +++++ + + + + + + + + + + + + + + + + + + + + + + + + + + +
Forward Traversal Iterator Requirements (in addition to Default Constructible and Single Pass Iterator)
ExpressionReturn TypeAssertion/Note
X u;X&note: u may have a +singular value.
++rX&r == s and r is +dereferenceable implies +++r == ++s.
iterator_traits<X>::difference_typeA signed integral type representing +the distance between iterators 
iterator_traversal<X>::typeConvertible to +forward_traversal_tag 
+
+
+
+View document source. +Generated by Docutils from reStructuredText source. +
+ + diff --git a/doc/ForwardTraversal.rst b/doc/ForwardTraversal.rst new file mode 100755 index 0000000..c4156d5 --- /dev/null +++ b/doc/ForwardTraversal.rst @@ -0,0 +1,27 @@ +Forward Traversal Concept +......................... + +A class or built-in type ``X`` models the *Forward Traversal* +concept if, in addition to ``X`` meeting the requirements of Default +Constructible and Single Pass Iterator, the following expressions are +valid and respect the stated semantics. + ++--------------------------------------------------------------------------------------------------------+ +|Forward Traversal Iterator Requirements (in addition to Default Constructible and Single Pass Iterator) | ++---------------------------------------+-----------------------------------+----------------------------+ +|Expression |Return Type |Assertion/Note | ++=======================================+===================================+============================+ +|``X u;`` |``X&`` |note: ``u`` may have a | +| | |singular value. | ++---------------------------------------+-----------------------------------+----------------------------+ +|``++r`` |``X&`` |``r == s`` and ``r`` is | +| | |dereferenceable implies | +| | |``++r == ++s.`` | ++---------------------------------------+-----------------------------------+----------------------------+ +|``iterator_traits::difference_type``|A signed integral type representing| | +| |the distance between iterators | | +| | | | ++---------------------------------------+-----------------------------------+----------------------------+ +|``iterator_traversal::type`` |Convertible to | | +| |``forward_traversal_tag`` | | ++---------------------------------------+-----------------------------------+----------------------------+ diff --git a/doc/IncrementableIterator.html b/doc/IncrementableIterator.html new file mode 100644 index 0000000..c3ccfd7 --- /dev/null +++ b/doc/IncrementableIterator.html @@ -0,0 +1,61 @@ + + + + + + +Incrementable Iterator Concept + + + +
+

Incrementable Iterator Concept

+

A class or built-in type X models the Incrementable Iterator +concept if, in addition to X being Assignable and Copy +Constructible, the following expressions are valid and respect the +stated semantics.

+ +++++ + + + + + + + + + + + + + + + + + + + + + + +
Incrementable Iterator Requirements (in addition to Assignable, Copy Constructible)
ExpressionReturn TypeAssertion/Semantics
++rX&&r == &++r
r++X
+{
+   X tmp = r;
+   ++r;
+   return tmp;
+}
+
+
iterator_traversal<X>::typeConvertible to +incrementable_traversal_tag 
+
+
+
+View document source. +Generated by Docutils from reStructuredText source. +
+ + diff --git a/doc/IncrementableIterator.rst b/doc/IncrementableIterator.rst new file mode 100755 index 0000000..f14928e --- /dev/null +++ b/doc/IncrementableIterator.rst @@ -0,0 +1,28 @@ +Incrementable Iterator Concept +.............................. + +A class or built-in type ``X`` models the *Incrementable Iterator* +concept if, in addition to ``X`` being Assignable and Copy +Constructible, the following expressions are valid and respect the +stated semantics. + + ++-------------------------------------------------------------------------------------+ +|Incrementable Iterator Requirements (in addition to Assignable, Copy Constructible) | +| | ++--------------------------------+-------------------------------+--------------------+ +|Expression |Return Type |Assertion/Semantics | ++================================+===============================+====================+ +|``++r`` |``X&`` |``&r == &++r`` | ++--------------------------------+-------------------------------+--------------------+ +|``r++`` |``X`` |:: | +| | | | +| | | { | +| | | X tmp = r; | +| | | ++r; | +| | | return tmp; | +| | | } | ++--------------------------------+-------------------------------+--------------------+ +|``iterator_traversal::type`` |Convertible to | | +| |``incrementable_traversal_tag``| | ++--------------------------------+-------------------------------+--------------------+ diff --git a/doc/InteroperableIterator.rst b/doc/InteroperableIterator.rst new file mode 100644 index 0000000..0cb751e --- /dev/null +++ b/doc/InteroperableIterator.rst @@ -0,0 +1,57 @@ +Interoperable Iterator Concept +.............................. + +A class or built-in type ``X`` that models Single Pass Iterator is +*interoperable with* a class or built-in type ``Y`` that also models +Single Pass Iterator if the following expressions are valid and +respect the stated semantics. In the tables below, ``x`` is an object +of type ``X``, ``y`` is an object of type ``Y``, ``Distance`` is +``iterator_traits::difference_type``, and ``n`` represents a +constant object of type ``Distance``. + ++-----------+-----------------------+---------------------------------------------------+ +|Expression |Return Type |Assertion/Precondition/Postcondition | ++===========+=======================+===================================================+ +|``y = x`` |``Y`` |post: ``y == x`` | ++-----------+-----------------------+---------------------------------------------------+ +|``Y(x)`` |``Y`` |post: ``Y(x) == x`` | ++-----------+-----------------------+---------------------------------------------------+ +|``x == y`` |convertible to ``bool``|``==`` is an equivalence relation over its domain. | ++-----------+-----------------------+---------------------------------------------------+ +|``y == x`` |convertible to ``bool``|``==`` is an equivalence relation over its domain. | ++-----------+-----------------------+---------------------------------------------------+ +|``x != y`` |convertible to ``bool``|``bool(a==b) != bool(a!=b)`` over its domain. | ++-----------+-----------------------+---------------------------------------------------+ +|``y != x`` |convertible to ``bool``|``bool(a==b) != bool(a!=b)`` over its domain. | ++-----------+-----------------------+---------------------------------------------------+ + +If ``X`` and ``Y`` both model Random Access Traversal Iterator then +the following additional requirements must be met. + ++-----------+-----------------------+---------------------+--------------------------------------+ +|Expression |Return Type |Operational Semantics|Assertion/ Precondition | ++===========+=======================+=====================+======================================+ +|``x < y`` |convertible to ``bool``|``y - x > 0`` |``<`` is a total ordering relation | ++-----------+-----------------------+---------------------+--------------------------------------+ +|``y < x`` |convertible to ``bool``|``x - y > 0`` |``<`` is a total ordering relation | ++-----------+-----------------------+---------------------+--------------------------------------+ +|``x > y`` |convertible to ``bool``|``y < x`` |``>`` is a total ordering relation | ++-----------+-----------------------+---------------------+--------------------------------------+ +|``y > x`` |convertible to ``bool``|``x < y`` |``>`` is a total ordering relation | ++-----------+-----------------------+---------------------+--------------------------------------+ +|``x >= y`` |convertible to ``bool``|``!(x < y)`` | | ++-----------+-----------------------+---------------------+--------------------------------------+ +|``y >= x`` |convertible to ``bool``|``!(y < x)`` | | ++-----------+-----------------------+---------------------+--------------------------------------+ +|``x <= y`` |convertible to ``bool``|``!(x > y)`` | | ++-----------+-----------------------+---------------------+--------------------------------------+ +|``y <= x`` |convertible to ``bool``|``!(y > x)`` | | ++-----------+-----------------------+---------------------+--------------------------------------+ +|``y - x`` |``Distance`` |``distance(Y(x),y)`` |pre: there exists a value ``n`` of | +| | | |``Distance`` such that ``x + n == y``.| +| | | |``y == x + (y - x)``. | ++-----------+-----------------------+---------------------+--------------------------------------+ +|``x - y`` |``Distance`` |``distance(y,Y(x))`` |pre: there exists a value ``n`` of | +| | | |``Distance`` such that ``y + n == x``.| +| | | |``x == y + (x - y)``. | ++-----------+-----------------------+---------------------+--------------------------------------+ diff --git a/doc/LvalueIterator.html b/doc/LvalueIterator.html new file mode 100644 index 0000000..3e3f97a --- /dev/null +++ b/doc/LvalueIterator.html @@ -0,0 +1,51 @@ + + + + + + +Lvalue Iterator Concept + + + +
+

Lvalue Iterator Concept

+

The Lvalue Iterator concept adds the requirement that the return +type of operator* type be a reference to the value type of the +iterator.

+ +++++ + + + + + + + + + + + + + + +
Lvalue Iterator Requirements
ExpressionReturn TypeNote/Assertion
*aT&T is cv +iterator_traits<X>::value_type +where cv is an optional +cv-qualification. +pre: a is +dereferenceable. If a +== b then *a is +equivalent to *b.
+
+
+
+View document source. +Generated by Docutils from reStructuredText source. +
+ + diff --git a/doc/LvalueIterator.rst b/doc/LvalueIterator.rst new file mode 100755 index 0000000..46c61b1 --- /dev/null +++ b/doc/LvalueIterator.rst @@ -0,0 +1,21 @@ +Lvalue Iterator Concept +....................... + +The *Lvalue Iterator* concept adds the requirement that the return +type of ``operator*`` type be a reference to the value type of the +iterator. + ++-------------------------------------------------------------+ +| Lvalue Iterator Requirements | ++-------------+-----------+-----------------------------------+ +|Expression |Return Type|Note/Assertion | ++=============+===========+===================================+ +|``*a`` | ``T&`` |``T`` is *cv* | +| | |``iterator_traits::value_type`` | +| | |where *cv* is an optional | +| | |cv-qualification. | +| | |pre: ``a`` is | +| | |dereferenceable. If ``a | +| | |== b`` then ``*a`` is | +| | |equivalent to ``*b``. | ++-------------+-----------+-----------------------------------+ diff --git a/doc/RandomAccessTraversal.html b/doc/RandomAccessTraversal.html new file mode 100644 index 0000000..4f7f40e --- /dev/null +++ b/doc/RandomAccessTraversal.html @@ -0,0 +1,129 @@ + + + + + + +Random Access Traversal Concept + + + +
+

Random Access Traversal Concept

+

A class or built-in type X models the Random Access Traversal +concept if the following expressions are valid and respect the stated +semantics. In the table below, Distance is +iterator_traits<X>::difference_type and n represents a +constant object of type Distance.

+ ++++++ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
Random Access Traversal Iterator Requirements (in addition to Bidirectional Traversal)
ExpressionReturn TypeOperational SemanticsAssertion/ +Precondition
r += nX&
+{
+  Distance m = n;
+  if (m >= 0)
+    while (m--)
+      ++r;
+  else
+    while (m++)
+      --r;
+  return r;
+}
+
+		 
a + n, n + aX{ X tmp = a; return tmp ++= n; } 
r -= nX&return r += -n 
a - nX{ X tmp = a; return tmp +-= n; } 
b - aDistancea < b ?  distance(a,b) +: -distance(b,a)pre: there exists a +value n of +Distance such that +a + n == b. b +== a + (b - a).
a[n]convertible to T*(a + n)pre: a is a Readable +Iterator
a[n] = vconvertible to T*(a + n) = vpre: a is a Writable +iterator
a < bconvertible to boolb - a > 0< is a total +ordering relation
a > bconvertible to boolb < a> is a total +ordering relation
a >= bconvertible to bool!(a < b) 
a <= bconvertible to bool!(a > b) 
iterator_traversal<X>::typeConvertible to +random_access_traversal_tag  
+
+
+
+View document source. +Generated by Docutils from reStructuredText source. +
+ + diff --git a/doc/RandomAccessTraversal.rst b/doc/RandomAccessTraversal.rst new file mode 100644 index 0000000..97b0f3d --- /dev/null +++ b/doc/RandomAccessTraversal.rst @@ -0,0 +1,63 @@ +Random Access Traversal Concept +............................... + +A class or built-in type ``X`` models the *Random Access Traversal* +concept if the following expressions are valid and respect the stated +semantics. In the table below, ``Distance`` is +``iterator_traits::difference_type`` and ``n`` represents a +constant object of type ``Distance``. + ++------------------------------------------------------------------------------------------------------------------+ +|Random Access Traversal Iterator Requirements (in addition to Bidirectional Traversal) | ++-------------------------------+---------------------------------+-------------------------+----------------------+ +|Expression |Return Type |Operational Semantics |Assertion/ | +| | | |Precondition | ++===============================+=================================+=========================+======================+ +|``r += n`` |``X&`` |:: | | +| | | | | +| | | { | | +| | | Distance m = n; | | +| | | if (m >= 0) | | +| | | while (m--) | | +| | | ++r; | | +| | | else | | +| | | while (m++) | | +| | | --r; | | +| | | return r; | | +| | | } | | ++-------------------------------+---------------------------------+-------------------------+----------------------+ +|``a + n``, ``n + a`` |``X`` |``{ X tmp = a; return tmp| | +| | |+= n; }`` | | +| | | | | ++-------------------------------+---------------------------------+-------------------------+----------------------+ +|``r -= n`` |``X&`` |``return r += -n`` | | ++-------------------------------+---------------------------------+-------------------------+----------------------+ +|``a - n`` |``X`` |``{ X tmp = a; return tmp| | +| | |-= n; }`` | | +| | | | | ++-------------------------------+---------------------------------+-------------------------+----------------------+ +|``b - a`` |``Distance`` |``a < b ? distance(a,b) |pre: there exists a | +| | |: -distance(b,a)`` |value ``n`` of | +| | | |``Distance`` such that| +| | | |``a + n == b``. ``b | +| | | |== a + (b - a)``. | ++-------------------------------+---------------------------------+-------------------------+----------------------+ +|``a[n]`` |convertible to T |``*(a + n)`` |pre: a is a *Readable | +| | | |Iterator* | ++-------------------------------+---------------------------------+-------------------------+----------------------+ +|``a[n] = v`` |convertible to T |``*(a + n) = v`` |pre: a is a *Writable | +| | | |iterator* | ++-------------------------------+---------------------------------+-------------------------+----------------------+ +|``a < b`` |convertible to ``bool`` |``b - a > 0`` |``<`` is a total | +| | | |ordering relation | ++-------------------------------+---------------------------------+-------------------------+----------------------+ +|``a > b`` |convertible to ``bool`` |``b < a`` |``>`` is a total | +| | | |ordering relation | ++-------------------------------+---------------------------------+-------------------------+----------------------+ +|``a >= b`` |convertible to ``bool`` |``!(a < b)`` | | ++-------------------------------+---------------------------------+-------------------------+----------------------+ +|``a <= b`` |convertible to ``bool`` |``!(a > b)`` | | ++-------------------------------+---------------------------------+-------------------------+----------------------+ +|``iterator_traversal::type``|Convertible to | | | +| |``random_access_traversal_tag`` | | | ++-------------------------------+---------------------------------+-------------------------+----------------------+ diff --git a/doc/ReadableIterator.html b/doc/ReadableIterator.html new file mode 100644 index 0000000..57edb8f --- /dev/null +++ b/doc/ReadableIterator.html @@ -0,0 +1,59 @@ + + + + + + +Readable Iterator Concept + + + +
+

Readable Iterator Concept

+

A class or built-in type X models the Readable Iterator concept +for value type T if, in addition to X being Assignable and +Copy Constructible, the following expressions are valid and respect +the stated semantics. U is the type of any specified member of +type T.

+ +++++ + + + + + + + + + + + + + + + + + + + + + + +
Readable Iterator Requirements (in addition to Assignable and Copy Constructible)
ExpressionReturn TypeNote/Precondition
iterator_traits<X>::value_typeTAny non-reference, +non-cv-qualified type
*aConvertible to T
+
pre: a is dereferenceable. If a == b then *a
+
is equivalent to *b.
+
+
a->mU&pre: pre: (*a).m is well-defined. Equivalent to (*a).m.
+
+
+
+View document source. +Generated by Docutils from reStructuredText source. +
+ + diff --git a/doc/ReadableIterator.rst b/doc/ReadableIterator.rst new file mode 100755 index 0000000..d38dad5 --- /dev/null +++ b/doc/ReadableIterator.rst @@ -0,0 +1,23 @@ + +Readable Iterator Concept +......................... + +A class or built-in type ``X`` models the *Readable Iterator* concept +for value type ``T`` if, in addition to ``X`` being Assignable and +Copy Constructible, the following expressions are valid and respect +the stated semantics. ``U`` is the type of any specified member of +type ``T``. + ++-----------------------------------------------------------------------------------------------------------------------------+ +|Readable Iterator Requirements (in addition to Assignable and Copy Constructible) | ++-----------------------------------+------------------------+----------------------------------------------------------------+ +|Expression |Return Type |Note/Precondition | ++===================================+========================+================================================================+ +|``iterator_traits::value_type`` |``T`` |Any non-reference, | +| | |non-cv-qualified type | ++-----------------------------------+------------------------+----------------------------------------------------------------+ +|``*a`` | Convertible to ``T`` |pre: ``a`` is dereferenceable. If ``a == b`` then ``*a`` | +| | | is equivalent to ``*b``. | ++-----------------------------------+------------------------+----------------------------------------------------------------+ +|``a->m`` |``U&`` |pre: ``pre: (*a).m`` is well-defined. Equivalent to ``(*a).m``. | ++-----------------------------------+------------------------+----------------------------------------------------------------+ diff --git a/doc/SinglePassIterator.html b/doc/SinglePassIterator.html new file mode 100644 index 0000000..a6091c7 --- /dev/null +++ b/doc/SinglePassIterator.html @@ -0,0 +1,63 @@ + + + + + + +Single Pass Iterator Concept + + + +
+

Single Pass Iterator Concept

+

A class or built-in type X models the Single Pass Iterator +concept if the following expressions are valid and respect the stated +semantics.

+ +++++ + + + + + + + + + + + + + + + + + + + + + + + + + + +
Single Pass Iterator Requirements (in addition to Incrementable Iterator and Equality +Comparable)
ExpressionReturn TypeAssertion/Semantics / +Pre-/Post-condition
++rX&pre: r is +dereferenceable; post: +r is dereferenceable or +r is past-the-end
a == bconvertible to bool== is an equivalence +relation over its domain
a != bconvertible to bool!(a == b)
iterator_traversal<X>::typeConvertible to +single_pass_traversal_tag 
+
+
+
+View document source. +Generated by Docutils from reStructuredText source. +
+ + diff --git a/doc/SinglePassIterator.rst b/doc/SinglePassIterator.rst new file mode 100755 index 0000000..2754d97 --- /dev/null +++ b/doc/SinglePassIterator.rst @@ -0,0 +1,28 @@ +Single Pass Iterator Concept +............................ + +A class or built-in type ``X`` models the *Single Pass Iterator* +concept if the following expressions are valid and respect the stated +semantics. + + ++------------------------------------------------------------------------------------------+ +|Single Pass Iterator Requirements (in addition to Incrementable Iterator and Equality | +|Comparable) | ++--------------------------------+-----------------------------+---------------------------+ +|Expression |Return Type |Assertion/Semantics / | +| | |Pre-/Post-condition | ++================================+=============================+===========================+ +|``++r`` |``X&`` |pre: ``r`` is | +| | |dereferenceable; post: | +| | |``r`` is dereferenceable or| +| | |``r`` is past-the-end | ++--------------------------------+-----------------------------+---------------------------+ +|``a == b`` |convertible to ``bool`` |``==`` is an equivalence | +| | |relation over its domain | ++--------------------------------+-----------------------------+---------------------------+ +|``a != b`` |convertible to ``bool`` |``!(a == b)`` | ++--------------------------------+-----------------------------+---------------------------+ +|``iterator_traversal::type`` |Convertible to | | +| |``single_pass_traversal_tag``| | ++--------------------------------+-----------------------------+---------------------------+ diff --git a/doc/SwappableIterator.html b/doc/SwappableIterator.html new file mode 100644 index 0000000..faf0347 --- /dev/null +++ b/doc/SwappableIterator.html @@ -0,0 +1,49 @@ + + + + + + +Swappable Iterator Concept + + + +
+

Swappable Iterator Concept

+

A class or built-in type X models the Swappable Iterator concept +if, in addition to X being Copy Constructible, the following +expressions are valid and respect the stated semantics.

+ +++++ + + + + + + + + + + + + + + +
Swappable Iterator Requirements (in addition to Copy Constructible)
ExpressionReturn TypePostcondition
iter_swap(a, b)voidthe pointed to values are +exchanged
+
+
[Note: An iterator that is a model of the Readable and Writable Iterator concepts
+
is also a model of Swappable Iterator. --end note]
+
+
+
+
+View document source. +Generated by Docutils from reStructuredText source. +
+ + diff --git a/doc/SwappableIterator.rst b/doc/SwappableIterator.rst new file mode 100755 index 0000000..ec94d32 --- /dev/null +++ b/doc/SwappableIterator.rst @@ -0,0 +1,19 @@ +Swappable Iterator Concept +.......................... + +A class or built-in type ``X`` models the *Swappable Iterator* concept +if, in addition to ``X`` being Copy Constructible, the following +expressions are valid and respect the stated semantics. + ++---------------------------------------------------------------------+ +|Swappable Iterator Requirements (in addition to Copy Constructible) | ++-------------------------+-------------+-----------------------------+ +|Expression |Return Type |Postcondition | ++=========================+=============+=============================+ +|``iter_swap(a, b)`` |``void`` |the pointed to values are | +| | |exchanged | ++-------------------------+-------------+-----------------------------+ + +[*Note:* An iterator that is a model of the *Readable* and *Writable Iterator* concepts + is also a model of *Swappable Iterator*. *--end note*] + diff --git a/doc/WritableIterator.html b/doc/WritableIterator.html new file mode 100644 index 0000000..dafee1c --- /dev/null +++ b/doc/WritableIterator.html @@ -0,0 +1,47 @@ + + + + + + +Writable Iterator Concept + + + +
+

Writable Iterator Concept

+

A class or built-in type X models the Writable Iterator concept +if, in addition to X being Copy Constructible, the following +expressions are valid and respect the stated semantics. Writable +Iterators have an associated set of value types.

+ +++++ + + + + + + + + + + + + + + +
Writable Iterator Requirements (in addition to Copy Constructible)
ExpressionReturn TypePrecondition
*a = o pre: The type of o +is in the set of +value types of X
+
+
+
+View document source. +Generated by Docutils from reStructuredText source. +
+ + diff --git a/doc/WritableIterator.rst b/doc/WritableIterator.rst new file mode 100755 index 0000000..7b854cc --- /dev/null +++ b/doc/WritableIterator.rst @@ -0,0 +1,17 @@ +Writable Iterator Concept +......................... + +A class or built-in type ``X`` models the *Writable Iterator* concept +if, in addition to ``X`` being Copy Constructible, the following +expressions are valid and respect the stated semantics. Writable +Iterators have an associated *set of value types*. + ++---------------------------------------------------------------------+ +|Writable Iterator Requirements (in addition to Copy Constructible) | ++-------------------------+--------------+----------------------------+ +|Expression |Return Type |Precondition | ++=========================+==============+============================+ +|``*a = o`` | | pre: The type of ``o`` | +| | | is in the set of | +| | | value types of ``X`` | ++-------------------------+--------------+----------------------------+ diff --git a/doc/docutils.sty b/doc/docutils.sty new file mode 100755 index 0000000..a6fce3f --- /dev/null +++ b/doc/docutils.sty @@ -0,0 +1,54 @@ +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +%%%%%%%%%%%%%% docutils.sty: A style for docutils latex output %%%%%%%%%%%%%%% +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +%% +%% o author: Alexander Schmolck (a.schmolck@gmx.net) +%% o created: 2002-07-07 10:50:31+00:40 +%% o last modified: $Date: 2004/01/29 05:55:26 $ +%% o keywords: +%% o license: +%XXX titlesec +%% XXX geometry +\usepackage{graphicx} +\usepackage{latexsym} % extra symbols +\usepackage{url} % !!!: pay attention when using in other commands!!! +\usepackage{verbatim} % normal verbatim has lenght-limit +\usepackage{enumerate} % easy style choice with e.g: ``\begin{enumerate}[Ex i.]`` +\usepackage{hyperref} %href, htarget and hlink XXX: pdfauthor, pdfcreator etc. +\usepackage{xr} %XXX do we need this? +% need this to have ``fboxes`` in ``enviroments``, as well as ``verbatim``s +\usepackage{fancybox} +\usepackage{mdwtab} % better tables and arrays (fixes spacing and adds + % vertical align and multirows (m)) +\usepackage{ltxtable} % long and autoscaling tables (use X for autoscaled + % columns) +\newcommand{\transition}{\vspace{2em}\par\hrule{}\par\vspace{2em}} +\newcommand{\classifier}[1]{(\textit{#1})} +\newenvironment{topic}[1]% +{\begin{Sbox}% + \begin{minipage}{.8\textwidth}% + \protect{\large{\textbf{#1}}}\par\vspace{.5em}}% +{\end{minipage}\end{Sbox}\fbox{\TheSbox}\par\vspace{.5em}} +%XXX shadow box for warnings? +\newenvironment{admonition}[1]% +{\begin{center}% + \begin{Sbox}% + \begin{minipage}{.9\textwidth}% + \protect{\textsc{#1}}\par\vspace{.2em}}% +{\end{minipage}\end{Sbox}\fbox{\TheSbox}\par\vspace{.5em}\end{center}} + +\newenvironment{doctest}% +{\VerbatimEnvironment + \begin{Verbatim}}% +{\end{Verbatim}} +% {% +% \begin{Sbox}% +% \begin{minipage}{.8\textwidth}% +% \protect{\large{\textsc{#1}}\par\vspace{.5em}}}% +% {\end{minipage}\end{Sbox}\fbox{\TheSbox}\par\vspace{.5em}} +%{\end{minipage}\end{Sbox}\fbox{\TheSbox}} + + +%% just a piece of example code +% \newcommand{\vitem}% +% {\SaveVerb[{\item[\UseVerb{\MyTemp}]}]{\MyTemp}} diff --git a/doc/filter_iterator_ref.html b/doc/filter_iterator_ref.html new file mode 100755 index 0000000..2ca03a0 --- /dev/null +++ b/doc/filter_iterator_ref.html @@ -0,0 +1,241 @@ + + + + + + + + + +
+
+template <class Predicate, class Iterator>
+class filter_iterator
+{
+ public:
+    typedef iterator_traits<Iterator>::value_type value_type;
+    typedef iterator_traits<Iterator>::reference reference;
+    typedef iterator_traits<Iterator>::pointer pointer;
+    typedef iterator_traits<Iterator>::difference_type difference_type;
+    typedef /* see below */ iterator_category;
+
+    filter_iterator();
+    filter_iterator(Predicate f, Iterator x, Iterator end = Iterator());
+    filter_iterator(Iterator x, Iterator end = Iterator());
+    template<class OtherIterator>
+    filter_iterator(
+        filter_iterator<Predicate, OtherIterator> const& t
+        , typename enable_if_convertible<OtherIterator, Iterator>::type* = 0 // exposition
+        );
+    Predicate predicate() const;
+    Iterator end() const;
+    Iterator base() const;
+    reference operator*() const;
+    filter_iterator& operator++();
+private:
+    Predicate m_pred; // exposition
+    Iterator m_iter;  // exposition
+    Iterator m_end;   // exposition
+};
+
+

The iterator_category member is a type convertible to the tags +corresponding to each standard concept modeled by filter_iterator, +as described in the models section.

+
+

filter_iterator requirements

+

The Predicate argument must be Assignable, Copy Constructible, and +the expression p(x) must be valid where p is an object of type +Predicate, x is an object of type +iterator_traits<Iterator>::value_type, and where the type of +p(x) must be convertible to bool.

+

The Iterator argument shall meet the requirements of Readable +Iterator and Single Pass Iterator or it shall meet the requirements of +Input Iterator.

+
+
+

filter_iterator models

+

The concepts that filter_iterator models are dependent on which +concepts the Iterator argument models, as specified in the +following tables.

+ ++++ + + + + + + + + + + + + + +
If Iterator modelsthen filter_iterator models
Single Pass IteratorSingle Pass Iterator
Forward Traversal IteratorForward Traversal Iterator
+ ++++ + + + + + + + + + + + + + + + + +
If Iterator modelsthen filter_iterator models
Readable IteratorReadable Iterator
Writable IteratorWritable Iterator
Lvalue IteratorLvalue Iterator
+ ++++ + + + + + + + + + + + + + + + + +
If Iterator modelsthen filter_iterator models
Readable Iterator, Single Pass IteratorInput Iterator
Readable Lvalue Iterator, Forward Traversal IteratorForward Iterator
Writable Lvalue Iterator, Forward Traversal IteratorMutable Forward Iterator
+
+
+

filter_iterator operations

+

In addition to those operations required by the concepts that +filter_iterator models, filter_iterator provides the following +operations.

+

filter_iterator();

+ +++ + + + + + +
Requires:Predicate and Iterator must be Default Constructible.
Returns:a filter_iterator whose``m_pred``, m_iter, and m_end +members are a default constructed.
+

filter_iterator(Predicate f, Iterator x, Iterator end = Iterator());

+ +++ + + + +
Returns:A filter_iterator where m_iter is either +the first position in the range [x,end) such that f(*m_iter) == true +or else``m_iter == end``. The member m_pred is constructed from +f and m_end from end.
+

filter_iterator(Iterator x, Iterator end = Iterator());

+ +++ + + + + + +
Requires:Predicate must be Default Constructible.
Returns:A filter_iterator where m_iter is either +the first position in the range [x,end) such that m_pred(*m_iter) == true +or else``m_iter == end``. The member m_pred is default constructed.
+
+template <class OtherIterator>
+filter_iterator(
+    filter_iterator<Predicate, OtherIterator> const& t
+    , typename enable_if_convertible<OtherIterator, Iterator>::type* = 0 // exposition
+    );``
+
+ +++ + + + + + +
Requires:OtherIterator is implicitly convertible to Iterator.
Returns:A filter iterator whose members are copied from t.
+

Predicate predicate() const;

+ +++ + + + +
Returns:m_pred
+

Iterator end() const;

+ +++ + + + +
Returns:m_end
+

Iterator base() const;

+ +++ + + + +
Returns:m_iterator
+

reference operator*() const;

+ +++ + + + +
Returns:*m_iter
+

filter_iterator& operator++();

+ +++ + + + + + +
Effects:Increments m_iter and then continues to +increment m_iter until either m_iter == m_end +or m_pred(*m_iter) == true.
Returns:*this
+
+
+
+
+View document source. +Generated on: 2004-01-13 02:57 UTC. +Generated by Docutils from reStructuredText source. +
+ + diff --git a/doc/indirect_iterator_ref.html b/doc/indirect_iterator_ref.html new file mode 100755 index 0000000..08e5018 --- /dev/null +++ b/doc/indirect_iterator_ref.html @@ -0,0 +1,147 @@ + + + + + + + + + +
+
+template <
+    class Iterator
+  , class Value = use_default
+  , class CategoryOrTraversal = use_default
+  , class Reference = use_default
+  , class Difference = use_default
+>
+class indirect_iterator
+{
+ public:
+    typedef /* see below */ value_type;
+    typedef /* see below */ reference;
+    typedef /* see below */ pointer;
+    typedef /* see below */ difference_type;
+    typedef /* see below */ iterator_category;
+
+    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
+    );
+};
+
+

The member types of indirect_iterator are defined according to the +following pseudo-code. We use the abbreviation +V=iterator_traits<Iterator>::value_type and v is an object of +type V.:

+
+if (Value is use_default) then
+    typedef iterator_traits<V>::value_type value_type;
+else
+    typedef remove_const<Value>::type value_type;
+
+if (Reference is use_default) then
+    typedef iterator_traits<V>::reference reference;
+else
+    typedef Reference reference;
+
+typedef Value* pointer;
+
+if (Difference is use_default)
+    typedef iterator_traits<Iterator>::difference_type difference_type;
+else
+    typedef Difference difference_type;
+
+

The member indirect_iterator::iterator_category is a type that +satisfies the requirements of the concepts modeled by the indirect +iterator as specified in the models section.

+
+

indirect_iterator requirements

+

The Iterator argument shall meet the requirements of Readable +Iterator. The CategoryOrTraversal argument shall be one of the +standard iterator tags or use_default. If CategoryOrTraversal +is an iterator tag, the template parameter Iterator argument shall +meet the traversal requirements corresponding to the iterator tag.

+

The expression *v, where v is an object of type +iterator_traits<Iterator>::value_type, must be a valid expression +and must be convertible to indirect_iterator::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 for the value_type member.

+
+
+

indirect_iterator models

+

If CategoryOrTraversal is a standard iterator tag, +indirect_iterator is a model of the iterator concept corresponding +to the tag, otherwise indirect_iterator satisfies the requirements +of the most refined standard traversal concept that is satisfied by +the Iterator argument.

+

indirect_iterator models Readable Iterator. If +indirect_iterator::reference(*v) = t is a valid expression (where +t is an object of type indirect_iterator::value_type) then +indirect_iterator models Writable Iterator. If +indirect_iterator::reference is a reference then +indirect_iterator models Lvalue Iterator.

+
+
+

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().
+
+
+ + diff --git a/doc/iter-issue-list.html b/doc/iter-issue-list.html new file mode 100755 index 0000000..695b466 --- /dev/null +++ b/doc/iter-issue-list.html @@ -0,0 +1,5271 @@ + + + + + + +Iterator concept and adapter issues + + + + + +
+

Iterator concept and adapter issues

+ +++ + + + + + +
Date:2004-01-21
Copyright:Copyright David Abrahams, Jeremy Siek, and Thomas Witt 2003.
+
+

Index

+ +
+
+

Issues from Matt's TR issues list

+
+

9.1 iterator_access overspecified?

+ +++ + + + + + +
Submitter:Pete Becker
Status:New
+

The proposal includes:

+
+enum iterator_access { 
+   readable_iterator = 1, writable_iterator = 2,
+   swappable_iterator = 4, lvalue_iterator = 8
+}; 
+
+

In general, the standard specifies thing like this as a bitmask +type with a list of defined names, and specifies neither the exact +type nor the specific values. Is there a reason for iterator_access +to be more specific?

+ +++ + + + + +
Proposed resolution:
 The iterator_access enum will be removed, +so this is no longer an issue. See the resolution to 9.15.
+
+
+

9.2 operators of iterator_facade overspecified

+ +++ + + + + + +
Submitter:Pete Becker
Status:New
+

In general, we've provided operational semantics for things like +operator++. That is, we've said that ++iter must work, without +requiring either a member function or a non-member function. +iterator_facade specifies most operators as member +functions. There's no inherent reason for these to be members, so +we should remove this requirement. Similarly, some operations are +specified as non-member functions but could be implemented as +members. Again, the standard doesn't make either of these choices, +and TR1 shouldn't, either. So: operator*(), operator++(), +operator++(int), operator--(), operator--(int), +operator+=, operator-=, operator-(difference_type), +operator-(iterator_facade instance), and operator+ should +be specified with operational semantics and not explicitly required +to be members or non-members.

+ +++ + + + + + + +
Proposed resolution:
 Not a defect.
Rationale:The standard uses valid expressions such as ++iter +in requirements tables, such as for input iterator. However, for +classes, such as reverse_iterator, the standard uses function +prototypes, as we have done here for +iterator_facade. Further, the prototype specification does +not prevent the implementor from using members or non-members, +since nothing the user can do in a conforming program can detect +how the function is implemented.
+
+
+

9.3 enable_if_interoperable needs standardese

+ +++ + + + + + +
Submitter:Pete Becker
Status:New
+

The only discussion of what this means is in a note, so is +non-normative. Further, the note seems to be incorrect. It says +that enable_if_interoperable only works for types that "are +interoperable, by which we mean they are convertible to each +other." This requirement is too strong: it should be that one of +the types is convertible to the other. N1541 48

+ +++ + + + + +
Proposed resolution:
 

Add normative text. Relax requirements in the +proposed way.

+

Change:

+
+[Note: The enable_if_interoperable template used above is +for exposition purposes. The member operators should be only be +in an overload set provided the derived types Dr1 and +Dr2 are interoperable, by which we mean they are +convertible to each other. The enable_if_interoperable +approach uses SFINAE to take the operators out of the overload +set when the types are not interoperable.]
+

To:

+
+

The enable_if_interoperable template used above is for +exposition purposes. The member operators should only be in an +overload set provided the derived types Dr1 and Dr2 are +interoperable, meaning that at least one of the types is +convertible to the other. The enable_if_interoperable +approach uses SFINAE to take the operators out of the overload +set when the types are not interoperable. The operators should +behave as-if enable_if_interoperable were defined to be:

+
+template <bool, typename> enable_if_interoperable_impl
+{};
+
+template <typename T> enable_if_interoperable_impl<true,T>
+{ typedef T type; };
+
+template<typename Dr1, typename Dr2, typename T>
+struct enable_if_interoperable
+  : enable_if_interoperable_impl<
+        is_convertible<Dr1,Dr2>::value || is_convertible<Dr2,Dr1>::value
+      , T
+    >
+{};
+
+
+
+
+
+

9.4 enable_if_convertible unspecified, conflicts with requires

+ +++ + + + + + +
Submitter:Pete Becker
Status:New
+

In every place where enable_if_convertible is used it's used like +this (simplified):

+
+template<class T>
+struct C
+{
+  template<class T1>
+  C(T1, enable_if_convertible<T1, T>::type* = 0);
+};
+
+

The idea being that this constructor won't compile if T1 isn't +convertible to T. As a result, the constructor won't be considered +as a possible overload when constructing from an object x where the +type of x isn't convertible to T. In addition, however, each of +these constructors has a requires clause that requires +convertibility, so the behavior of a program that attempts such a +construction is undefined. Seems like the enable_if_convertible +part is irrelevant, and should be removed. There are two +problems. First, enable_if_convertible is never specified, so we +don't know what this is supposed to do. Second: we could reasonably +say that this overload should be disabled in certain cases or we +could reasonably say that behavior is undefined, but we can't say +both.

+

Thomas Witt writes that the goal of putting in +enable_if_convertible here is to make sure that a specific overload +doesn't interfere with the generic case except when that overload +makes sense. He agrees that what we currently have is deficient. +Dave Abrahams writes that there is no conflict with the requires +cause because the requires clause only takes effect when the +function is actually called. The presence of the constructor +signature can/will be detected by is_convertible without violating +the requires clause, and thus it makes a difference to disable +those constructor instantiations that would be disabled by +enable_if_convertible even if calling them invokes undefined +behavior. There was more discussion on the reflector: +c++std-lib-12312, c++std-lib-12325, c++std-lib- 12330, +c++std-lib-12334, c++std-lib-12335, c++std-lib-12336, +c++std-lib-12338, c++std-lib- 12362.

+ +++ + + + + +
Proposed resolution:
 

Change:

+
+[Note: The enable_if_convertible<X,Y>::type expression +used in this section is for exposition purposes. The converting +constructors for specialized adaptors should be only be in an +overload set provided that an object of type X is +implicitly convertible to an object of type Y. The +enable_if_convertible approach uses SFINAE to take the +constructor out of the overload set when the types are not +implicitly convertible.]
+

To:

+
+

The enable_if_convertible<X,Y>::type expression used in +this section is for exposition purposes. The converting +constructors for specialized adaptors should be only be in an +overload set provided that an object of type X is +implicitly convertible to an object of type Y. The +signatures involving enable_if_convertible should behave +as-if enable_if_convertible were defined to be:

+
+template <bool> enable_if_convertible_impl
+{};
+
+template <> enable_if_convertible_impl<true>
+{ struct type; };
+
+template<typename From, typename To>
+struct enable_if_convertible
+  : enable_if_convertible_impl<is_convertible<From,To>::value>
+{};
+
+

If an expression other than the default argument is used to +supply the value of a function parameter whose type is written +in terms of enable_if_convertible, the program is +ill-formed, no diagnostic required.

+

[Note: The enable_if_convertible approach uses SFINAE to +take the constructor out of the overload set when the types are +not implicitly convertible. ]

+
+
+
+
+

9.5 iterator_adaptor has an extraneous 'bool' at the start of the template definition

+ +++ + + + + + +
Submitter:Pete Becker
Status:New
+

The title says it all; this is probably just a typo.

+ +++ + + + + +
Proposed resolution:
 Remove the 'bool'.
+
+
+

9.6 Name of private member shouldn't be normative

+ +++ + + + + + +
Submitter:Pete Becker
Status:New
+

iterator_adaptor has a private member named m_iterator. Presumably +this is for exposition only, since it's an implementation +detail. It needs to be marked as such.

+ +++ + + + + +
Proposed resolution:
 
+
Mark the member m_iterator as exposition
+
only. Note/DWA: I think this is NAD because the user can't +detect it, though I'm happy to mark it exposition only.
+
+

In [lib.iterator.adaptor]

+

Change:

+
+Base m_iterator;
+
+

to:

+
+Base m_iterator; // exposition only
+
+
+
+
+

9.7 iterator_adaptor operations specifications are a bit inconsistent

+ +++ + + + + + +
Submitter:Pete Becker
Status:New
+

iterator_adpator() has a Requires clause, that Base must be default +constructible. iterator_adaptor(Base) has no Requires clause, +although the Returns clause says that the Base member is copy +construced from the argument (this may actually be an oversight in +N1550, which doesn't require iterators to be copy constructible or +assignable).

+ +++ + + + + +
Proposed resolution:
 

Add a requirements section for the template +parameters of iterator_adaptor, and state that Base must be Copy +Constructible and Assignable.

+

N1550 does in fact include requirements for copy constructible +and assignable in the requirements tables. To clarify, we've also +added the requirements to the text.

+
+
+
+

9.8 Specialized adaptors text should be normative

+ +++ + + + + + +
Submitter:Pete Becker
Status:New
+

similar to 9.3, "Specialized Adaptors" has a note describing +enable_if_convertible. This should be normative text.

+ +++ + + + + +
Proposed resolution:
 Changed it to normative +text. See the resolution of 9.4
+
+
+

9.9 Reverse_iterator text is too informal

+ +++ + + + + + +
Submitter:Pete Becker
Status:New
+

reverse iterator "flips the direction of the base iterator's +motion". This needs to be more formal, as in the current +standard. Something like: "iterates through the controlled sequence +in the opposite direction"

+ +++ + + + + +
Proposed resolution:
 

Change:

+
+The reverse iterator adaptor flips the direction of a base +iterator's motion. Invoking operator++() moves the base +iterator backward and invoking operator--() moves the base +iterator forward.
+

to:

+
+The reverse iterator adaptor iterates through the adapted iterator +range in the opposite direction.
+
+
+
+

9.10 'prior' is undefined

+ +++ + + + + + +
Submitter:Pete Becker
Status:New
+

reverse_iterator::dereference is specified as calling a function +named 'prior' which has no specification.

+ +++ + + + + + + +
Proposed resolution:
 

Change the specification to avoid using prior as follows.

+

Remove:

+
+typename reverse_iterator::reference dereference() const { return *prior(this->base()); }
+
+

And at the end of the operations section add:

+
+

reference operator*() const;

+ +++ + + + +
Effects:
+
+Iterator tmp = m_iterator;
+return *--tmp;
+
+
+
Rationale:The style of specification has changed because of issue 9.37x.
+
+
+

9.11 "In other words" is bad wording

+ +++ + + + + + +
Submitter:Pete Becker
Status:New
+

Transform iterator has a two-part specification: it does this, in +other words, it does that. "In other words" always means "I didn't +say it right, so I'll try again." We need to say it once.

+ +++ + + + + +
Proposed resolution:
 

Change:

+
+The transform iterator adapts an iterator by applying some function +object to the result of dereferencing the iterator. In other words, +the operator* of the transform iterator first dereferences the +base iterator, passes the result of this to the function object, and +then returns the result.
+

to:

+
+The transform iterator adapts an iterator by modifying the +operator* to apply a function object to the result of +dereferencing the iterator and returning the result.
+
+
+
+

9.12 Transform_iterator shouldn't mandate private member

+ +++ + + + + + +
Submitter:Pete Becker
Status:New
+

transform_iterator has a private member named 'm_f' which should be +marked "exposition only."

+ +++ + + + + +
Proposed resolution:
 

Mark the member m_f as exposition +only. Note/DWA: I think this is NAD because the user can't +detect it, though I'm happy to mark it exposition only.

+

Change:

+
+UnaryFunction m_f;
+
+

to:

+
+UnaryFunction m_f;   // exposition only
+
+
+
+
+

9.13 Unclear description of counting iterator

+ +++ + + + + + +
Submitter:Pete Becker
Status:New
+

The description of Counting iterator is unclear. "The counting +iterator adaptor implements dereference by returning a reference to +the base object. The other operations are implemented by the base +m_iterator, as per the inheritance from iterator_adaptor."

+ +++ + + + + +
Proposed resolution:
 

Change:

+
+The counting iterator adaptor implements dereference by +returning a reference to the base object. The other operations +are implemented by the base m_iterator, as per the +inheritance from iterator_adaptor.
+

to:

+
+counting_iterator adapts an object by adding an +operator* that returns the current value of the object. All +other iterator operations are forwarded to the adapted object.
+
+
+
+

9.14 Counting_iterator's difference type

+ +++ + + + + + +
Submitter:Pete Becker
Status:New
+

Counting iterator has the following note:

+
+[Note: implementers are encouraged to provide an implementation +of distance_to and a difference_type that avoids overflows in the +cases when the Incrementable type is a numeric type.]
+

I'm not sure what this means. The user provides a template argument +named Difference, but there's no difference_type. I assume this is +just a glitch in the wording. But if implementors are encouraged to +ignore this argument if it won't work right, why is it there?

+ +++ + + + + +
Proposed resolution:
 The difference_type was inherited from +iterator_adaptor. However, we've removed the explicit +inheritance, so explicit typedefs have been added. See the +resolution of 9.37x.
+
+
+

9.15 How to detect lvalueness?

+ +++ + + + + + +
Submitter:Dave Abrahams
Status:New
+

Shortly after N1550 was accepted, we discovered that an iterator's +lvalueness can be determined knowing only its value_type. This +predicate can be calculated even for old-style iterators (on whose +reference type the standard places few requirements). A trait in +the Boost iterator library does it by relying on the compiler's +unwillingness to bind an rvalue to a T& function template +parameter. Similarly, it is possible to detect an iterator's +readability knowing only its value_type. Thus, any interface which +asks the user to explicitly describe an iterator's lvalue-ness or +readability seems to introduce needless complexity.

+ +++ + + + + +
Proposed resolution:
 
    +
  1. Remove the is_writable and is_swappable traits, and +remove the requirements in the Writable Iterator and Swappable +Iterator concepts that require their models to support these +traits.
    2. +
  2. Change the is_readable specification. Remove the +requirement for support of the is_readable trait from the +Readable Iterator concept.
    3. +
  3. Remove the iterator_tag class and transplant the logic for +choosing an iterator category into iterator_facade.
    4. +
  4. Change the specification of traversal_category.
    5. +
  5. Remove Access parameters from N1530
    6. +
+

In N1550:

+

Remove:

+
+

Since the access concepts are not related via refinement, but +instead cover orthogonal issues, we do not use tags for the +access concepts, but instead use the equivalent of a bit field.

+

We provide an access mechanism for mapping iterator types to +the new traversal tags and access bit field. Our design reuses +iterator_traits<Iter>::iterator_category as the access +mechanism. To that end, the access and traversal information is +bundled into a single type using the following iterator_tag +class.

+
+enum iterator_access { readable_iterator = 1, writable_iterator = 2, 
+    swappable_iterator = 4, lvalue_iterator = 8 };
+
+template <unsigned int access_bits, class TraversalTag>
+struct iterator_tag : /* appropriate old category or categories */ {
+  static const iterator_access access =
+    (iterator_access)access_bits & 
+      (readable_iterator | writable_iterator | swappable_iterator);
+  typedef TraversalTag traversal;
+};
+
+

The access_bits argument is declared to be unsigned int +instead of the enum iterator_access for convenience of +use. For example, the expression (readable_iterator | +writable_iterator) produces an unsigned int, not an +iterator_access. The purpose of the lvalue_iterator +part of the iterator_access enum is to communicate to +iterator_tag whether the reference type is an lvalue so +that the appropriate old category can be chosen for the base +class. The lvalue_iterator bit is not recorded in the +iterator_tag::access data member.

+

The iterator_tag class template is derived from the +appropriate iterator tag or tags from the old requirements +based on the access bits and traversal tag passed as template +parameters. The algorithm for determining the old tag or tags +picks the least refined old concepts that include all of the +requirements of the access and traversal concepts (that is, the +closest fit), if any such category exists. For example, the +category tag for a Readable Single Pass Iterator will always be +derived from input_iterator_tag, while the category tag for +a Single Pass Iterator that is both Readable and Writable will +be derived from both input_iterator_tag and +output_iterator_tag.

+

We also provide several helper classes that make it convenient +to obtain the access and traversal characteristics of an +iterator. These helper classes work both for iterators whose +iterator_category is iterator_tag and also for +iterators using the original iterator categories.

+
+template <class Iterator> struct is_readable  { typedef ... type; };
+template <class Iterator> struct is_writable { typedef ... type; };
+template <class Iterator> struct is_swappable { typedef ... type; };
+template <class Iterator> struct traversal_category { typedef ... type; };
+
+
+

After:

+
+Like the old iterator requirements, we provide tags for +purposes of dispatching based on the traversal concepts. The +tags are related via inheritance so that a tag is convertible +to another tag if the concept associated with the first tag is +a refinement of the second tag.
+

Add:

+
+

Our design reuses iterator_traits<Iter>::iterator_category +to indicate an iterator's traversal capability. To specify +capabilities not captured by any old-style iterator category, +an iterator designer can use an iterator_category type that +is convertible to both the the most-derived old iterator +category tag which fits, and the appropriate new iterator +traversal tag.

+

We do not provide tags for the purposes of dispatching based on +the access concepts, in part because we could not find a way to +automatically infer the right access tags for old-style +iterators. An iterator's writability may be dependent on the +assignability of its value_type and there's no known way to +detect whether an arbitrary type is assignable. Fortunately, +the need for dispatching based on access capability is not as +great as the need for dispatching based on traversal +capability.

+
+

From the Readable Iterator Requirements table, remove:

+
+ +++++ + + + + + + +
is_readable<X>::typetrue_type 
+
+

From the Writable Iterator Requirements table, remove:

+
+ +++++ + + + + + + +
is_writable<X>::typetrue_type 
+
+

From the Swappable Iterator Requirements table, remove:

+
+ +++++ + + + + + + +
is_swappable<X>::typetrue_type 
+
+

From [lib.iterator.synopsis] replace:

+
+template <class Iterator> struct is_readable;
+template <class Iterator> struct is_writable;
+template <class Iterator> struct is_swappable;
+template <class Iterator> struct traversal_category;
+
+enum iterator_access { readable_iterator = 1, writable_iterator = 2, 
+    swappable_iterator = 4, lvalue_iterator = 8 };
+
+template <unsigned int access_bits, class TraversalTag>
+struct iterator_tag : /* appropriate old category or categories */ {
+  static const iterator_access access =
+    (iterator_access)access_bits & 
+      (readable_iterator | writable_iterator | swappable_iterator);
+  typedef TraversalTag traversal;
+};
+
+

with:

+
+template <class Iterator> struct is_readable_iterator;
+template <class Iterator> struct iterator_traversal;
+
+

In [lib.iterator.traits], remove:

+
+

The iterator_tag class template is an iterator category tag +that encodes the access enum and traversal tag in addition to +being compatible with the original iterator tags. The +iterator_tag class inherits from one of the original +iterator tags according to the following pseudo-code.

+
+inherit-category(access, traversal-tag) =
+     if ((access & readable_iterator) && (access & lvalue_iterator)) {
+         if (traversal-tag is convertible to random_access_traversal_tag)
+             return random_access_iterator_tag;
+         else if (traversal-tag is convertible to bidirectional_traversal_tag)
+             return bidirectional_iterator_tag;
+         else if (traversal-tag is convertible to forward_traversal_tag)
+             return forward_iterator_tag;
+         else if (traversal-tag is convertible to single_pass_traversal_tag)
+             if (access-tag is convertible to writable_iterator_tag)
+                 return input_output_iterator_tag;
+             else
+                 return input_iterator_tag;
+         else
+             return null_category_tag;
+     } else if ((access & readable_iterator) and (access & writable_iterator)
+                and traversal-tag is convertible to single_pass_iterator_tag)
+         return input_output_iterator_tag;
+     else if (access & readable_iterator
+              and traversal-tag is convertible to single_pass_iterator_tag)
+         return input_iterator_tag;
+     else if (access & writable_iterator
+              and traversal-tag is convertible to incrementable_iterator_tag)
+         return output_iterator_tag;
+     else
+         return null_category_tag;
+
+

If the argument for TraversalTag is not convertible to +incrementable_iterator_tag then the program is ill-formed.

+
+

Change:

+
+

The is_readable, is_writable, is_swappable, and +traversal_category class templates are traits classes. For +iterators whose iterator_traits<Iter>::iterator_category +type is iterator_tag, these traits obtain the access +enum and traversal member type from within +iterator_tag. For iterators whose +iterator_traits<Iter>::iterator_category type is not +iterator_tag and instead is a tag convertible to one of the +original tags, the appropriate traversal tag and access bits +are deduced. The following pseudo-code describes the +algorithm.

+
+is-readable(Iterator) = 
+    cat = iterator_traits<Iterator>::iterator_category;
+    if (cat == iterator_tag<Access,Traversal>)
+        return Access & readable_iterator;
+    else if (cat is convertible to input_iterator_tag)
+        return true;
+    else
+        return false;
+
+is-writable(Iterator) =
+    cat = iterator_traits<Iterator>::iterator_category;
+    if (cat == iterator_tag<Access,Traversal>)
+        return Access & writable_iterator;
+    else if (cat is convertible to output_iterator_tag)
+         return true;
+    else if (
+         cat is convertible to forward_iterator_tag
+         and iterator_traits<Iterator>::reference is a 
+             mutable reference)
+        return true;
+    else
+        return false;
+
+is-swappable(Iterator) =
+    cat = iterator_traits<Iterator>::iterator_category;
+    if (cat == iterator_tag<Access,Traversal>)
+        return Access & swappable_iterator;
+    else if (cat is convertible to forward_iterator_tag) {
+        if (iterator_traits<Iterator>::reference is a const reference)
+            return false;
+        else
+            return true;
+    } else 
+        return false;
+
+traversal-category(Iterator) =
+    cat = iterator_traits<Iterator>::iterator_category;
+    if (cat == iterator_tag<Access,Traversal>)
+        return Traversal;
+    else if (cat is convertible to random_access_iterator_tag)
+        return random_access_traversal_tag;
+    else if (cat is convertible to bidirectional_iterator_tag)
+        return bidirectional_traversal_tag;
+    else if (cat is convertible to forward_iterator_tag)
+        return forward_traversal_tag;
+    else if (cat is convertible to input_iterator_tag)
+        return single_pass_iterator_tag;
+    else if (cat is convertible to output_iterator_tag)
+        return incrementable_iterator_tag;
+    else
+        return null_category_tag;
+
+

The following specializations provide the access and traversal +category tags for pointer types.

+
+template <typename T>
+struct is_readable<const T*> { typedef true_type type; };
+template <typename T>
+struct is_writable<const T*> { typedef false_type type; };
+template <typename T>
+struct is_swappable<const T*> { typedef false_type type; };
+
+template <typename T>
+struct is_readable<T*> { typedef true_type type; };
+template <typename T>
+struct is_writable<T*> { typedef true_type type; };
+template <typename T>
+struct is_swappable<T*> { typedef true_type type; };
+
+template <typename T>
+struct traversal_category<T*>
+{
+  typedef random_access_traversal_tag type;
+};
+
+
+

to:

+
+

The is_readable_iterator class template satisfies the +UnaryTypeTrait requirements.

+

Given an iterator type X, +is_readable_iterator<X>::value yields true if, for an +object a of type X, *a is convertible to +iterator_traits<X>::value_type, and false otherwise.

+

iterator_traversal<X>::type is

+
+category-to-traversal(iterator_traits<X>::iterator_category) 
+
+

where category-to-traversal is defined as follows

+
+category-to-traversal(C) =
+    if (C is convertible to incrementable_traversal_tag)
+        return C;
+    else if (C is convertible to random_access_iterator_tag)
+        return random_access_traversal_tag;
+    else if (C is convertible to bidirectional_iterator_tag)
+        return bidirectional_traversal_tag;
+    else if (C is convertible to forward_iterator_tag)
+        return forward_traversal_tag;
+    else if (C is convertible to input_iterator_tag)
+        return single_pass_traversal_tag;
+    else if (C is convertible to output_iterator_tag)
+        return incrementable_traversal_tag;
+    else
+        the program is ill-formed
+
+
+

In N1530:

+

In [lib.iterator.helper.synopsis]:

+

Change:

+
+const unsigned use_default_access = -1;
+
+struct iterator_core_access { /* implementation detail */ };
+
+template <
+    class Derived
+  , class Value
+  , unsigned AccessCategory
+  , class TraversalCategory
+  , class Reference  = Value&
+  , class Difference = ptrdiff_t
+>
+class iterator_facade;
+
+template <
+    class Derived
+  , class Base
+  , class Value      = use_default
+  , unsigned Access  = use_default_access
+  , class Traversal  = use_default
+  , class Reference  = use_default
+  , class Difference = use_default
+>
+class iterator_adaptor;
+
+template <
+    class Iterator
+  , class Value = use_default
+  , unsigned Access  = use_default_access
+  , class Traversal  = use_default
+  , class Reference = use_default
+  , class Difference = use_default
+>
+class indirect_iterator;
+
+

To:

+
+struct iterator_core_access { /* implementation detail */ };
+
+template <
+    class Derived
+  , class Value
+  , class CategoryOrTraversal
+  , class Reference  = Value&
+  , class Difference = ptrdiff_t
+>
+class iterator_facade;
+
+template <
+    class Derived
+  , class Base
+  , class Value      = use_default
+  , class CategoryOrTraversal  = use_default
+  , class Reference  = use_default
+  , class Difference = use_default
+>
+class iterator_adaptor;
+
+template <
+    class Iterator
+  , class Value = use_default
+  , class CategoryOrTraversal = use_default
+  , class Reference = use_default
+  , class Difference = use_default
+>
+class indirect_iterator;
+
+

Change:

+
+template <
+    class Incrementable
+  , unsigned Access  = use_default_access
+  , class Traversal  = use_default
+  , class Difference = use_default
+>
+class counting_iterator
+
+

To:

+
+template <
+    class Incrementable
+  , class CategoryOrTraversal  = use_default
+  , class Difference = use_default
+>
+class counting_iterator;
+
+

In [lib.iterator.facade]:

+

Change:

+
+template <
+    class Derived
+  , class Value
+  , unsigned AccessCategory
+  , class TraversalCategory
+  , class Reference  = /* see below */
+  , class Difference = ptrdiff_t
+>
+class iterator_facade {
+
+

to:

+
+template <
+    class Derived
+  , class Value
+  , class CategoryOrTraversal
+  , class Reference  = Value&
+  , class Difference = ptrdiff_t
+>
+class iterator_facade {
+
+

Change:

+
+typedef iterator_tag<AccessCategory, TraversalCategory> iterator_category;
+
+

to:

+
+typedef /* see below */ iterator_category;
+
+

Change:

+
+// Comparison operators
+template <class Dr1, class V1, class AC1, class TC1, class R1, class D1,
+          class Dr2, class V2, class AC2, class TC2, class R2, class D2>
+typename enable_if_interoperable<Dr1, Dr2, bool>::type // exposition
+operator ==(iterator_facade<Dr1, V1, AC1, TC1, R1, D1> const& lhs,
+            iterator_facade<Dr2, V2, AC2, TC2, R2, D2> const& rhs);
+
+template <class Dr1, class V1, class AC1, class TC1, class R1, class D1,
+          class Dr2, class V2, class AC2, class TC2, class R2, class D2>
+typename enable_if_interoperable<Dr1, Dr2, bool>::type
+operator !=(iterator_facade<Dr1, V1, AC1, TC1, R1, D1> const& lhs,
+            iterator_facade<Dr2, V2, AC2, TC2, R2, D2> const& rhs);
+
+template <class Dr1, class V1, class AC1, class TC1, class R1, class D1,
+          class Dr2, class V2, class AC2, class TC2, class R2, class D2>
+typename enable_if_interoperable<Dr1, Dr2, bool>::type
+operator <(iterator_facade<Dr1, V1, AC1, TC1, R1, D1> const& lhs,
+           iterator_facade<Dr2, V2, AC2, TC2, R2, D2> const& rhs);
+
+template <class Dr1, class V1, class AC1, class TC1, class R1, class D1,
+          class Dr2, class V2, class AC2, class TC2, class R2, class D2>
+typename enable_if_interoperable<Dr1, Dr2, bool>::type
+operator <=(iterator_facade<Dr1, V1, AC1, TC1, R1, D1> const& lhs,
+            iterator_facade<Dr2, V2, AC2, TC2, R2, D2> const& rhs);
+
+template <class Dr1, class V1, class AC1, class TC1, class R1, class D1,
+          class Dr2, class V2, class AC2, class TC2, class R2, class D2>
+typename enable_if_interoperable<Dr1, Dr2, bool>::type
+operator >(iterator_facade<Dr1, V1, AC1, TC1, R1, D1> const& lhs,
+           iterator_facade<Dr2, V2, AC2, TC2, R2, D2> const& rhs);
+
+template <class Dr1, class V1, class AC1, class TC1, class R1, class D1,
+          class Dr2, class V2, class AC2, class TC2, class R2, class D2>
+typename enable_if_interoperable<Dr1, Dr2, bool>::type
+operator >=(iterator_facade<Dr1, V1, AC1, TC1, R1, D1> const& lhs,
+            iterator_facade<Dr2, V2, AC2, TC2, R2, D2> const& rhs);
+
+template <class Dr1, class V1, class AC1, class TC1, class R1, class D1,
+          class Dr2, class V2, class AC2, class TC2, class R2, class D2>
+typename enable_if_interoperable<Dr1, Dr2, bool>::type
+operator >=(iterator_facade<Dr1, V1, AC1, TC1, R1, D1> const& lhs,
+            iterator_facade<Dr2, V2, AC2, TC2, R2, D2> const& rhs);
+
+// Iterator difference
+template <class Dr1, class V1, class AC1, class TC1, class R1, class D1,
+          class Dr2, class V2, class AC2, class TC2, class R2, class D2>
+typename enable_if_interoperable<Dr1, Dr2, bool>::type
+operator -(iterator_facade<Dr1, V1, AC1, TC1, R1, D1> const& lhs,
+           iterator_facade<Dr2, V2, AC2, TC2, R2, D2> const& rhs);
+
+// Iterator addition
+template <class Derived, class V, class AC, class TC, class R, class D>
+Derived operator+ (iterator_facade<Derived, V, AC, TC, R, D> const&,
+                   typename Derived::difference_type n)
+
+

to:

+
+// Comparison operators
+template <class Dr1, class V1, class TC1, class R1, class D1,
+          class Dr2, class V2, class TC2, class R2, class D2>
+typename enable_if_interoperable<Dr1,Dr2,bool>::type // exposition
+operator ==(iterator_facade<Dr1,V1,TC1,R1,D1> const& lhs,
+            iterator_facade<Dr2,V2,TC2,R2,D2> const& rhs);
+
+template <class Dr1, class V1, class TC1, class R1, class D1,
+          class Dr2, class V2, class TC2, class R2, class D2>
+typename enable_if_interoperable<Dr1,Dr2,bool>::type
+operator !=(iterator_facade<Dr1,V1,TC1,R1,D1> const& lhs,
+            iterator_facade<Dr2,V2,TC2,R2,D2> const& rhs);
+
+template <class Dr1, class V1, class TC1, class R1, class D1,
+          class Dr2, class V2, class TC2, class R2, class D2>
+typename enable_if_interoperable<Dr1,Dr2,bool>::type
+operator <(iterator_facade<Dr1,V1,TC1,R1,D1> const& lhs,
+           iterator_facade<Dr2,V2,TC2,R2,D2> const& rhs);
+
+template <class Dr1, class V1, class TC1, class R1, class D1,
+          class Dr2, class V2, class TC2, class R2, class D2>
+typename enable_if_interoperable<Dr1,Dr2,bool>::type
+operator <=(iterator_facade<Dr1,V1,TC1,R1,D1> const& lhs,
+            iterator_facade<Dr2,V2,TC2,R2,D2> const& rhs);
+
+template <class Dr1, class V1, class TC1, class R1, class D1,
+          class Dr2, class V2, class TC2, class R2, class D2>
+typename enable_if_interoperable<Dr1,Dr2,bool>::type
+operator >(iterator_facade<Dr1,V1,TC1,R1,D1> const& lhs,
+           iterator_facade<Dr2,V2,TC2,R2,D2> const& rhs);
+
+template <class Dr1, class V1, class TC1, class R1, class D1,
+          class Dr2, class V2, class TC2, class R2, class D2>
+typename enable_if_interoperable<Dr1,Dr2,bool>::type
+operator >=(iterator_facade<Dr1,V1,TC1,R1,D1> const& lhs,
+            iterator_facade<Dr2,V2,TC2,R2,D2> const& rhs);
+
+// Iterator difference
+template <class Dr1, class V1, class TC1, class R1, class D1,
+          class Dr2, class V2, class TC2, class R2, class D2>
+/* see below */
+operator-(iterator_facade<Dr1,V1,TC1,R1,D1> const& lhs,
+          iterator_facade<Dr2,V2,TC2,R2,D2> const& rhs);
+
+// Iterator addition
+template <class Dr, class V, class TC, class R, class D>
+Derived operator+ (iterator_facade<Dr,V,TC,R,D> const&,
+                   typename Derived::difference_type n);
+
+template <class Dr, class V, class TC, class R, class D>
+Derived operator+ (typename Derived::difference_type n,
+                   iterator_facade<Dr,V,TC,R,D> const&);
+
+

After the iterator_facade synopsis, add:

+

The iterator_category member of iterator_facade is

+
+iterator-category(CategoryOrTraversal, value_type, reference)
+
+

where iterator-category is defined as follows:

+
+iterator-category(C,R,V) :=
+   if (C is convertible to std::input_iterator_tag
+       || C is convertible to std::output_iterator_tag
+   )
+       return C
+
+   else if (C is not convertible to incrementable_traversal_tag)
+       the program is ill-formed
+
+   else return a type X satisfying the following two constraints:
+
+      1. X is convertible to X1, and not to any more-derived
+         type, where X1 is defined by:
+
+           if (R is a reference type
+               && C is convertible to forward_traversal_tag)
+           {
+               if (C is convertible to random_access_traversal_tag)
+                   X1 = random_access_iterator_tag
+               else if (C is convertible to bidirectional_traversal_tag)
+                   X1 = bidirectional_iterator_tag
+               else
+                   X1 = forward_iterator_tag
+           }
+           else
+           {
+               if (C is convertible to single_pass_traversal_tag
+                   && R is convertible to V)
+                   X1 = input_iterator_tag
+               else
+                   X1 = C
+           }
+
+      2. category-to-traversal(X) is convertible to the most
+         derived traversal tag type to which X is also
+         convertible, and not to any more-derived traversal tag
+         type.
+
+
+
+

In [lib.iterator.facade] iterator_facade requirements:

+

Remove:

+
+AccessCategory must be an unsigned value which uses no more +bits than the greatest value of iterator_access.
+

In the Iterator Adaptor section, change:

+
+Several of the template parameters of iterator_adaptor default +to use_default (or use_default_access).
+

to:

+
+Several of the template parameters of iterator_adaptor default +to use_default.
+

In [lib.iterator.special.adaptors]:

+

Change:

+
+template <
+    class Iterator
+  , class Value = use_default
+  , unsigned Access  = use_default_access
+  , class Traversal  = use_default
+  , class Reference = use_default
+  , class Difference = use_default
+>
+class indirect_iterator
+
+

to:

+
+template <
+    class Iterator
+  , class Value = use_default
+  , class CategoryOrTraversal = use_default
+  , class Reference = use_default
+  , class Difference = use_default
+>
+class indirect_iterator
+
+

Change:

+
+template <
+    class Iterator2, class Value2, unsigned Access2, class Traversal2
+  , class Reference2, class Difference2
+>
+indirect_iterator(
+
+

to:

+
+template <
+    class Iterator2, class Value2, class Category2
+  , class Reference2, class Difference2
+>
+indirect_iterator(
+
+

Change:

+
+template <
+    class Incrementable
+  , unsigned Access = use_default_access
+  , class Traversal = use_default
+  , class Difference = use_default
+>
+class counting_iterator
+
+

to:

+
+template <
+    class Incrementable
+  , class CategoryOrTraversal = use_default
+  , class Difference = use_default
+>
+class counting_iterator
+
+

Change:

+
+typedef iterator_tag<
+      writable_iterator
+    , incrementable_traversal_tag
+> iterator_category;
+
+

to:

+
+typedef std::output_iterator_tag iterator_category;
+

In [lib.iterator.adaptor]

+

Change:

+
+template <
+    class Derived
+  , class Base
+  , class Value      = use_default
+  , unsigned Access  = use_default_access
+  , class Traversal  = use_default
+  , class Reference  = use_default
+  , class Difference = use_default
+>
+class iterator_adaptor 
+
+

To:

+
+template <
+    class Derived
+  , class Base
+  , class Value               = use_default
+  , class CategoryOrTraversal = use_default
+  , class Reference           = use_default
+  , class Difference = use_default
+>
+class iterator_adaptor 
+
+
+ +++ + + + +
Rationale:
+
    +
  1. There are two reasons for removing is_writable +and is_swappable. The first is that we do not know of +a way to fix the specification so that it gives the correct +answer for all iterators. Second, there was only a weak +motivation for having is_writable and is_swappable +there in the first place. The main motivation was simply +uniformity: we have tags for the old iterator categories +so we should have tags for the new iterator categories. +While having tags and the capability to dispatch based +on the traversal categories is often used, we see +less of a need for dispatching based on writability +and swappability, since typically algorithms +that need these capabilities have no alternative if +they are not provided.
    2. +
  2. We discovered that the is_readable trait can be implemented +using only the iterator type itself and its value_type. +Therefore we remove the requirement for is_readable from the +Readable Iterator concept, and change the definition of +is_readable so that it works for any iterator type.
    3. +
  3. The purpose of the iterator_tag class was to bundle the +traversal and access category tags into the +iterator_category typedef. With is_writable and +is_swappable gone, and is_readable no longer in need of +special hints, there is no reason for iterators to provide +information about the access capabilities of an iterator. Thus +there is no need for the iterator_tag. The traversal tag can +be directly used for the iterator_category. If a new +iterator is intended to be backward compatible with old iterator +concepts, a tag type that is convertible to both one of the new +traversal tags and also to an old iterator tag can be created +and use for the iterator_category.
    4. +
  4. The changes to the specification of traversal_category are a +direct result of the removal of iterator_tag.
    5. +
+
+
+

9.16 is_writable_iterator returns false positives

+ +++ + + + + + +
Submitter:Dave Abrahams
Status:New
+

is_writable_iterator returns false positives for forward iterators +whose value_type has a private assignment operator, or whose +reference type is not a reference (currently legal).

+ +++ + + + + +
Proposed Resolution:
 See the resolution to 9.15.
+
+
+

9.17 is_swappable_iterator returns false positives

+ +++ + + + + + +
Submitter:Dave Abrahams
Status:New
+

is_swappable_iterator has the same problems as +is_writable_iterator. In addition, if we allow users to write their +own iter_swap functions it's easy to imagine old-style iterators +for which is_swappable returns false negatives.

+ +++ + + + + +
Proposed Resolution:
 See the resolution to 9.15.
+
+
+

9.18 Are is_readable, is_writable, and is_swappable useful?

+ +++ + + + + + +
Submitter:Dave Abrahams
Status:New
+

I am concerned that there is little use for any of is_readable, +is_writable, or is_swappable, and that not only do they unduly +constrain iterator implementors but they add overhead to +iterator_facade and iterator_adaptor in the form of a template +parameter which would otherwise be unneeded. Since we can't +implement two of them accurately for old-style iterators, I am +having a hard time justifying their impact on the rest of the +proposal(s).

+ +++ + + + + +
Proposed Resolution:
 See the resolution to 9.15.
+
+
+

9.19 Non-Uniformity of the "lvalue_iterator Bit"

+ +++ + + + + + +
Submitter:Dave Abrahams
Status:New
+

The proposed iterator_tag class template accepts an "access bits" +parameter which includes a bit to indicate the iterator's +lvalueness (whether its dereference operator returns a reference to +its value_type. The relevant part of N1550 says:

+
+The purpose of the lvalue_iterator part of the iterator_access +enum is to communicate to iterator_tagwhether the reference type +is an lvalue so that the appropriate old category can be chosen +for the base class. The lvalue_iterator bit is not recorded in +the iterator_tag::access data member.
+

The lvalue_iterator bit is not recorded because N1550 aims to +improve orthogonality of the iterator concepts, and a new-style +iterator's lvalueness is detectable by examining its reference +type. This inside/outside difference is awkward and confusing.

+ +++ + + + + +
Proposed Resolution:
 The iterator_tag class will be removed, so this is no longer an issue. +See the resolution to 9.15.
+
+
+

9.20 Traversal Concepts and Tags

+ +++ + + + + + +
Submitter:Dave Abrahams
Status:New
+

Howard Hinnant pointed out some inconsistencies with the naming of +these tag types:

+
+incrementable_iterator_tag // ++r, r++ 
+single_pass_iterator_tag // adds a == b, a != b 
+forward_traversal_iterator_tag // adds multi-pass 
+bidirectional_traversal_iterator_tag // adds --r, r--
+random_access_traversal_iterator_tag // adds r+n,n+r,etc. 
+
+

Howard thought that it might be better if all tag names contained +the word "traversal". It's not clear that would result in the best +possible names, though. For example, incrementable iterators can +only make a single pass over their input. What really distinguishes +single pass iterators from incrementable iterators is not that they +can make a single pass, but that they are equality +comparable. Forward traversal iterators really distinguish +themselves by introducing multi-pass capability. Without entering +a "Parkinson's Bicycle Shed" type of discussion, it might be worth +giving the names of these tags (and the associated concepts) some +extra attention.

+ +++ + + + + +
Proposed resolution:
 

Change the names of the traversal tags to the +following names:

+
+incrementable_traversal_tag
+single_pass_traversal_tag
+forward_traversal_tag
+bidirectional_traversal_tag
+random_access_traversal_tag
+
+

In [lib.iterator.traversal]:

+

Change:

+
+ +++++ + + + + + + +
traversal_category<X>::typeConvertible to +incrementable_iterator_tag 
+
+

to:

+
+ +++++ + + + + + + +
iterator_traversal<X>::typeConvertible to +incrementable_traversal_tag 
+
+

Change:

+
+ +++++ + + + + + + +
traversal_category<X>::typeConvertible to +single_pass_iterator_tag 
+
+

to:

+
+ +++++ + + + + + + +
iterator_traversal<X>::typeConvertible to +single_pass_traversal_tag 
+
+

Change:

+
+ +++++ + + + + + + +
traversal_category<X>::typeConvertible to +forward_traversal_iterator_tag 
+
+

to:

+
+ +++++ + + + + + + +
iterator_traversal<X>::typeConvertible to +forward_traversal_tag 
+
+

Change:

+
+ +++++ + + + + + + +
traversal_category<X>::typeConvertible to +bidirectional_traversal_iterator_tag 
+
+

to:

+
+ +++++ + + + + + + +
iterator_traversal<X>::typeConvertible to +bidirectional_traversal_tag 
+
+

Change:

+
+ ++++++ + + + + + + + +
traversal_category<X>::typeConvertible to +random_access_traversal_iterator_tag  
+
+

to:

+
+ ++++++ + + + + + + + +
iterator_traversal<X>::typeConvertible to +random_access_traversal_tag  
+
+

In [lib.iterator.synopsis], change:

+
+struct incrementable_iterator_tag { };
+struct single_pass_iterator_tag : incrementable_iterator_tag { };
+struct forward_traversal_tag : single_pass_iterator_tag { };
+
+

to:

+
+struct incrementable_traversal_tag { };
+struct single_pass_traversal_tag : incrementable_traversal_tag { };
+struct forward_traversal_tag : single_pass_traversal_tag { };
+
+

Remove:

+
+struct null_category_tag { };
+struct input_output_iterator_tag : input_iterator_tag, output_iterator_tag {};
+
+
+
+
+

9.21 iterator_facade Derived template argument underspecified

+ +++ + + + + + +
Submitter:Pete Becker
Status:New
+

The first template argument to iterator_facade is named Derived, +and the proposal says:

+
+The Derived template parameter must be a class derived from +iterator_facade.
+

First, iterator_facade is a template, so cannot be derived +from. Rather, the class must be derived from a specialization of +iterator_facade. More important, isn't Derived required to be the +class that is being defined? That is, if I understand it right, the +definition of D here this is not valid:

+
+class C : public iterator_facade<C, ... > { ... }; 
+class D : public iterator_facade<C, ...> { ... }; 
+
+

In the definition of D, the Derived argument to iterator_facade is +a class derived from a specialization of iterator_facade, so the +requirement is met. Shouldn't the requirement be more like "when +using iterator_facade to define an iterator class Iter, the class +Iter must be derived from a specialization of iterator_facade whose +first template argument is Iter." That's a bit awkward, but at the +moment I don't see a better way of phrasing it.

+ +++ + + + + +
Proposed resolution:
 

In [lib.iterator.facade]

+

Remove:

+
+The Derived template parameter must be a class derived from +iterator_facade.
+

Change:

+
+The following table describes the other requirements on the +Derived parameter. Depending on the resulting iterator's +iterator_category, a subset of the expressions listed in the table +are required to be valid. The operations in the first column must be +accessible to member functions of class iterator_core_access.
+

to:

+
+The following table describes the typical valid expressions on +iterator_facade's Derived parameter, depending on the +iterator concept(s) it will model. The operations in the first +column must be made accessible to member functions of class +iterator_core_access. In addition, +static_cast<Derived*>(iterator_facade*) shall be well-formed.
+

In [lib.iterator.adaptor]

+

Change:

+
+The iterator_adaptor is a base class template derived from +an instantiation of iterator_facade.
+

to:

+
+Each specialization of the iterator_adaptor class template +is derived from a specialization of iterator_facade.
+

Change:

+
+The Derived template parameter must be a derived class of +iterator_adaptor.
+

To:

+
+static_cast<Derived*>(iterator_adaptor*) shall be well-formed.
+
+

[Note: The proposed resolution to Issue 9.37 contains related +changes]

+
+
+

9.22 return type of Iterator difference for iterator facade

+ +++ + + + + + +
Submitter:Pete Becker
Status:New
+

The proposal says:

+
+template <class Dr1, class V1, class AC1, class TC1, class R1, class D1, 
+class Dr2, class V2, class AC2, class TC2, class R2, class D2>
+typename enable_if_interoperable<Dr1, Dr2, bool>::type
+operator -(iterator_facade<Dr1, V1, AC1, TC1, R1, D1> const& lhs, 
+iterator_facade<Dr2, V2, AC2, TC2, R2, D2> const& rhs); 
+
+

Shouldn't the return type be one of the two iterator types? Which +one? The idea is that if one of the iterator types can be converted +to the other type, then the subtraction is okay. Seems like the +return type should then be the type that was converted to. Is that +right?

+ +++ + + + + +
Proposed resolution:
 See resolution to 9.34.
+
+
+

9.23 Iterator_facade: minor wording Issue

+ +++ + + + + + +
Submitter:Pete Becker
Status:New
+

In the table that lists the required (sort of) member functions of +iterator types that are based on iterator_facade, the entry for +c.equal(y) says:

+
+true iff c and y refer to the same position. Implements c == y +and c != y. The second sentence is inside out. c.equal(y) does +not implement either of these operations. It is used to implement +them. Same thing in the description of c.distance_to(z).
+ +++ + + + + +
Proposed resolution:
 remove "implements" descriptions from +table. See resolution to 9.34
+
+
+

9.24 Use of undefined name in iterator_facade table

+ +++ + + + + + +
Submitter:Pete Becker
Status:New
+

Several of the descriptions use the name X without defining +it. This seems to be a carryover from the table immediately above +this section, but the text preceding that table says "In the table +below, X is the derived iterator type." Looks like the X:: +qualifiers aren't really needed; X::reference can simply be +reference, since that's defined by the iterator_facade +specialization itself.

+ +++ + + + + +
Proposed resolution:
 

Remove references to X.

+

In [lib.iterator.facade] operations operator->() const;:

+
+

Change:

+
+ +++ + + + +
Returns:

If X::reference is a reference type, an object +of type X::pointer equal to:

+
+&static_cast<Derived const*>(this)->dereference()
+
+

Otherwise returns an object of unspecified type such that, +given an object a of type X, a->m is equivalent +to (w = *a, w.m) for some temporary object w of type +X::value_type.

+

The type X::pointer is Value* if +is_writable_iterator<X>::value is true, and +Value const* otherwise.

+
+
+

to:

+
+ +++ + + + +
Returns:

If reference is a reference type, an object +of type pointer equal to:

+
+&static_cast<Derived const*>(this)->dereference()
+
+

Otherwise returns an object of unspecified type such that, +(*static_cast<Derived const*>(this))->m is equivalent +to (w = **static_cast<Derived const*>(this), w.m) for +some temporary object w of type value_type.

+
+
+

Further changes are covered by issue 9.26.

+
+
+
+
+

9.25 Iterator_facade: wrong return type

+ +++ + + + + + +
Submitter:Pete Becker
Status:New
+

Several of the member functions return a Derived object or a +Derived&. Their Effects clauses end with:

+
+return *this;
+
+

This should be

+
+return *static_cast<Derived*>(this);
+
+ +++ + + + + +
Proposed resolution:
 

In [lib.iterator.facade], in the effects clause +of the following operations:

+
+Derived& operator++()
+Derived& operator--()
+Derived& operator+=(difference_type n)
+Derived& operator-=(difference_type n)
+
+
+
Change:
+
return *this
+
to:
+
return *static_cast<Derived*>(this);
+
+
+
+
+

9.26 Iterator_facade: unclear returns clause for operator[]

+ +++ + + + + + +
Submitter:Pete Becker
Status:New
+

The returns clause for operator[](difference_type n) const +says:

+
+Returns: an object convertible to X::reference and holding a copy +p of a+n such that, for a constant object v of type +X::value_type, X::reference(a[n] = v) is equivalent to p = v. +This needs to define 'a', but assuming it's supposed to be +*this (or maybe *(Derived*)this), it still isn't clear +what this says. Presumably, the idea is that you can index off of +an iterator and assign to the result. But why the requirement +that it hold a copy of a+n? Granted, that's probably how it's +implemented, but it seems over-constrained. And the last phrase +seems wrong. p is an iterator; there's no requirement that you +can assign a value_type object to it. Should that be *p = v? +But why the cast in reference(a[n] = v)?
+ +++ + + + + +
Proposed resolution:
 

In section operator[]:

+
+

Change:

+
+Writable iterators built with iterator_facade implement +the semantics required by the preferred resolution to issue +299 and adopted by proposal n1477: the result of p[n] +is a proxy object containing a copy of p+n, and p[n] = +x is equivalent to *(p + n) = x. This approach will +work properly for any random-access iterator regardless of +the other details of its implementation. A user who knows +more about the implementation of her iterator is free to +implement an operator[] which returns an lvalue in the +derived iterator class; it will hide the one supplied by +iterator_facade from clients of her iterator.
+

to:

+
+Writable iterators built with iterator_facade implement +the semantics required by the preferred resolution to issue +299 and adopted by proposal n1550: the result of p[n] +is an object convertible to the iterator's value_type, +and p[n] = x is equivalent to *(p + n) = x (Note: +This result object may be implemented as a proxy containing a +copy of p+n). This approach will work properly for any +random-access iterator regardless of the other details of its +implementation. A user who knows more about the +implementation of her iterator is free to implement an +operator[] that returns an lvalue in the derived iterator +class; it will hide the one supplied by iterator_facade +from clients of her iterator.
+
+

In [lib.iterator.facade] operations:

+
+

Change:

+
+ +++ + + + +
Returns:an object convertible to X::reference and +holding a copy p of a+n such that, for a constant +object v of type X::value_type, X::reference(a[n] += v) is equivalent to p = v.
+
+

to:

+
+ +++ + + + +
Returns:an object convertible to value_type. For +constant objects v of type value_type, and n of +type difference_type, (*this)[n] = v is equivalent +to *(*this + n) = v, and static_cast<value_type +const&>((*this)[n]) is equivalent to +static_cast<value_type const&>(*(*this + n))
+
+
+
+
+
+

9.27 Iterator_facade: redundant clause

+ +++ + + + + + +
Submitter:Pete Becker
Status:New
+

operator- has both an effects clause and a returns +clause. Looks like the returns clause should be removed.

+ +++ + + + + +
Proposed resolution:
 

Remove the returns clause.

+

In [lib.iterator.facade] operations:

+
+
Remove:
+
+++ + + + +
Returns:static_cast<Derived const*>(this)->advance(-n);
+
+
+
+
+
+

9.28 indirect_iterator: incorrect specification of default constructor

+ +++ + + + + + +
Submitter:Pete Becker
Status:New
+

The default constructor returns "An instance of indirect_iterator +with a default constructed base object", but the constructor that +takes an Iterator object returns "An instance of indirect_iterator +with the iterator_adaptor subobject copy constructed from x." The +latter is the correct form, since it does not reach inside the base +class for its semantics. So the default constructor shoudl return +"An instance of indirect_iterator with a default-constructed +iterator_adaptor subobject."

+ +++ + + + + + + +
Proposed resolution:
 
+
Change:
+
+++ + + + +
Returns:An instance of indirect_iterator with +a default constructed base object.
+
+
to:
+
+++ + + + +
Returns:An instance of indirect_iterator with +a default-constructed m_iterator.
+
+
+
Rationale:Inheritance from iterator_adaptor has been removed, so we instead +give the semantics in terms of the (exposition only) member +m_iterator.
+
+
+

9.29 indirect_iterator: unclear specification of template constructor

+ +++ + + + + + +
Submitter:Pete Becker
Status:New
+

The templated constructor that takes an indirect_iterator with a +different set of template arguments says that it returns "An +instance of indirect_iterator that is a copy of [the argument]". +But the type of the argument is different from the type of the +object being constructed, and there is no description of what +a "copy" means. The Iterator template parameter for the argument +must be convertible to the Iterator template parameter for the type +being constructed, which suggests that the argument's contained +Iterator object should be converted to the target type's Iterator +type. Is that what's meant here? +(Pete later writes: In fact, this problem is present in all of the +specialized adaptors that have a constructor like this: the +constructor returns "a copy" of the argument without saying what a +copy is.)

+ +++ + + + + + + +
Proposed resolution:
 
+
Change:
+
+++ + + + +
Returns:An instance of indirect_iterator that is a copy of y.
+
+
to:
+
+++ + + + +
Returns:An instance of indirect_iterator whose +m_iterator subobject is constructed from y.base().
+
+
+
Rationale:Inheritance from iterator_adaptor has been removed, so we +instead give the semantics in terms of the member m_iterator.
+
+
+

9.30 transform_iterator argument irregularity

+ +++ + + + + + +
Submitter:Pete Becker
Status:New
+

The specialized adaptors that take both a Value and a Reference +template argument all take them in that order, i.e. Value precedes +Reference in the template argument list, with the exception of +transform_iterator, where Reference precedes Value. This seems like +a possible source of confusion. Is there a reason why this order is +preferable?

+ +++ + + + + + + +
Proposed resolution:
 NAD
Rationale:defaults for Value depend on Reference. A sensible +Value can almost always be computed from Reference. The first +parameter is UnaryFunction, so the argument order is already +different from the other adapters.
+
+
+

9.31 function_output_iterator overconstrained

+ +++ + + + + + +
Submitter:Pete Becker
Status:New
+

function_output_iterator requirements says: "The UnaryFunction must +be Assignable, Copy Constructible, and the expression f(x) must be +valid, where f is an object of type UnaryFunction and x is an +object of a type accepted by f."

+

Everything starting with "and," somewhat reworded, is actually a +constraint on output_proxy::operator=. All that's needed to create +a function_output_iterator object is that the UnaryFunction type be +Assignable and CopyConstructible. That's also sufficient to +dereference and to increment such an object. It's only when you try +to assign through a dereferenced iterator that f(x) has to work, +and then only for the particular function object that the iterator +holds and for the particular value that is being assigned.

+
+
Addition from Jeremy:
+
The constructor for function_output_iterator is also +slightly overconstrained because it requires +the UnaryFunction to have a default constructor +even when the default constructor of function_output_iterator +is not used.
+
+ +++ + + + + +
Proposed resolution:
 
+
Change:
+
output_proxy operator*();
+
to:
+
/* see below */ operator*();
+
+

After function_output_iterator& operator++(int); add:

+
+private:
+  UnaryFunction m_f;     // exposition only
+
+
+
Change:
+
The UnaryFunction must be Assignable, Copy Constructible, +and the expression f(x) must be valid, where f is an +object of type UnaryFunction and x is an object of a +type accepted by f. The resulting +function_output_iterator is a model of the Writable and +Incrementable Iterator concepts.
+
to:
+
UnaryFunction must be Assignable and Copy Constructible.
+
+

After the requirements section, add:

+
+
+

function_output_iterator models

+
+function_output_iterator is a model of the Writable and +Incrementable Iterator concepts.
+
+
Change:
+
+++ + + + +
Returns:An instance of function_output_iterator with +f stored as a data member.
+
+
to:
+
+++ + + + +
Effects:Constructs an instance of function_output_iterator +with m_f constructed from f.
+
+
Change:
+

output_proxy operator*();

+ +++ + + + +
Returns:An instance of output_proxy constructed with +a copy of the unary function f.
+
+
to:
+

operator*();

+ +++ + + + +
Returns:An object r of unspecified type such that r = t +is equivalent to m_f(t) for all t.
+
+
Remove:
+

function_output_iterator::output_proxy operations

+

output_proxy(UnaryFunction& f);

+ +++ + + + +
Returns:An instance of output_proxy with f stored as +a data member.
+

template <class T> output_proxy& operator=(const T& value);

+ +++ + + + +
Effects:
+m_f(value); 
+return *this; 
+
+
+
+
+

Change:

+
+explicit function_output_iterator(const UnaryFunction& f = UnaryFunction());
+
+

to:

+
+explicit function_output_iterator();
+
+explicit function_output_iterator(const UnaryFunction& f);
+
+
+
+
+

9.32 Should output_proxy really be a named type?

+ +++ + + + + + +
Submitter:Pete Becker
Status:New
+

This means someone can store an output_proxy object for later use, +whatever that means. It also constrains output_proxy to hold a copy +of the function object, rather than a pointer to the iterator +object. Is all this mechanism really necessary?

+ +++ + + + + +
Proposed resolution:
 See issue 9.31.
+
+
+

9.33 istreambuf_iterator isn't a Readable Iterator

+ +++ + + + + + +
Submitter:Pete Becker
Status:New
+

c++std-lib-12333:

+
+N1550 requires that for a Readable Iterator a of type X, *a +returns an object of type +iterator_traits<X>::reference. istreambuf_iterator::operator* +returns charT, but istreambuf_iterator::reference is +charT&. So am I overlooking something, or is +istreambuf_iterator not Readable.
+ +++ + + + + + + +
Proposed resolution:
 

Remove all constraints on +iterator_traits<X>::reference in Readable Iterator and Lvalue +Iterator. Change Lvalue Iterator to refer to T& instead of +iterator_traits<X>::reference.

+
+
Change:
+
A class or built-in type X models the Readable Iterator +concept for the value type T if the following expressions +are valid and respect the stated semantics. U is the type +of any specified member of type T.
+
to:
+
A class or built-in type X models the Readable Iterator +concept for value type T if, in addition to X being +Assignable and Copy Constructible, the following expressions +are valid and respect the stated semantics. U is the type +of any specified member of type T.
+
+

From the Input Iterator Requirements table, remove:

+
+ +++++ + + + + + + +
iterator_traits<X>::referenceConvertible to +iterator_traits<X>::value_type 
+
+

Change:

+
+ +++++ + + + + + + +
*aiterator_traits<X>::referencepre: a is +dereferenceable. If a +== b then *a is +equivalent to *b
+
+

to:

+
+ +++++ + + + + + + +
*aConvertible to T
+
pre: a is dereferenceable. If a == b then *a
+
is equivalent to *b.
+
+
+
+
+
Change:
+
The Lvalue Iterator concept adds the requirement that the +reference type be a reference to the value type of the +iterator.
+
to:
+
The Lvalue Iterator concept adds the requirement that the +return type of operator* type be a reference to the value +type of the iterator.
+
+

Change:

+
+ +++++ + + + + + + + + + + + + + + +
Lvalue Iterator Requirements
ExpressionReturn TypeAssertion
iterator_traits<X>::referenceT&T is cv +iterator_traits<X>::value_type +where cv is an optional +cv-qualification
+
+

to:

+
+ +++++ + + + + + + + + + + + + + + +
Lvalue Iterator Requirements
ExpressionReturn TypeNote/Assertion
*aT&T is cv +iterator_traits<X>::value_type +where cv is an optional +cv-qualification. +pre: a is +dereferenceable. If a +== b then *a is +equivalent to *b.
+
+

At the end of the section reverse_iterator models, add: +The type iterator_traits<Iterator>::reference must be the type of +*i, where i is an object of type Iterator.

+
Rationale:

Ideally there should be requirements on the reference +type, however, since Readable Iterator is suppose to correspond +to the current standard iterator requirements (which do not place +requirements on the reference type) we will leave them off for +now. There is a DR in process with respect to the reference type +in the stadard iterator requirements. Once that is resolved we +will revisit this issue for Readable Iterator and Lvalue +Iterator.

+

We added Assignable to the requirements for Readable +Iterator. This is needed to have Readable Iterator coincide with +the capabilities of Input Iterator.

+
+
+
+

9.34 iterator_facade free functions unspecified

+ +++ + + + + + +
Submitter:Pete Becker
Status:New
+

c++std-lib-12562:

+
+The template functions operator==, operator!=, +operator<, operator<=, operator>, operator>=, and +operator- that take two arguments that are specializations of +iterator_facade have no specification. The template function +operator+ that takes an argument that is a specialization of +iterator_facade and an argument of type difference_type has no +specification.
+ +++ + + + + +
Proposed resolution:
 

Add the missing specifications.

+
+template <class Dr, class V, class TC, class R, class D>
+Derived operator+ (iterator_facade<Dr,V,TC,R,D> const&,
+                   typename Derived::difference_type n);
+
+template <class Dr, class V, class TC, class R, class D>
+Derived operator+ (typename Derived::difference_type n,
+                   iterator_facade<Dr,V,TC,R,D> const&);
+
+ +++ + + + +
Effects:
+Derived tmp(static_cast<Derived const*>(this));
+return tmp += n;
+
+
+
+template <class Dr1, class V1, class TC1, class R1, class D1,
+          class Dr2, class V2, class TC2, class R2, class D2>
+typename enable_if_interoperable<Dr1,Dr2,bool>::type
+operator ==(iterator_facade<Dr1,V1,TC1,R1,D1> const& lhs,
+            iterator_facade<Dr2,V2,TC2,R2,D2> const& rhs);
+
+ +++ + + + +
Returns:if is_convertible<Dr2,Dr1>::value, then +lhs.equal(rhs). Otherwise, rhs.equal(lhs).
+
+template <class Dr1, class V1, class TC1, class R1, class D1,
+          class Dr2, class V2, class TC2, class R2, class D2>
+typename enable_if_interoperable<Dr1,Dr2,bool>::type
+operator !=(iterator_facade<Dr1,V1,TC1,R1,D1> const& lhs,
+            iterator_facade<Dr2,V2,TC2,R2,D2> const& rhs);
+
+ +++ + + + +
Returns:if is_convertible<Dr2,Dr1>::value, then +!lhs.equal(rhs). Otherwise, !rhs.equal(lhs).
+
+template <class Dr1, class V1, class TC1, class R1, class D1,
+          class Dr2, class V2, class TC2, class R2, class D2>
+typename enable_if_interoperable<Dr1,Dr2,bool>::type
+operator <(iterator_facade<Dr1,V1,TC1,R1,D1> const& lhs,
+           iterator_facade<Dr2,V2,TC2,R2,D2> const& rhs);
+
+ +++ + + + +
Returns:if is_convertible<Dr2,Dr1>::value, then +lhs.distance_to(rhs) < 0. Otherwise, rhs.distance_to(lhs) > +0.
+
+template <class Dr1, class V1, class TC1, class R1, class D1,
+          class Dr2, class V2, class TC2, class R2, class D2>
+typename enable_if_interoperable<Dr1,Dr2,bool>::type
+operator <=(iterator_facade<Dr1,V1,TC1,R1,D1> const& lhs,
+            iterator_facade<Dr2,V2,TC2,R2,D2> const& rhs);
+
+ +++ + + + +
Returns:if is_convertible<Dr2,Dr1>::value, then +lhs.distance_to(rhs) <= 0. Otherwise, rhs.distance_to(lhs) +>= 0.
+
+template <class Dr1, class V1, class TC1, class R1, class D1,
+          class Dr2, class V2, class TC2, class R2, class D2>
+typename enable_if_interoperable<Dr1,Dr2,bool>::type
+operator >(iterator_facade<Dr1,V1,TC1,R1,D1> const& lhs,
+           iterator_facade<Dr2,V2,TC2,R2,D2> const& rhs);
+
+ +++ + + + +
Returns:if is_convertible<Dr2,Dr1>::value, then +lhs.distance_to(rhs) > 0. Otherwise, +rhs.distance_to(lhs) < 0.
+
+template <class Dr1, class V1, class TC1, class R1, class D1,
+          class Dr2, class V2, class TC2, class R2, class D2>
+typename enable_if_interoperable<Dr1,Dr2,bool>::type
+operator >=(iterator_facade<Dr1,V1,TC1,R1,D1> const& lhs,
+            iterator_facade<Dr2,V2,TC2,R2,D2> const& rhs);
+
+ +++ + + + +
Returns:if is_convertible<Dr2,Dr1>::value, then +lhs.distance_to(rhs) >= 0. Otherwise, +rhs.distance_to(lhs) <= 0.
+
+template <class Dr1, class V1, class TC1, class R1, class D1,
+          class Dr2, class V2, class TC2, class R2, class D2>
+typename enable_if_interoperable<Dr1,Dr2,difference>::type
+operator -(iterator_facade<Dr1,V1,TC1,R1,D1> const& lhs,
+           iterator_facade<Dr2,V2,TC2,R2,D2> const& rhs);
+
+ +++ + + + + + +
Return Type:if is_convertible<Dr2,Dr1>::value, then +difference shall be +iterator_traits<Dr1>::difference_type. Otherwise, +difference shall be +iterator_traits<Dr2>::difference_type.
Returns:if is_convertible<Dr2,Dr1>::value, then +-lhs.distance_to(rhs). Otherwise, +rhs.distance_to(lhs).
+
+
+
+

9.35 iterator_facade: too many equals?

+ +++ + + + + + +
Submitter:Pete Becker
Status:New
+

c++std-lib-12563:

+
+

The table listing the functions required for types derived from +iterator_facade has two functions named equal and two named +distance_to:

+
+c.equal(b)
+c.equal(y)
+c.distance_to(b)
+c.distance_to(z)
+
+

where b and c are const objects of the derived type, y and z are +constant objects of certain iterator types that are interoperable +with the derived type. Seems like the 'b' versions are +redundant: in both cases, the other version will take a 'b'. In +fact, iterator_adaptor is specified to use iterator_facade, but +does not provide the 'b' versions of these functions.

+

Are the 'b' versions needed?

+
+ +++ + + + + +
Proposed resolution:
 

Remove the 'b' versions.

+

In iterator_facade requirements, remove:

+
+ ++++++ + + + + + + + +
c.equal(b)convertible to booltrue iff b and c are +equivalent.Single Pass Iterator
+
+

and remove:

+
+ ++++++ + + + + + + + +
c.distance_to(b)convertible to +X::difference_typeequivalent to distance(c, b)Random Access Traversal +Iterator
+
+
+
+
+

9.36 iterator_facade function requirements

+ +++ + + + + + +
Submitter:Pete Becker
Status:New
+

c++std-lib-12636:

+
+

The table that lists required functions for the derived type X +passed to iterator_facade lists, among others:

+

for a single pass iterator:

+
+c.equal(b)
+c.equal(y)
+
+

where b and c are const X objects, and y is a const object of a +single pass iterator that is interoperable with X. Since X is +interoperable with itself, c.equal(b) is redundant. There is a +difference in their descriptions, but its meaning isn't +clear. The first is "true iff b and c are equivalent", and the +second is "true iff c and y refer to the same position." Is there +a difference between the undefined term "equivalent" and "refer +to the same position"?

+

Similarly, for a random access traversal iterator:

+
+c.distance_to(b)
+c.distance_to(z)
+
+

where z is a constant object of a random access traversal +iterator that is interoperable with X. Again, X is interoperable +with itself, so c.distance_to(b) is redundant. Also, the +specification for c.distance_to(z) isn't valid. It's written +as "equivalent to distance(c, z)". The template function distance +takes two arguments of the same type, so distance(c, z) isn't +valid if c and z are different types. Should it be +distance(c, (X)z)?

+
+ +++ + + + + +
Proposed resolution:
 

Removed the 'b' versions (see 9.35) and added the cast.

+

Change:

+
+ ++++++ + + + + + + + +
c.distance_to(z)convertible to +X::difference_typeequivalent to distance(c, z). +Implements c - z, c < z, c +<= z, c > z, and c >= c.Random Access Traversal +Iterator
+
+

to:

+
+ ++++++ + + + + + + + +
c.distance_to(z)convertible to +F::difference_typeequivalent to +distance(c, X(z)).Random Access Traversal +Iterator
+
+
+
+
+
+

More Issues (not from Matt's list)

+
+

9.37x Inheritance in iterator_adaptor and other adaptors is an overspecification

+ +++ + + + + + +
Submitter:Pete Becker
Status:New
+

c++std-lib-12696: +The paper requires that iterator_adaptor be derived from an +appropriate instance of iterator_facade, and that most of the specific +forms of adaptors be derived from appropriate instances of +iterator_adaptor. That seems like overspecification, and we ought to +look at specifying these things in terms of what the various templates +provide rather than how they're implemented.

+ +++ + + + + +
Proposed resolution:
 

Remove the specfication of inheritance, and add explicit +specification of all the functionality that was inherited from the +specialized iterators.

+

In iterator_adaptor, inheritance is retained, sorry NAD. Also, +the Interoperable Iterators concept is added to the new iterator +concepts, and this concept is used in the specification of the +iterator adaptors.

+

In n1550, after [lib.random.access.traversal.iterators], add:

+
+

Interoperable Iterators [lib.interoperable.iterators]

+

A class or built-in type X that models Single Pass Iterator +is interoperable with a class or built-in type Y that +also models Single Pass Iterator if the following expressions +are valid and respect the stated semantics. In the tables +below, x is an object of type X, y is an object of +type Y, Distance is +iterator_traits<Y>::difference_type, and n represents a +constant object of type Distance.

+ +++++ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
ExpressionReturn TypeAssertion/Precondition/Postcondition
y = xYpost: y == x
Y(x)Ypost: Y(x) == x
x == yconvertible to bool== is an equivalence relation over its domain.
y == xconvertible to bool== is an equivalence relation over its domain.
x != yconvertible to boolbool(a==b) != bool(a!=b) over its domain.
y != xconvertible to boolbool(a==b) != bool(a!=b) over its domain.
+

If X and Y both model Random Access Traversal Iterator then +the following additional requirements must be met.

+ ++++++ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
ExpressionReturn TypeOperational SemanticsAssertion/ Precondition
x < yconvertible to booly - x > 0< is a total ordering relation
y < xconvertible to boolx - y > 0< is a total ordering relation
x > yconvertible to booly < x> is a total ordering relation
y > xconvertible to boolx < y> is a total ordering relation
x >= yconvertible to bool!(x < y) 
y >= xconvertible to bool!(y < x) 
x <= yconvertible to bool!(x > y) 
y <= xconvertible to bool!(y > x) 
y - xDistancedistance(Y(x),y)pre: there exists a value n of +Distance such that x + n == y. +y == x + (y - x).
x - yDistancedistance(y,Y(x))pre: there exists a value n of +Distance such that y + n == x. +x == y + (x - y).
+
+

In N1530:

+
+

In [lib.iterator.adaptor]

+

Change:

+
+class iterator_adaptor 
+  : public iterator_facade<Derived, /* see details ...*/>
+
+

To:

+
+class iterator_adaptor 
+  : public iterator_facade<Derived, *V'*, *C'*, *R'*, *D'*> // see details
+
+
+
Change the text from:
+
The Base type must implement the expressions involving +m_iterator in the specifications...
+
until the end of the iterator_adaptor requirements section, to:
+
The Base argument shall be Assignable and Copy Constructible.
+
+

Add:

+
+
+
+

iterator_adaptor base class parameters

+
+

The V', C', R', and D' parameters of the iterator_facade +used as a base class in the summary of iterator_adaptor +above are defined as follows:

+
+V' = if (Value is use_default)
+          return iterator_traits<Base>::value_type
+      else
+          return Value
+
+C' = if (CategoryOrTraversal is use_default)
+          return iterator_traversal<Base>::type
+      else
+          return CategoryOrTraversal
+
+R' = if (Reference is use_default)
+          if (Value is use_default)
+              return iterator_traits<Base>::reference
+          else
+              return Value&
+      else
+          return Reference
+
+D' = if (Difference is use_default)
+          return iterator_traits<Base>::difference_type
+      else
+          return Difference
+
+
+

In [lib.iterator.special.adaptors]

+

Change:

+
+class indirect_iterator
+  : public iterator_adaptor</* see discussion */>
+{
+    friend class iterator_core_access;
+
+

to:

+
+class indirect_iterator
+{
+ public:
+    typedef /* see below */ value_type;
+    typedef /* see below */ reference;
+    typedef /* see below */ pointer;
+    typedef /* see below */ difference_type;
+    typedef /* see below */ iterator_category;
+
+

Change:

+
+private: // as-if specification
+    typename indirect_iterator::reference dereference() const
+    {
+        return **this->base();
+    }
+
+

to:

+
+    Iterator const& base() const;
+    reference operator*() const;
+    indirect_iterator& operator++();
+    indirect_iterator& operator--();
+private:
+   Iterator m_iterator; // exposition
+
+

After the synopsis add:

+
+

The member types of indirect_iterator are defined +according to the following pseudo-code, where V is +iterator_traits<Iterator>::value_type

+
+if (Value is use_default) then
+    typedef remove_const<pointee<V>::type>::type value_type;
+else
+    typedef remove_const<Value>::type value_type;
+
+if (Reference is use_default) then
+    if (Value is use_default) then
+        typedef indirect_reference<V>::type reference;
+    else
+        typedef Value& reference;
+else
+    typedef Reference reference;
+
+if (Value is use_default) then 
+    typedef pointee<V>::type* pointer;
+else 
+    typedef Value* pointer;
+
+if (Difference is use_default)
+    typedef iterator_traits<Iterator>::difference_type difference_type;
+else
+    typedef Difference difference_type;
+
+if (CategoryOrTraversal is use_default)
+    typedef iterator-category(
+        iterator_traversal<Iterator>::type,``reference``,``value_type``
+    ) iterator_category;
+else
+    typedef iterator-category(
+        CategoryOrTraversal,``reference``,``value_type``
+    ) iterator_category;
+
+
+

[Note: See resolution to 9.44y for a description of pointee and +indirect_reference]

+

After the requirements section, add:

+
+
+

indirect_iterator models

+
+

In addition to the concepts indicated by iterator_category +and by iterator_traversal<indirect_iterator>::type, a +specialization of indirect_iterator models the following +concepts, Where v is an object of +iterator_traits<Iterator>::value_type:

+
+
    +
  • Readable Iterator if reference(*v) is convertible to +value_type.
    • +
  • Writable Iterator if reference(*v) = t is a valid +expression (where t is an object of type +indirect_iterator::value_type)
    • +
  • Lvalue Iterator if reference is a reference type.
    • +
+
+

indirect_iterator<X,V1,C1,R1,D1> is interoperable with +indirect_iterator<Y,V2,C2,R2,D2> if and only if X is +interoperable with Y.

+
+

Before indirect_iterator(); add:

+
+In addition to the operations required by the concepts described +above, specializations of indirect_iterator provide the +following operations.
+
+
Change:
+
+++ + + + +
Returns:An instance of indirect_iterator with +the iterator_adaptor subobject copy constructed from x.
+
+
to:
+
+++ + + + +
Returns:An instance of indirect_iterator with +m_iterator copy constructed from x.
+
+
+

At the end of the indirect_iterator operations add:

+
+

Iterator const& base() const;

+ +++ + + + +
Returns:m_iterator
+

reference operator*() const;

+ +++ + + + +
Returns:**m_iterator
+

indirect_iterator& operator++();

+ +++ + + + + + +
Effects:++m_iterator
Returns:*this
+

indirect_iterator& operator--();

+ +++ + + + + + +
Effects:--m_iterator
Returns:*this
+
+

Change:

+
+template <class Iterator>
+class reverse_iterator :
+  public iterator_adaptor< reverse_iterator<Iterator>, Iterator >
+{
+  friend class iterator_core_access;
+
+

to:

+
+template <class Iterator>
+class reverse_iterator
+{
+public:
+  typedef iterator_traits<Iterator>::value_type value_type;
+  typedef iterator_traits<Iterator>::reference reference;
+  typedef iterator_traits<Iterator>::pointer pointer;
+  typedef iterator_traits<Iterator>::difference_type difference_type;
+  typedef /* see below */ iterator_category;
+
+

Change:

+
+private: // as-if specification
+  typename reverse_iterator::reference dereference() const { return *prior(this->base()); }
+
+  void increment() { --this->base_reference(); }
+  void decrement() { ++this->base_reference(); }
+
+  void advance(typename reverse_iterator::difference_type n)
+  {
+      this->base_reference() += -n;
+  }
+
+  template <class OtherIterator>
+  typename reverse_iterator::difference_type
+  distance_to(reverse_iterator<OtherIterator> const& y) const
+  {
+      return this->base_reference() - y.base();
+  }
+
+

to:

+
+  Iterator const& base() const;
+  reference operator*() const;
+  reverse_iterator& operator++();
+  reverse_iterator& operator--();
+private:
+  Iterator m_iterator; // exposition
+
+
+
After the synopsis for reverse_iterator, add:
+
If Iterator models Random Access Traversal Iterator and Readable +Lvalue Iterator, then iterator_category is convertible to +random_access_iterator_tag. Otherwise, if +Iterator models Bidirectional Traversal Iterator and Readable +Lvalue Iterator, then iterator_category is convertible to +bidirectional_iterator_tag. Otherwise, iterator_category is +convertible to input_iterator_tag.
+
Change:
+

reverse_iterator requirements

+

The base Iterator must be a model of Bidirectional Traversal +Iterator. The resulting reverse_iterator will be a model of the +most refined standard traversal and access concepts that are modeled +by Iterator.

+
+
to:
+

reverse_iterator requirements

+

Iterator must be a model of Bidirectional Traversal Iterator.

+
+
+
+
+

reverse_iterator models

+
+

A specialization of reverse_iterator models the same iterator +traversal and iterator access concepts modeled by its Iterator +argument. In addition, it may model old iterator concepts +specified in the following table:

+ ++++ + + + + + + + + + + + + + + + + + + + +
If I modelsthen reverse_iterator<I> models
Readable Lvalue Iterator, +Bidirectional Traversal IteratorBidirectional Iterator
Writable Lvalue Iterator, +Bidirectional Traversal IteratorMutable Bidirectional Iterator
Readable Lvalue Iterator, +Random Access Traversal IteratorRandom Access Iterator
Writable Lvalue Iterator, +Random Access Traversal IteratorMutable Random Access Iterator
+

reverse_iterator<X> is interoperable with +reverse_iterator<Y> if and only if X is interoperable with +Y.

+
+
+
Change:
+
+++ + + + +
Returns:An instance of reverse_iterator with a +default constructed base object.
+
+
to:
+
+++ + + + +
Effects:Constructs an instance of reverse_iterator with m_iterator +default constructed.
+
+
Change:
+
+++ + + + +
Effects:Constructs an instance of reverse_iterator with a +base object copy constructed from x.
+
+
to:
+
+++ + + + +
Effects:Constructs an instance of reverse_iterator with a +m_iterator constructed from x.
+
+
Change:
+
+++ + + + +
Returns:An instance of reverse_iterator that is a copy of r.
+
+
to:
+
+++ + + + +
Effects:Constructs instance of reverse_iterator whose +m_iterator subobject is constructed from y.base().
+
+
At the end of the operations for reverse_iterator, add:
+

Iterator const& base() const;

+ +++ + + + +
Returns:m_iterator
+

reference operator*() const;

+ +++ + + + +
Effects:
+
+Iterator tmp = m_iterator;
+return *--tmp;
+
+

reverse_iterator& operator++();

+ +++ + + + + + +
Effects:--m_iterator
Returns:*this
+

reverse_iterator& operator--();

+ +++ + + + + + +
Effects:++m_iterator
Returns:*this
+
+
+

Change:

+
+class transform_iterator
+  : public iterator_adaptor</* see discussion */>
+{
+  friend class iterator_core_access;
+
+

to:

+
+class transform_iterator
+{
+public:
+  typedef /* see below */ value_type;
+  typedef /* see below */ reference;
+  typedef /* see below */ pointer;
+  typedef iterator_traits<Iterator>::difference_type difference_type;
+  typedef /* see below */ iterator_category;
+
+

After UnaryFunction functor() const; add:

+
+Iterator const& base() const;
+reference operator*() const;
+transform_iterator& operator++();
+transform_iterator& operator--();
+
+

Change:

+
+private:
+  typename transform_iterator::value_type dereference() const;
+  UnaryFunction m_f;
+};
+
+

to:

+
+private:
+  Iterator m_iterator; // exposition only
+  UnaryFunction m_f;   // exposition only
+};
+
+
+
After the synopsis, add:
+
If Iterator models Readable Lvalue Iterator and if Iterator +models Random Access Traversal Iterator, then iterator_category is +convertible to random_access_iterator_tag. Otherwise, if +Iterator models Bidirectional Traversal Iterator, then +iterator_category is convertible to +bidirectional_iterator_tag. Otherwise iterator_category is +convertible to forward_iterator_tag. If Iterator does not +model Readable Lvalue Iterator then iterator_category is +convertible to input_iterator_tag.
+
In the requirements section, change:
+

The type Iterator must at least model Readable Iterator. The +resulting transform_iterator models the most refined of the +following that is also modeled by Iterator.

+
+
    +
  • Writable Lvalue Iterator if +result_of<UnaryFunction(iterator_traits<Iterator>::reference)>::type +is a non-const reference.
    • +
  • Readable Lvalue Iterator if +result_of<UnaryFunction(iterator_traits<Iterator>::reference)>::type +is a const reference.
    • +
  • Readable Iterator otherwise.
    • +
+
+

The transform_iterator models the most refined standard traversal +concept that is modeled by Iterator.

+

The reference type of transform_iterator is +result_of<UnaryFunction(iterator_traits<Iterator>::reference)>::type. +The value_type is remove_cv<remove_reference<reference> >::type.

+
+
to:
+
The argument Iterator shall model Readable Iterator.
+
+

After the requirements section, add:

+
+
+

transform_iterator models

+
+

The resulting transform_iterator models the most refined of the +following options that is also modeled by Iterator.

+
+
    +
  • Writable Lvalue Iterator if +transform_iterator::reference is a non-const +reference.
    • +
  • Readable Lvalue Iterator if +transform_iterator::reference is a const reference.
    • +
  • Readable Iterator otherwise.
    • +
+
+

The transform_iterator models the most refined standard traversal +concept that is modeled by the Iterator argument.

+

If transform_iterator is a model of Readable Lvalue Iterator then +it models the following original iterator concepts depending on what +the Iterator argument models.

+ ++++ + + + + + + + + + + + + + + + + + + + +
If Iterator modelsthen transform_iterator models
Single Pass IteratorInput Iterator
Forward Traversal IteratorForward Iterator
Bidirectional Traversal IteratorBidirectional Iterator
Random Access Traversal IteratorRandom Access Iterator
+

If transform_iterator models Writable Lvalue Iterator then it is a +mutable iterator (as defined in the old iterator requirements).

+

transform_iterator<F1, X, R1, V1> is interoperable with +transform_iterator<F2, Y, R2, V2> if and only if X is +interoperable with Y.

+
+

Remove the private operations section heading and remove:

+
+``typename transform_iterator::value_type dereference() const;``
+
+:Returns: ``m_f(transform_iterator::dereference());``
+
+

After the entry for functor(), add:

+
+``Iterator const& base() const;``
+
+:Returns: ``m_iterator``
+
+
+``reference operator*() const;``
+
+:Returns: ``m_f(*m_iterator)``
+
+
+``transform_iterator& operator++();``
+
+:Effects: ``++m_iterator``
+:Returns: ``*this``
+
+
+``transform_iterator& operator--();``
+
+:Effects: ``--m_iterator``
+:Returns: ``*this``
+
+

Change:

+
+template <class Predicate, class Iterator>
+class filter_iterator
+   : public iterator_adaptor<
+         filter_iterator<Predicate, Iterator>, Iterator
+       , use_default
+       , /* see details */
+     >
+{
+ public:
+
+

to:

+
+template <class Predicate, class Iterator>
+class filter_iterator
+{
+ public:
+   typedef iterator_traits<Iterator>::value_type value_type;
+   typedef iterator_traits<Iterator>::reference reference;
+   typedef iterator_traits<Iterator>::pointer pointer;
+   typedef iterator_traits<Iterator>::difference_type difference_type;
+   typedef /* see below */ iterator_category;
+
+

Change:

+
+private: // as-if specification
+   void increment()
+   {
+       ++(this->base_reference());
+       satisfy_predicate();
+   }
+
+   void satisfy_predicate()
+   {
+       while (this->base() != this->m_end && !this->m_predicate(*this->base()))
+           ++(this->base_reference());
+   }
+
+   Predicate m_predicate;
+   Iterator m_end;
+
+

to:

+
+    Iterator const& base() const;
+    reference operator*() const;
+    filter_iterator& operator++();
+private:
+    Predicate m_pred; // exposition only
+    Iterator m_iter;  // exposition only
+    Iterator m_end;   // exposition only
+
+
+
Change:
+
The base Iterator parameter must be a model of Readable +Iterator and Single Pass Iterator. The resulting +filter_iterator will be a model of Forward Traversal Iterator +if Iterator is, otherwise the filter_iterator will be a +model of Single Pass Iterator. The access category of the +filter_iterator will be the same as the access category of +Iterator.
+
to:
+
The Iterator argument shall meet the requirements of Readable +Iterator and Single Pass Iterator or it shall meet the requirements of +Input Iterator.
+
+

After the requirements section, add:

+
+
+

filter_iterator models

+
+

The concepts that filter_iterator models are dependent on which +concepts the Iterator argument models, as specified in the +following tables.

+ ++++ + + + + + + + + + + + + + +
If Iterator modelsthen filter_iterator models
Single Pass IteratorSingle Pass Iterator
Forward Traversal IteratorForward Traversal Iterator
+ ++++ + + + + + + + + + + + + + + + + +
If Iterator modelsthen filter_iterator models
Readable IteratorReadable Iterator
Writable IteratorWritable Iterator
Lvalue IteratorLvalue Iterator
+ ++++ + + + + + + + + + + + + + + + + +
If Iterator modelsthen filter_iterator models
Readable Iterator, Single Pass IteratorInput Iterator
Readable Lvalue Iterator, Forward Traversal IteratorForward Iterator
Writable Lvalue Iterator, Forward Traversal IteratorMutable Forward Iterator
+

filter_iterator<P1, X> is interoperable with filter_iterator<P2, Y> +if and only if X is interoperable with Y.

+
+
+
Change:
+
+++ + + + +
Returns:a filter_iterator whose +predicate is a default constructed Predicate and +whose end is a default constructed Iterator.
+
+
to:
+
+++ + + + +
Effects:Constructs a filter_iterator whose``m_pred``, m_iter, and m_end +members are a default constructed.
+
+
Change:
+
+++ + + + +
Returns:A filter_iterator at position x that filters according +to predicate f and that will not increment past end.
+
+
to:
+
+++ + + + +
Effects:Constructs a filter_iterator where m_iter is either +the first position in the range [x,end) such that f(*m_iter) == true +or else``m_iter == end``. The member m_pred is constructed from +f and m_end from end.
+
+
Change:
+
+++ + + + +
Returns:A filter_iterator at position x that filters +according to a default constructed Predicate +and that will not increment past end.
+
+
to:
+
+++ + + + +
Effects:Constructs a filter_iterator where m_iter is either +the first position in the range [x,end) such that m_pred(*m_iter) == true +or else``m_iter == end``. The member m_pred is default constructed.
+
+
Change:
+
+++ + + + +
Returns:A copy of iterator t.
+
+
to:
+
+++ + + + +
Effects:Constructs a filter iterator whose members are copied from t.
+
+
Change:
+
+++ + + + +
Returns:A copy of the predicate object used to construct *this.
+
+
to:
+
+++ + + + +
Returns:m_pred
+
+
Change:
+
+++ + + + +
Returns:The object end used to construct *this.
+
+
to:
+
+++ + + + +
Returns:m_end
+
+
+

At the end of the operations section, add:

+
+

reference operator*() const;

+ +++ + + + +
Returns:*m_iter
+

filter_iterator& operator++();

+ +++ + + + + + +
Effects:Increments m_iter and then continues to +increment m_iter until either m_iter == m_end +or m_pred(*m_iter) == true.
Returns:*this
+
+

Change:

+
+class counting_iterator
+  : public iterator_adaptor<
+        counting_iterator<Incrementable, Access, Traversal, Difference>
+      , Incrementable
+      , Incrementable
+      , Access
+      , /* see details for traversal category */
+      , Incrementable const&
+      , Incrementable const*
+      , /* distance = Difference or a signed integral type */>
+{
+    friend class iterator_core_access;
+ public:
+
+

to:

+
+class counting_iterator
+{
+ public:
+    typedef Incrementable value_type;
+    typedef const Incrementable& reference;
+    typedef const Incrementable* pointer;
+    typedef /* see below */ difference_type;
+    typedef /* see below */ iterator_category;
+
+

Change:

+
+private:
+    typename counting_iterator::reference dereference() const
+    {
+        return this->base_reference();
+    }
+
+

to:

+
+    Incrementable const& base() const;
+    reference operator*() const;
+    counting_iterator& operator++();
+    counting_iterator& operator--();
+private:
+    Incrementable m_inc; // exposition
+
+

After the synopsis, add:

+
+

If the Difference argument is use_default then +difference_type is an unspecified signed integral +type. Otherwise difference_type is Difference.

+

iterator_category is determined according to the following +algorithm:

+
+if (CategoryOrTraversal is not use_default)
+    return CategoryOrTraversal
+else if (numeric_limits<Incrementable>::is_specialized)
+    return iterator-category(
+        random_access_traversal_tag, Incrementable, const Incrementable&)
+else
+    return iterator-category(
+         iterator_traversal<Incrementable>::type, 
+         Incrementable, const Incrementable&)
+
+
+
+
Change:
+
+
[Note: implementers are encouraged to provide an implementation of
+
distance_to and a difference_type that avoids overflows in +the cases when the Incrementable type is a numeric type.]
+
+
+
to:
+
+
[Note: implementers are encouraged to provide an implementation of
+
operator- and a difference_type that avoid overflows in +the cases where std::numeric_limits<Incrementable>::is_specialized +is true.]
+
+
+
Change:
+

The Incrementable type must be Default Constructible, Copy +Constructible, and Assignable. The default distance is +an implementation defined signed integegral type.

+

The resulting counting_iterator models Readable Lvalue Iterator.

+
+
to:
+
The Incrementable argument shall be Copy Constructible and Assignable.
+
Change:
+
Furthermore, if you wish to create a counting iterator that is a Forward +Traversal Iterator, then the following expressions must be valid:
+
to:
+
If iterator_category is convertible to forward_iterator_tag +or forward_traversal_tag, the following must be well-formed:
+
Change:
+
If you wish to create a counting iterator that is a +Bidirectional Traversal Iterator, then pre-decrement is also required:
+
to:
+
If iterator_category is convertible to +bidirectional_iterator_tag or bidirectional_traversal_tag, +the following expression must also be well-formed:
+
Change:
+
If you wish to create a counting iterator that is a Random Access +Traversal Iterator, then these additional expressions are also +required:
+
to:
+
If iterator_category is convertible to +random_access_iterator_tag or random_access_traversal_tag, +the following must must also be valid:
+
+

After the requirements section, add:

+
+
+

counting_iterator models

+
+

Specializations of counting_iterator model Readable Lvalue +Iterator. In addition, they model the concepts corresponding to the +iterator tags to which their iterator_category is convertible. +Also, if CategoryOrTraversal is not use_default then +counting_iterator models the concept corresponding to the iterator +tag CategoryOrTraversal. Otherwise, if +numeric_limits<Incrementable>::is_specialized, then +counting_iterator models Random Access Traversal Iterator. +Otherwise, counting_iterator models the same iterator traversal +concepts modeled by Incrementable.

+

counting_iterator<X,C1,D1> is interoperable with +counting_iterator<Y,C2,D2> if and only if X is +interoperable with Y.

+
+

At the begining of the operations section, add:

+
+In addition to the operations required by the concepts modeled by +counting_iterator, counting_iterator provides the following +operations.
+
+
Change:
+
+++ + + + +
Returns:A default constructed instance of counting_iterator.
+
+
to:
+
+++ + + + + + +
Requires:Incrementable is Default Constructible.
Effects:Default construct the member m_inc.
+
+
Change:
+
+++ + + + +
Returns:An instance of counting_iterator that is a copy of rhs.
+
+
to:
+
+++ + + + +
Effects:Construct member m_inc from rhs.m_inc.
+
+
Change:
+
+++ + + + +
Returns:An instance of counting_iterator with its base +object copy constructed from x.
+
+
to:
+
+++ + + + +
Effects:Construct member m_inc from x.
+
+
+

At the end of the operations section, add:

+
+

reference operator*() const;

+ +++ + + + +
Returns:m_inc
+

counting_iterator& operator++();

+ +++ + + + + + +
Effects:++m_inc
Returns:*this
+

counting_iterator& operator--();

+ +++ + + + + + +
Effects:--m_inc
Returns:*this
+

Incrementable const& base() const;

+ +++ + + + +
Returns:m_inc
+
+
+
+
+

9.38x Problem with specification of a->m in Readable Iterator

+ +++ + + + + + +
Submitter:Howard Hinnant
Status:New
+

c++std-lib-12585:

+

Readable Iterator Requirements says:

+
+ +++++ + + + + + + +
a->mU&pre: (*a).m is well-defined. Equivalent to (*a).m
+
+

Do we mean to outlaw iterators with proxy references from meeting +the readable requirements?

+

Would it be better for the requirements to read static_cast<T>(*a).m +instead of (*a).m ?

+ +++ + + + + + + +
Proposed resolution:
 NAD.
Rationale:

We think you're misreading "pre:". +If (*a).m is not well defined, then the iterator is not +required to provide a->m. So a proxy iterator is not +required to provide a->m.

+

As an aside, it is possible for proxy iterators to +support ->, so changing the requirements to +read static_cast<T>(*a).m is interesting. +However, such a change to Readable Iterator would +mean that it no longer corresponds to the +input iterator requirements. So old iterators would not +necessarily conform to new iterator requirements.

+
+
+
+

9.39x counting_iterator Traversal argument unspecified

+ +++ + + + +
Submitter:Pete Becker
+

c++std-lib-12635:

+

counting_iterator takes an argument for its Traversal type, with a +default value of use_default. It is derived from an instance of +iterator_adaptor, where the argument passed for the Traversal type +is described as "/* see details for traversal category +*/". The details for counting_iterator describe constraints on +the Incrementable type imposed by various traversal +categories. There is no description of what the argument to +iterator_adaptor should be.

+ +++ + + + + +
Proposed resolution:
 We no longer inherit from iterator_adaptor. So instead, +we specify the iterator_category in terms of the Traversal type +(which is now called CategoryOrTraversal). Also the +requirements and models section was reorganized to +match these changes and to make more sense.
+
+
+

9.40x indirect_iterator requirements muddled

+ +++ + + + +
Submitter:Pete Becker
+

c++std-lib-12640:

+
+
+The value_type of the Iterator template parameter should itself +be dereferenceable. The return type of the operator* for +the value_type must be the same type as the Reference template +parameter.
+

I'd say this a bit differently, to emphasize what's required: +iterator_traits<Iterator>::value_type must be dereferenceable. +The Reference template parameter must be the same type as +*iterator_traits<Iterator>::value_type().

+
+The Value template parameter will be the value_type for the +indirect_iterator, unless Value is const. If Value is const X, then +value_type will be non- const X.
+

Also non-volatile, right? In other words, if Value isn't use_default, it +just gets passed as the Value argument for iterator_adaptor.

+
+

The default for Value is:

+
+iterator_traits< iterator_traits<Iterator>::value_type >::value_type
+
+

If the default is used for Value, then there must be a valid +specialization of iterator_traits for the value type of the +base iterator.

+
+

The earlier requirement is that +iterator_traits<Iterator>::value_type must be +dereferenceable. Now it's being treated as an iterator. Is this +just a pun, or is iterator_traits<Iterator>::value_type +required to be some form of iterator? If it's the former we need +to find a different way to say it. If it's the latter we need to +say so.

+
+ +++ + + + + + + +
Proposed resolution:
 

Change:

+
+

The value_type of the Iterator template parameter +should itself be dereferenceable. The return type of the +operator* for the value_type must be the same type as +the Reference template parameter. The Value template +parameter will be the value_type for the +indirect_iterator, unless Value is const. If Value +is const X, then value_type will be non- const X. +The default for Value is:

+
+iterator_traits< iterator_traits<Iterator>::value_type >::value_type
+
+

If the default is used for Value, then there must be a +valid specialization of iterator_traits for the value type +of the base iterator.

+

The Reference parameter will be the reference type of the +indirect_iterator. The default is Value&.

+

The Access and Traversal parameters are passed +unchanged to the corresponding parameters of the +iterator_adaptor base class, and the Iterator parameter +is passed unchanged as the Base parameter to the +iterator_adaptor base class.

+
+

to:

+
+
+The expression *v, where v is an object of +iterator_traits<Iterator>::value_type, shall be valid +expression and convertible to reference. Iterator +shall model the traversal concept indicated by +iterator_category. Value, Reference, and +Difference shall be chosen so that value_type, +reference, and difference_type meet the requirements +indicated by iterator_category.
+

[Note: 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 for the value_type member.]

+
+
Rationale:Not included above is the specification of the +value_type, reference, etc., members, which is handled by +the changes in 9.37x.
+
+
+

9.41x Problem with transform_iterator requirements

+ +++ + + + +
Submitter:Pete Becker
+

c++std-lib-12641:

+
+The reference type of transform_iterator is result_of< +UnaryFunction(iterator_traits<Iterator>::reference) +>::type. The value_type is +remove_cv<remove_reference<reference> >::type.
+

These are the defaults, right? If the user supplies their own types +that's what gets passed to iterator_adaptor. And again, the +specification should be in terms of the specialization of +iterator_adaptor, and not in terms of the result:

+

Reference argument to iterator_adaptor:

+
+if (Reference != use_default)
+    Reference
+else
+    result_of<
+        UnaryFunction(iterator_traits<Iterator>::reference)
+    >::type
+
+

Value argument to iterator_adaptor:

+
+if (Value != use_default)
+    Value
+else if (Reference != use_default)
+    remove_reference<reference>::type
+else
+    remove_reference<
+        result_of<
+            UnaryFunction(iterator_traits<Iterator>::reference)
+        >::type
+    >::type
+
+

There's probably a better way to specify that last alternative, but +I've been at this too long, and it's all turning into a maze of +twisty passages, all alike.

+ +++ + + + + +
Proposed resolution:
 

Replace:

+
+The reference type of transform_iterator is result_of< +UnaryFunction(iterator_traits<Iterator>::reference) +>::type. The value_type is +remove_cv<remove_reference<reference> >::type.
+

with:

+
+

If Reference is use_default then the reference +member of transform_iterator is result_of< +UnaryFunction(iterator_traits<Iterator>::reference) +>::type. Otherwise, reference is Reference.

+

If Value is use_default then the value_type +member is remove_cv<remove_reference<reference> >::type. +Otherwise, value_type is Value.

+
+
+
+
+

9.42x filter_iterator details unspecified

+ +++ + + + +
Submitter:Pete Becker
+

c++std-lib-12642:

+

The paper says:

+
+template<class Predicate, class Iterator>
+class filter_iterator
+     : public iterator_adaptor<
+         filter_iterator<Predicate, Iterator>,
+         Iterator,
+         use_default,
+         /* see details */ >
+
+

That comment covers the Access, Traversal, Reference, and Difference +arguments. The only specification for any of these in the details is:

+
+The access category of the filter_iterator will be the same as +the access category of Iterator.
+

Needs more.

+ +++ + + + + +
Proposed resolution:
 

Add to the synopsis:

+
+typedef iterator_traits<Iterator>::value_type value_type;
+typedef iterator_traits<Iterator>::reference reference;
+typedef iterator_traits<Iterator>::pointer pointer;
+typedef iterator_traits<Iterator>::difference_type difference_type;
+typedef /* see below */ iterator_category;
+
+

and add just after the synopsis:

+
+If Iterator models Readable Lvalue Iterator and Forward +Traversal Iterator then iterator_category is convertible +to std::forward_iterator_tag. Otherwise +iterator_category is convertible to +std::input_iterator_tag.
+
+
+
+

9.43x transform_iterator interoperability too restrictive

+ +++ + + + +
Submitter:Jeremy Siek
+

We do not need to require that the function objects have the same +type, just that they be convertible.

+ +++ + + + + +
Proposed resolution:
 

Change:

+
+template<class OtherIterator, class R2, class V2>
+transform_iterator(
+      transform_iterator<UnaryFunction, OtherIterator, R2, V2> const& t
+    , typename enable_if_convertible<OtherIterator, Iterator>::type* = 0 // exposition
+);
+
+

to:

+
+template<class F2, class I2, class R2, class V2>
+transform_iterator(
+      transform_iterator<F2, I2, R2, V2> const& t
+    , typename enable_if_convertible<I2, Iterator>::type* = 0      // exposition only
+    , typename enable_if_convertible<F2, UnaryFunction>::type* = 0 // exposition only
+);
+
+
+
+
+

9.44y indirect_iterator and smart pointers

+ +++ + + + +
Submitter:Dave Abrahams
+

indirect_iterator should be able to iterate over containers of +smart pointers, but the mechanism that allows it was left out of +the specification, even though it's present in the Boost +specification

+ +++ + + + + +
Proposed resolution:
 

Add pointee and indirect_reference +to deal with this capability.

+

In [lib.iterator.helper.synopsis], add:

+
+template <class Dereferenceable>
+struct pointee;
+
+template <class Dereferenceable>
+struct indirect_reference;
+
+

After indirect_iterator's abstract, add:

+
+
+

Class template pointee

+ + + +
+template <class Dereferenceable>
+struct pointee
+{
+    typedef /* see below */ type;
+};
+
+ +++ + + + +
Requires:For an object x of type Dereferenceable, *x +is well-formed. If ++x is ill-formed it shall neither be +ambiguous nor shall it violate access control, and +Dereferenceable::element_type shall be an accessible type. +Otherwise iterator_traits<Dereferenceable>::value_type shall +be well formed. [Note: These requirements need not apply to +explicit or partial specializations of pointee]
+

type is determined according to the following algorithm, where +x is an object of type Dereferenceable:

+
+if ( ++x is ill-formed )
+{
+    return ``Dereferenceable::element_type``
+}
+else if (``*x`` is a mutable reference to
+         std::iterator_traits<Dereferenceable>::value_type)
+{
+    return iterator_traits<Dereferenceable>::value_type
+}
+else
+{
+    return iterator_traits<Dereferenceable>::value_type const
+}
+
+
+
+

Class template indirect_reference

+ + + +
+template <class Dereferenceable>
+struct indirect_reference
+{
+    typedef /* see below */ type;
+};
+
+ +++ + + + +
Requires:For an object x of type Dereferenceable, *x +is well-formed. If ++x is ill-formed it shall neither be +ambiguous nor shall it violate access control, and +pointee<Dereferenceable>::type& shall be well-formed. +Otherwise iterator_traits<Dereferenceable>::reference shall +be well formed. [Note: These requirements need not apply to +explicit or partial specializations of indirect_reference]
+

type is determined according to the following algorithm, where +x is an object of type Dereferenceable:

+
+if ( ++x is ill-formed )
+    return ``pointee<Dereferenceable>::type&``
+else
+    std::iterator_traits<Dereferenceable>::reference
+
+
+

See proposed resolution to Issue 9.37x for more changes related to +this issue.

+
+
+

9.45y N1530: Typos and editorial changes in proposal text (not standardese)

+ +++ + + + +
Submitter:Dave Abrahams
+
    +

  1. "because specification helps to highlight that the Reference +template parameter may not always be identical to the iterator's +reference type, and will keep users making mistakes based on +that assumption."

    + +++ + + + + +
    Proposed resolution:
     

    add "from" before "making"

    +
    +
    2. +

  2. mention of obsolete projection_iterator

    +
    3. +
+
+ +++ + + + + + + +
Proposed Resolution:
 

From n1530, in the Specialized Adaptors section, remove:

+
+projection_iterator, which is similar to transform_iterator +except that when dereferenced it returns a reference instead of +a value.
+
Rationale:This iterator was in the original boost library, but the new +iterator concepts allowed this iterator to be +folded into transform_iterator.
+
+
+
+

9.46y N1530: base() return-by-value is costly

+ +++ + + + +
Submitter:Dave Abrahams
+

We've had some real-life reports that iterators that use +iterator_adaptor's base() function can be inefficient +when the Base iterator is expensive to copy. Iterators, of +all things, should be efficient.

+ +++ + + + + +
Proposed resolution:
 

In [lib.iterator.adaptor]

+

Change:

+
+Base base() const;
+
+

to:

+
+Base const& base() const;
+
+

twice (once in the synopsis and once in the public +operations section).

+
+
+
+

9.47x Forgot default constructible in Forward Traversal Iterator

+ +++ + + + +
Submitter:Jeremy Siek
+

We want Forward Traversal Iterator plus Readable Lvalue Iterator to +match the old Foward Iterator requirements, so we need Forward +Traversal Iterator to include Default Constructible.

+ +++ + + + + +
Proposed resolution:
 

Change:

+
+

A class or built-in type X models the Forward Traversal Iterator +concept if the following expressions are valid and respect the stated +semantics.

+ +++++ + + + + +
Forward Traversal Iterator Requirements (in addition to Single Pass Iterator)
+
+

to:

+
+

A class or built-in type X models the Forward Traversal Iterator +concept if, in addition to X meeting the requirements of +Default Constructible and Single Pass Iterator, the following +expressions are valid and respect the +stated semantics.

+ +++++ + + + + +
Forward Traversal Iterator Requirements (in addition to Default Constructible and Single Pass Iterator)
+
+
+
+
+

9.48x Editorial changes (non-normative text)

+
+
Change:
+
Iterator facade uses the Curiously Recurring Template Pattern (CRTP) +[Cop95] so that the user can specify the behavior of +iterator_facade in a derived class. Former designs used policy +objects to specify the behavior. iterator_facade does not use policy +objects for several reasons:
+
to:
+
Iterator facade uses the Curiously Recurring Template +Pattern (CRTP) [Cop95] so that the user can specify the behavior +of iterator_facade in a derived class. Former designs used +policy objects to specify the behavior, but that approach was +discarded for several reasons:
+
Change:
+
iterator's operator++ returns the iterator type itself means +that all iterators generated by iterator_facade would be +instantiations of iterator_facade. Cumbersome type generator
+
to:
+
iterator's operator++ returns the iterator type itself +would mean that all iterators built with the library would +have to be specializations of iterator_facade<...>, rather +than something more descriptive like +indirect_iterator<T*>. Cumbersome type generator
+
Change:
+
The return type for operator-> and operator[] is not +explicitly specified. Instead it requires each iterator_facade +instantiation to meet the requirements of its iterator_category.
+
To:
+
The return types for iterator_facade's operator-> and +operator[] are not explicitly specified. Instead, those types +are described in terms of a set of requirements, which must be +satisfied by the iterator_facade implementation.
+
+
+
+

9.49x Clarification of iterator_facade requirements and type members

+

A general cleanup and simplification of the requirements and +description of type members for iterator_facade.

+

The user is only allowed to add const as a qualifier.

+
+
Change:
+
typedef remove_cv<Value>::type value_type;
+
to:
+
typedef remove_const<Value>::type value_type;
+
+

We use to have an unspecified type for pointer, to match the +return type of operator->, but there's no real reason to make them +match, so we just use the simpler Value* for pointer.

+

Change:

+
+typedef /* see description of operator-> */ pointer;
+
+
To:
+
typedef Value* pointer;
+
Remove:
+
Some of the constraints on template parameters to +iterator_facade are expressed in terms of resulting nested +types and should be viewed in the context of their impact on +iterator_traits<Derived>.
+
Change:
+
The Derived template parameter must be a class derived from +iterator_facade.
+
and:
+
The following table describes the other requirements on the +Derived parameter. Depending on the resulting iterator's +iterator_category, a subset of the expressions listed in the table +are required to be valid. The operations in the first column must be +accessible to member functions of class iterator_core_access.
+
to:
+
The following table describes the typical valid expressions on +iterator_facade's Derived parameter, depending on the +iterator concept(s) it will model. The operations in the first +column must be made accessible to member functions of class +iterator_core_access. In addition, +static_cast<Derived*>(iterator_facade*) shall be well-formed.
+
Remove:
+

The nested ::value_type type will be the same as +remove_cv<Value>::type, so the Value parameter must be +an (optionally const-qualified) non-reference type.

+

The nested ::reference will be the same as the Reference +parameter; it must be a suitable reference type for the resulting +iterator. The default for the Reference parameter is +Value&.

+
+
+

Change:

+
+

In the table below, X is the derived iterator type, a is an +object of type X, b and c are objects of type const X, +n is an object of X::difference_type, y is a constant +object of a single pass iterator type interoperable with X, and z +is a constant object of a random access traversal iterator type +interoperable with X.

+ ++++++ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
ExpressionReturn TypeAssertion/NoteRequired to implement +Iterator Concept(s)
c.dereference()X::reference Readable Iterator, Writable +Iterator
c.equal(b)convertible to booltrue iff b and c are +equivalent.Single Pass Iterator
c.equal(y)convertible to booltrue iff c and y refer to the +same position. Implements c == y +and c != y.Single Pass Iterator
a.advance(n)unused Random Access Traversal +Iterator
a.increment()unused Incrementable Iterator
a.decrement()unused Bidirectional Traversal +Iterator
c.distance_to(b)convertible to +X::difference_typeequivalent to distance(c, b)Random Access Traversal +Iterator
c.distance_to(z)convertible to +X::difference_typeequivalent to distance(c, z). +Implements c - z, c < z, c +<= z, c > z, and c >= c.Random Access Traversal +Iterator
+
+

to:

+
+

In the table below, F is iterator_facade<X,V,C,R,D>, a is an +object of type X, b and c are objects of type const X, +n is an object of F::difference_type, y is a constant +object of a single pass iterator type interoperable with X, and z +is a constant object of a random access traversal iterator type +interoperable with X.

+

iterator_facade Core Operations

+ ++++++ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
ExpressionReturn TypeAssertion/NoteUsed to implement Iterator +Concept(s)
c.dereference()F::reference Readable Iterator, Writable +Iterator
c.equal(y)convertible to booltrue iff c and y +refer to the same +position.Single Pass Iterator
a.increment()unused Incrementable Iterator
a.decrement()unused Bidirectional Traversal +Iterator
a.advance(n)unused Random Access Traversal +Iterator
c.distance_to(z)convertible to +F::difference_typeequivalent to +distance(c, X(z)).Random Access Traversal +Iterator
+
+
+
+
+
+
+View document source. +Generated by Docutils from reStructuredText source. +
+ + diff --git a/doc/iterator_adaptor_ref.html b/doc/iterator_adaptor_ref.html new file mode 100755 index 0000000..7a9b9b9 --- /dev/null +++ b/doc/iterator_adaptor_ref.html @@ -0,0 +1,230 @@ + + + + + + + + + +
+ + +
+template <
+    class Derived
+  , class Base
+  , class Value        = use_default
+  , class CategoryOrTraversal  = use_default
+  , class Reference  = use_default
+  , class Difference = use_default
+>
+class iterator_adaptor 
+  : public iterator_facade<Derived, V, C, R, D> // see details
+{
+    friend class iterator_core_access;
+ public:
+    iterator_adaptor();
+    explicit iterator_adaptor(Base iter);
+    Base base() const;
+ protected:
+    Base const& base_reference() const;
+    Base& base_reference();
+ private: // Core iterator interface for iterator_facade.  
+    typename iterator_adaptor::reference dereference() const;
+
+    template <
+    class OtherDerived, class OtherIterator, class V, class C, class R, class D
+    >   
+    bool equal(iterator_adaptor<OtherDerived, OtherIterator, V, C, R, D> const& x) const;
+
+    void advance(typename iterator_adaptor::difference_type n);
+    void increment();
+    void decrement();
+
+    template <
+        class OtherDerived, class OtherIterator, class V, class C, class R, class D
+    >   
+    typename iterator_adaptor::difference_type distance_to(
+        iterator_adaptor<OtherDerived, OtherIterator, V, C, R, D> const& y) const;
+
+ private:
+    Base m_iterator; // exposition only
+};
+
+
+

iterator_adaptor base class parameters

+

The V, C, R, and D parameters of the iterator_facade +used as a base class in the summary of iterator_adaptor +above are defined as follows:

+
+V = if (Value is use_default)
+          return iterator_traits<Base>::value_type
+      else
+          return Value
+
+C = if (CategoryOrTraversal is use_default)
+          return iterator_traversal<Base>::type
+      else
+          return CategoryOrTraversal
+
+R = if (Reference is use_default)
+          if (Value is use_default)
+              return iterator_traits<Base>::reference
+          else
+              return Value&
+      else
+          return Reference
+
+D = if (Difference is use_default)
+          return iterator_traits<Base>::difference_type
+      else
+          return Difference
+
+
+
+

iterator_adaptor usage

+

The Derived template parameter must be a publicly derived from +iterator_adaptor. In order for Derived to model the +iterator concepts corresponding to +iterator_traits<Derived>::iterator_category, the expressions +involving m_iterator in the specifications of those private +member functions of iterator_adaptor that may be called by +iterator_facade<Derived, V, C, R, D> +in evaluating any valid expression involving Derived +in those concepts' requirements.

+
+
+

iterator_adaptor public operations

+

iterator_adaptor();

+ +++ + + + + + +
Requires:The Base type must be Default Constructible.
Returns:An instance of iterator_adaptor with +m_iterator default constructed.
+

explicit iterator_adaptor(Base iter);

+ +++ + + + +
Returns:An instance of iterator_adaptor with +m_iterator copy constructed from iter.
+

Base base() const;

+ +++ + + + +
Returns:m_iterator
+
+
+

iterator_adaptor protected member functions

+

Base const& base_reference() const;

+ +++ + + + +
Returns:A const reference to m_iterator.
+

Base& base_reference();

+ +++ + + + +
Returns:A non-const reference to m_iterator.
+
+
+

iterator_adaptor private member functions

+

typename iterator_adaptor::reference dereference() const;

+ +++ + + + +
Returns:*m_iterator
+
+template <
+class OtherDerived, class OtherIterator, class V, class C, class R, class D
+>   
+bool equal(iterator_adaptor<OtherDerived, OtherIterator, V, C, R, D> const& x) const;
+
+ +++ + + + +
Returns:m_iterator == x.base()
+

void advance(typename iterator_adaptor::difference_type n);

+ +++ + + + +
Effects:m_iterator += n;
+

void increment();

+ +++ + + + +
Effects:++m_iterator;
+

void decrement();

+ +++ + + + +
Effects:--m_iterator;
+
+template <
+    class OtherDerived, class OtherIterator, class V, class C, class R, class D
+>   
+typename iterator_adaptor::difference_type distance_to(
+    iterator_adaptor<OtherDerived, OtherIterator, V, C, R, D> const& y) const;
+
+ +++ + + + +
Returns:y.base() - m_iterator
+
+
+
+
+View document source. +Generated on: 2004-01-12 15:25 UTC. +Generated by Docutils from reStructuredText source. +
+ + diff --git a/doc/iterator_concepts.html b/doc/iterator_concepts.html new file mode 100644 index 0000000..7962ff0 --- /dev/null +++ b/doc/iterator_concepts.html @@ -0,0 +1,123 @@ + + + + + + +Iterator Concepts + + + + + + + +
+

Iterator Concepts

+ +++ + + + + + + + + + + + +
Author:David Abrahams, Jeremy Siek, Thomas Witt
Contact:dave@boost-consulting.com, jsiek@osl.iu.edu, witt@styleadvisor.com
Organization:Boost Consulting, Indiana University Open Systems +Lab, Zephyr Associates, Inc.
Date:2004-01-27
Copyright:Copyright David Abrahams, Jeremy Siek, and Thomas Witt 2004. All rights reserved
+ +++ + + + +
abstract:The iterator concept checking classes provide a mechanism for +a template to report better error messages when a user instantiates +the template with a type that does not meet the requirements of +the template.
+

For an introduction to using concept checking classes, see +the documentation for the boost::concept_check library.

+
+

Reference

+ + +
+

iterator_concepts.hpp Synopsis

+
+namespace boost_concepts {
+
+    // Iterator Access Concepts
+
+    template <typename Iterator>
+    class ReadableIteratorConcept;
+
+    template <
+        typename Iterator
+      , typename ValueType = std::iterator_traits<Iterator>::value_type
+    >
+    class WritableIteratorConcept;
+
+    template <typename Iterator>
+    class SwappableIteratorConcept;
+
+    template <typename Iterator>
+    class LvalueIteratorConcept;
+
+    // Iterator Traversal Concepts
+
+    template <typename Iterator>
+    class IncrementableIteratorConcept;
+
+    template <typename Iterator>
+    class SinglePassIteratorConcept;
+
+    template <typename Iterator>
+    class ForwardTraversalConcept;
+
+    template <typename Iterator>
+    class BidirectionalTraversalConcept;
+
+    template <typename Iterator>
+    class RandomAccessTraversalConcept;
+
+    // Interoperability
+
+    template <typename Iterator, typename ConstIterator>
+    class InteroperableIteratorConcept;
+
+}
+
+
+
+
+
+
+View document source. +Generated by Docutils from reStructuredText source. +
+ + diff --git a/doc/iterator_concepts.pdf b/doc/iterator_concepts.pdf new file mode 100755 index 0000000000000000000000000000000000000000..9c9c598f72aa84812b733f5e5833e37583d45bfc GIT binary patch literal 67049 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 + class ReadableIteratorConcept; + + template < + typename Iterator + , typename ValueType = std::iterator_traits::value_type + > + class WritableIteratorConcept; + + template + class SwappableIteratorConcept; + + template + class LvalueIteratorConcept; + + // Iterator Traversal Concepts + + template + class IncrementableIteratorConcept; + + template + class SinglePassIteratorConcept; + + template + class ForwardTraversalConcept; + + template + class BidirectionalTraversalConcept; + + template + class RandomAccessTraversalConcept; + + // Interoperability + + template + class InteroperableIteratorConcept; + + } diff --git a/doc/iterator_traits.html b/doc/iterator_traits.html new file mode 100755 index 0000000..2691867 --- /dev/null +++ b/doc/iterator_traits.html @@ -0,0 +1,120 @@ + + + + + + +Iterator Traits + + + + + + + +
+

Iterator Traits

+ +++ + + + + + + + + + + + +
Author:David Abrahams
Contact:dave@boost-consulting.com
Organization:Boost Consulting
Date:2004-01-13
Copyright:Copyright David Abrahams 2004. All rights reserved
+ +++ + + + +
abstract:Header <boost/iterator/iterator_traits.hpp> provides +the ability to access an iterator's associated types using +MPL-compatible metafunctions.
+
+

Overview

+

std::iterator_traits provides access to five associated types +of any iterator: its value_type, reference, pointer, +iterator_category, and difference_type. Unfortunately, +such a "multi-valued" traits template can be difficult to use in a +metaprogramming context. <boost/iterator/iterator_traits.hpp> +provides access to these types using a standard metafunctions.

+
+
+

Summary

+

Header <boost/iterator/iterator_traits.hpp>:

+
+template <class Iterator>
+struct iterator_value
+{
+    typedef typename 
+      std::iterator_traits<Iterator>::value_type 
+    type;
+};
+
+template <class Iterator>
+struct iterator_reference
+{
+    typedef typename 
+      std::iterator_traits<Iterator>::reference
+    type;
+};
+
+
+template <class Iterator>
+struct iterator_pointer
+{
+    typedef typename 
+      std::iterator_traits<Iterator>::pointer 
+    type;
+};
+
+template <class Iterator>
+struct iterator_difference
+{
+    typedef typename
+      detail::iterator_traits<Iterator>::difference_type
+    type;
+};
+
+template <class Iterator>
+struct iterator_category
+{
+    typedef typename
+      detail::iterator_traits<Iterator>::iterator_category
+    type;
+};
+
+
+
+

Broken Compiler Notes

+

Because of workarounds in Boost, you may find that these +metafunctions actually work better than the facilities provided by +your compiler's standard library.

+

On compilers that don't support partial specialization, such as +Microsoft Visual C++ 6.0 or 7.0, you may need to manually invoke +BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION on the +value_type of pointers that are passed to these metafunctions.

+

Because of bugs in the implementation of GCC-2.9x, the name of +iterator_category is changed to iterator_category_ on that +compiler. A macro, BOOST_ITERATOR_CATEGORY, that expands to +either iterator_category or iterator_category_, as +appropriate to the platform, is provided for portability.

+
+
+
+
+View document source. +Generated by Docutils from reStructuredText source. +
+ + diff --git a/doc/iterator_traits.pdf b/doc/iterator_traits.pdf new file mode 100755 index 0000000000000000000000000000000000000000..d2ce5904d873c6fb211b4cde77ecea896bd437b2 GIT binary patch literal 53847 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 provides + the ability to access an iterator's associated types using + MPL-compatible metafunctions_. + +.. _metafunctions: ../../mpl/doc/index.html#metafunctions + +Overview +======== + +``std::iterator_traits`` provides access to five associated types +of any iterator: its ``value_type``, ``reference``, ``pointer``, +``iterator_category``, and ``difference_type``. Unfortunately, +such a "multi-valued" traits template can be difficult to use in a +metaprogramming context. ```` +provides access to these types using a standard metafunctions_. + +Summary +======= + +Header ````:: + + template + struct iterator_value + { + typedef typename + std::iterator_traits::value_type + type; + }; + + template + struct iterator_reference + { + typedef typename + std::iterator_traits::reference + type; + }; + + + template + struct iterator_pointer + { + typedef typename + std::iterator_traits::pointer + type; + }; + + template + struct iterator_difference + { + typedef typename + detail::iterator_traits::difference_type + type; + }; + + template + struct iterator_category + { + typedef typename + detail::iterator_traits::iterator_category + type; + }; + +Broken Compiler Notes +===================== + +Because of workarounds in Boost, you may find that these +metafunctions_ actually work better than the facilities provided by +your compiler's standard library. + +On compilers that don't support partial specialization, such as +Microsoft Visual C++ 6.0 or 7.0, you may need to manually invoke +BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION_ on the +``value_type`` of pointers that are passed to these metafunctions. + +Because of bugs in the implementation of GCC-2.9x, the name of +``iterator_category`` is changed to ``iterator_category_`` on that +compiler. A macro, ``BOOST_ITERATOR_CATEGORY``, that expands to +either ``iterator_category`` or ``iterator_category_``, as +appropriate to the platform, is provided for portability. + +.. _BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION: ../../type_traits/index.html#transformations + diff --git a/doc/make_filter_iterator.html b/doc/make_filter_iterator.html new file mode 100755 index 0000000..994bd7b --- /dev/null +++ b/doc/make_filter_iterator.html @@ -0,0 +1,53 @@ + + + + + + + + + +
+
+template <class Predicate, class Iterator>
+filter_iterator<Predicate,Iterator>
+make_filter_iterator(Predicate f, Iterator x, Iterator end = Iterator());
+
+ +++ + + + +
Returns:An instance of filter_iterator<Predicate,Iterator> +where m_iter is either the first position in the range [x,end) such that +f(*this->base()) == true or else m_iter == end. +The member m_pred is constructed from f and m_end from end.
+
+template <class Predicate, class Iterator>
+filter_iterator<Predicate,Iterator>
+make_filter_iterator(Iterator x, Iterator end = Iterator());
+
+ +++ + + + +
Returns:An instance of filter_iterator<Predicate,Iterator> +where m_iter is either the first position in the range [x,end) +such that f(*this->base()) == true, where f is a default +constructed Predicate, or else m_iter == end. +The member m_pred is default constructed and m_end +is constructed from end.
+
+
+
+View document source. +Generated on: 2004-01-13 02:57 UTC. +Generated by Docutils from reStructuredText source. +
+ + diff --git a/doc/ref_problem.html b/doc/ref_problem.html new file mode 100755 index 0000000..5cafc68 --- /dev/null +++ b/doc/ref_problem.html @@ -0,0 +1,70 @@ + + + + + + +Problem with reference and old/new iterator category correspondance + + + +
+

Problem with reference and old/new iterator category correspondance

+ +++ + + + + + + + + + + + +
Author:David Abrahams and Jeremy Siek
Contact:dave@boost-consulting.com, jsiek@osl.iu.edu
Organization:Boost Consulting, Indiana University Bloomington
date:$Date$
Copyright:Copyright David Abrahams, Jeremy Siek 2003. 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)
+
+

Introduction

+

The new iterator categories are intended to correspond to the old +iterator categories, as specified in a diagram in N1550. For example, +an iterator categorized as a mutable Forward Iterator under the old +scheme is now a Writable, Lvalue, and Foward Traversal iterator. +However, there is a problem with this correspondance, the new iterator +categories place requirements on the iterator_traits<X>::reference +type whereas the standard iterator requirements say nothing about the +reference type . In particular, the new Readable Iterator +requirements say that the return type of *a must be +iterator_traits<X>::reference and the Lvalue Iterator requirements +says that iterator_traits<X>::reference must be T& or const +T&.

+
+
+

Proposed Resolution

+

Change the standard requirements to match the requirements of the new +iterators. (more details to come)

+
+
+

Rationale

+

The lack of specification in the standard of the reference type is +certainly a defect. Without specification, it is entirely useless in a +generic function. The current practice in the community is generally +to assume there are requirements on the reference type, such as +those proposed in the new iterator categories.

+

There is some danger in adding requirements to existing concepts. +This will mean that some existing iterator types will no longer meet +the iterator requirements. However, we feel that the impact of this is +small enough to warrant going ahead with this change.

+

An alternative solution would be to leave the standard requirements as +is, and to remove the requirements for the reference type in the +new iterator concepts. We are not in favor of this approach because it +extends what we see as a defect further into the future.

+
+
+ + diff --git a/doc/rst2latex b/doc/rst2latex new file mode 100755 index 0000000..795610c --- /dev/null +++ b/doc/rst2latex @@ -0,0 +1,4 @@ +#!/bin/sh +PYTHONPATH="c:/src/docutils/docutils;c:/src/docutils/docutils/extras" +export PYTHONPATH +python c:/src/docutils/docutils/tools/rst2latex.py --documentoptions pdftex --stylesheet=docutils.sty --embed-stylesheet $1 `echo $1 | sed 's/\(.*\)\..*/\1.tex/'` diff --git a/doc/syscmd.py b/doc/syscmd.py new file mode 100644 index 0000000..e6a8dca --- /dev/null +++ b/doc/syscmd.py @@ -0,0 +1,14 @@ +# Copyright David Abrahams 2004. 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) + +import os +import sys + +def syscmd(s): + print 'executing: ', repr(s) + sys.stdout.flush() + err = os.system(s) + if err: + raise SystemError, 'command: %s returned %s' % ( + repr(s), err) diff --git a/index.html b/index.html new file mode 100755 index 0000000..40f1ae1 --- /dev/null +++ b/index.html @@ -0,0 +1,9 @@ + + + + + +Automatically loading index page... if nothing happens, please go to +doc/index.html. + +