From 9189d5bd60004e843ca204940d5c759e8fd26df6 Mon Sep 17 00:00:00 2001 From: Jeremy Siek Date: Mon, 28 Apr 2003 01:44:05 +0000 Subject: [PATCH] checking in what I've got so far [SVN r1228] --- doc/facade-and-adaptor.rst | 164 +++++++++++++++++++++++++++++++++++-- 1 file changed, 157 insertions(+), 7 deletions(-) diff --git a/doc/facade-and-adaptor.rst b/doc/facade-and-adaptor.rst index 610d5dd..90e7479 100755 --- a/doc/facade-and-adaptor.rst +++ b/doc/facade-and-adaptor.rst @@ -1246,8 +1246,12 @@ model of Forward Traversal Iterator if ``Iterator`` is, otherwise the access category of the ``filter_iterator`` will be the most refined standard access category that is modeled by ``Iterator``. -The ``Predicate`` must be an Assignable, Copy Constructible type also -with the valid expression ``p(x)`` where ``p`` is an object of type +.. Thomas is going to try implementing filter_iterator so that + it will be bidirectional if the underlying iterator is. -JGS + + +The ``Predicate`` 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::value_type``, and where the type of ``p(x)`` must be convertible to ``bool``. @@ -1304,6 +1308,10 @@ with the valid expression ``p(x)`` where ``p`` is an object of type Counting iterator ----------------- +The counting iterator adaptor implements dereference by returning the +current value of the base object. The other operations are implemented +by the base object, as per the inheritance from ``iterator_adaptor``. + Class template ``counting_iterator`` .................................... @@ -1312,7 +1320,14 @@ Class template ``counting_iterator`` template class counting_iterator - : public iterator_adaptor + : public iterator_adaptor< + counting_iterator + , Incrementable + , Incrementable + , /* see details for category */ + , Incrementable const& + , Incrementable const* + , /* see details for difference */> { typedef iterator_adaptor super_t; friend class iterator_core_access; @@ -1320,7 +1335,86 @@ Class template ``counting_iterator`` counting_iterator(); counting_iterator(counting_iterator const& rhs); counting_iterator(Incrementable x); - }; + private: + + typename super_t::reference dereference() const + { + return this->base_reference(); + } + + // Why is this complicated? Why not let the default impl handle this? -JGS + template + difference_type + distance_to(counting_iterator const& y) const + { + typedef typename mpl::if_< + detail::is_numeric + , detail::number_distance + , detail::iterator_distance + >::type d; + + return d::distance(this->base(), y.base()); + } + }; + +``counting_iterator`` requirements +---------------------------------- + +The ``Incrementable`` type must be Default Constructible, Copy +Constructible, and Assignable. Also, the ``Incrementable`` type must +provide access to an associated ``difference_type`` and +``iterator_category`` through the ``counting_iterator_traits`` class. + +The resulting ``counting_iterator`` models Readable Lvalue Iterator. + +Furthermore, if you wish to create a counting iterator that is a Forward +Traversal Iterator, then the following expressions must be valid: +:: + + Incrementable i, j; + ++i // pre-increment + i == j // operator equal + +If you wish to create a counting iterator that is a +Bidirectional Traversal Iterator, then pre-decrement is also required: +:: + + --i + +If you wish to create a counting iterator that is a Random Access +Traversal Iterator, then these additional expressions are also +required: +:: + + counting_iterator_traits::difference_type n; + i += n + n = i - j + i < j + + + + +``counting_iterator`` operations +-------------------------------- + +``counting_iterator();`` + +:Returns: A default constructed instance of ``counting_iterator``. + + +``counting_iterator(counting_iterator const& rhs);`` + +:Returns: An instance of ``counting_iterator`` that is a copy of ``rhs``. + +.. Why isn't this constructor templated and use + enable_if_interoperable like the rest? That version + was ifdef'd out in the impl. Why? -JGS + + +``counting_iterator(Incrementable x);`` + +:Returns: An instance of ``counting_iterator`` with its base + object copy constructed from ``x``. Function output iterator @@ -1343,14 +1437,16 @@ Class template ``function_output_iterator`` template class function_output_iterator { public: - typedef std::output_iterator_tag iterator_category; + typedef iterator_tag< + writable_iterator_tag + , incrementable_iterator_tag + > iterator_category; typedef void value_type; typedef void difference_type; typedef void pointer; typedef void reference; - explicit function_output_iterator(const UnaryFunction& f = UnaryFunction()) - : m_f(f) {} + explicit function_output_iterator(const UnaryFunction& f = UnaryFunction()); struct output_proxy { output_proxy(UnaryFunction& f); @@ -1362,5 +1458,59 @@ Class template ``function_output_iterator`` }; +``function_output_iterator`` requirements +----------------------------------------- + +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. + + +``function_output_iterator`` operations +--------------------------------------- + +``explicit function_output_iterator(const UnaryFunction& f = UnaryFunction());`` + +:Returns: An instance of ``function_output_iterator`` with + ``f`` stored as a data member. + + +``output_proxy operator*();`` + +:Returns: An instance of ``output_proxy`` constructed with + a copy of the unary function ``f``. + + +``function_output_iterator& operator++();`` + +:Returns: ``*this`` + + +``function_output_iterator& operator++(int);`` + +:Returns: ``*this`` + + +``function_output_iterator::output_proxy`` operations +----------------------------------------------------- + +``output_proxy(UnaryFunction& f);`` + +:Returns: An instance of ``output_proxy`` with ``f`` stored as + a data member. + + +``template output_proxy& operator=(const T& value);`` + +:Effects: + :: + + m_f(value); + return *this; + + + .. [Cop95] [Coplien, 1995] Coplien, J., Curiously Recurring Template Patterns, C++ Report, February 1995, pp. 24-27.