|  | Home | Libraries | People | FAQ | More | 
            The template compare_iterators
            is a type used as an attribute customization point. It is invoked by
            the Karma repetitive generators (such as List
            (%), Kleene
            (unary *), Plus (unary +), and Repeat)
            in order to compare the current iterator (returned either from traits::begin_container or from traits::next_iterator) with the end
            iterator (returned from traits::end_container) in order to find
            the end of the element sequence to generate output for.
          
#include <boost/spirit/home/support/container.hpp>
Also, see Include Structure.
| ![[Note]](../../../../images/note.png) | Note | 
|---|---|
| This header file does not need to be included directly by any user program as it is normally included by other Spirit header files relying on its content. | 
| Name | 
|---|
| 
                       | 
template <typename Iterator, typename Enable> struct compare_iterators { static bool call(Iterator const& it1, Iterator const& it2); };
| Parameter | Description | Default | 
|---|---|---|
| 
                       | 
                      The type,  | none | 
| 
                       | 
                      Helper template parameter usable to selectively enable or disable
                      certain specializations of  | 
                       | 
Notation
IteratorAn iterator type.
it1, it2
                  Instances of an iterator of type Iterator.
                
C
                  A container type whose iterator type is Iterator.
                
| Expression | Semantics | 
|---|---|
| 
                       | 
                      Returns whether the iterators  | 
            Spirit predefines specializations
            of this customization point for several types. The following table lists
            those types together with the types returned by the embedded typedef
            type:
          
| Template Parameters | Semantics | 
|---|---|
| 
                       | 
                      The function  | 
| 
                       | 
                      The function  | 
            The customization point compare_iterators
            needs to be implemented for a specific iterator type whenever the container
            this iterator belongs to is to be used as an attribute in place of a
            STL container. It is applicable for generators (Spirit.Karma)
            only. As a rule of thumb: it has to be implemented whenever a certain
            iterator type belongs to a container which is to be passed as an attribute
            to a generator normally exposing a STL container, C
            and if the container type does not expose the interface of a STL container
            (i.e. is_container<C>::type would normally return mpl::false_).
          
If this customization point is implemented, the following other customization points might need to be implemented as well.
| Name | When to implement | 
|---|---|
| Needs to be implemented whenever a type is to be used as a container attribute in Karma. | |
| 
                      Karma: List
                      ( | |
| 
                      Karma: List
                      ( | |
| 
                      Karma: List
                      ( | |
| 
                      Karma: List
                      ( | |
| 
                      Karma: List
                      ( | |
| 
                      Karma: List
                      ( | 
            For an example of how to use the customization point compare_iterators
            please see here: use_as_container.