2003-08-05 19:48:41 +00:00
<?xml version="1.0" encoding="utf-8" ?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
< html xmlns = "http://www.w3.org/1999/xhtml" xml:lang = "en" lang = "en" >
< head >
< meta http-equiv = "Content-Type" content = "text/html; charset=utf-8" / >
2004-01-13 15:59:47 +00:00
< meta name = "generator" content = "Docutils 0.3.1: http://docutils.sourceforge.net/" / >
2003-08-05 19:48:41 +00:00
< title > Permutation Iterator< / title >
< meta name = "author" content = "Toon Knapen, David Abrahams, Roland Richter, Jeremy Siek" / >
< meta name = "organization" content = "Boost Consulting, Indiana University Open Systems Lab" / >
2004-01-13 02:58:21 +00:00
< meta name = "date" content = "2004-01-13" / >
2003-09-14 02:17:41 +00:00
< meta name = "copyright" content = "Copyright Toon Knapen, David Abrahams, Roland Richter, and Jeremy Siek 2003. All rights reserved" / >
2004-01-12 04:17:26 +00:00
< link rel = "stylesheet" href = "default.css" type = "text/css" / >
2003-08-05 19:48:41 +00:00
< / head >
< body >
< div class = "document" id = "permutation-iterator" >
< h1 class = "title" > Permutation Iterator< / h1 >
< table class = "docinfo" frame = "void" rules = "none" >
< col class = "docinfo-name" / >
< col class = "docinfo-content" / >
< tbody valign = "top" >
< tr > < th class = "docinfo-name" > Author:< / th >
< td > Toon Knapen, David Abrahams, Roland Richter, Jeremy Siek< / td > < / tr >
< tr > < th class = "docinfo-name" > Contact:< / th >
< td > < a class = "first reference" href = "mailto:dave@boost-consulting.com" > dave@ boost-consulting.com< / a > , < a class = "last reference" href = "mailto:jsiek@osl.iu.edu" > jsiek@ osl.iu.edu< / a > < / td > < / tr >
< tr > < th class = "docinfo-name" > Organization:< / th >
< td > < a class = "first reference" href = "http://www.boost-consulting.com" > Boost Consulting< / a > , Indiana University < a class = "last reference" href = "http://www.osl.iu.edu" > Open Systems
Lab< / a > < / td > < / tr >
< tr > < th class = "docinfo-name" > Date:< / th >
2004-01-13 02:58:21 +00:00
< td > 2004-01-13< / td > < / tr >
2003-08-05 19:48:41 +00:00
< tr > < th class = "docinfo-name" > Copyright:< / th >
2003-09-14 02:17:41 +00:00
< td > Copyright Toon Knapen, David Abrahams, Roland Richter, and Jeremy Siek 2003. All rights reserved< / td > < / tr >
2003-08-05 19:48:41 +00:00
< / tbody >
< / table >
< table class = "field-list" frame = "void" rules = "none" >
< col class = "field-name" / >
< col class = "field-body" / >
< tbody valign = "top" >
2004-01-13 02:58:21 +00:00
< tr class = "field" > < th class = "field-name" > abstract:< / th > < td class = "field-body" > The permutation iterator adaptor provides a permuted view of a given
range. That is, the view includes every element of the given range but
in a potentially different order.< / td >
2003-08-05 19:48:41 +00:00
< / tr >
< / tbody >
< / table >
< div class = "contents topic" id = "table-of-contents" >
< p class = "topic-title" > < a name = "table-of-contents" > Table of Contents< / a > < / p >
< ul class = "simple" >
2004-01-13 21:00:31 +00:00
< li > < a class = "reference" href = "#introduction" id = "id2" name = "id2" > Introduction< / a > < / li >
< li > < a class = "reference" href = "#reference" id = "id3" name = "id3" > Reference< / a > < ul >
< li > < a class = "reference" href = "#permutation-iterator-requirements" id = "id4" name = "id4" > < tt class = "literal" > < span class = "pre" > permutation_iterator< / span > < / tt > requirements< / a > < / li >
< li > < a class = "reference" href = "#permutation-iterator-models" id = "id5" name = "id5" > < tt class = "literal" > < span class = "pre" > permutation_iterator< / span > < / tt > models< / a > < / li >
< li > < a class = "reference" href = "#permutation-iterator-operations" id = "id6" name = "id6" > < tt class = "literal" > < span class = "pre" > permutation_iterator< / span > < / tt > operations< / a > < / li >
2003-08-05 19:48:41 +00:00
< / ul >
< / li >
2004-01-13 21:00:31 +00:00
< li > < a class = "reference" href = "#example" id = "id7" name = "id7" > Example< / a > < / li >
2003-08-05 19:48:41 +00:00
< / ul >
< / div >
< div class = "section" id = "introduction" >
2004-01-13 21:00:31 +00:00
< h1 > < a class = "toc-backref" href = "#id2" name = "introduction" > Introduction< / a > < / h1 >
2003-08-05 19:48:41 +00:00
< p > The adaptor takes two arguments:< / p >
< blockquote >
< ul class = "simple" >
< li > an iterator to the range V on which the permutation
will be applied< / li >
< li > the reindexing scheme that defines how the
elements of V will be permuted.< / li >
< / ul >
< / blockquote >
< p > Note that the permutation iterator is not limited to strict
permutations of the given range V. The distance between begin and end
of the reindexing iterators is allowed to be smaller compared to the
size of the range V, in which case the permutation iterator only
provides a permutation of a subrange of V. The indexes neither need
to be unique. In this same context, it must be noted that the past the
end permutation iterator is completely defined by means of the
past-the-end iterator to the indices.< / p >
< / div >
< div class = "section" id = "reference" >
2004-01-13 21:00:31 +00:00
< h1 > < a class = "toc-backref" href = "#id3" name = "reference" > Reference< / a > < / h1 >
2003-08-05 19:48:41 +00:00
< pre class = "literal-block" >
template< class ElementIterator
, class IndexIterator
, class ValueT = use_default
2004-01-12 04:17:26 +00:00
, class CategoryT = use_default
2003-08-05 19:48:41 +00:00
, class ReferenceT = use_default
, class DifferenceT = use_default >
class permutation_iterator
{
public:
permutation_iterator();
explicit permutation_iterator(ElementIterator x, IndexIterator y);
template< class OEIter, class OIIter, class V, class C, class R, class D >
permutation_iterator(
permutation_iterator< OEIter, OIIter, V, C, R, D> const& r
, typename enable_if_convertible< OEIter, ElementIterator> ::type* = 0
, typename enable_if_convertible< OIIter, IndexIterator> ::type* = 0
);
2004-01-13 21:00:31 +00:00
reference operator*() const;
permutation_iterator& operator++();
2004-01-18 20:54:59 +00:00
ElementIterator const& base() const;
2004-01-12 04:17:26 +00:00
private:
2004-01-18 20:54:59 +00:00
ElementIterator m_elt; // exposition only
2004-01-13 21:00:31 +00:00
IndexIterator m_order; // exposition only
2003-08-05 19:48:41 +00:00
};
2004-01-12 04:17:26 +00:00
template < class ElementIterator, class IndexIterator>
permutation_iterator< ElementIterator, IndexIterator>
make_permutation_iterator( ElementIterator e, IndexIterator i);
2003-08-05 19:48:41 +00:00
< / pre >
< div class = "section" id = "permutation-iterator-requirements" >
2004-01-13 21:00:31 +00:00
< h2 > < a class = "toc-backref" href = "#id4" name = "permutation-iterator-requirements" > < tt class = "literal" > < span class = "pre" > permutation_iterator< / span > < / tt > requirements< / a > < / h2 >
< p > < tt class = "literal" > < span class = "pre" > ElementIterator< / span > < / tt > shall model Random Access Traversal Iterator.
< tt class = "literal" > < span class = "pre" > IndexIterator< / span > < / tt > shall model Readable Iterator. The value type of
the < tt class = "literal" > < span class = "pre" > IndexIterator< / span > < / tt > must be convertible to the difference type of
< tt class = "literal" > < span class = "pre" > ElementIterator< / span > < / tt > .< / p >
< / div >
< div class = "section" id = "permutation-iterator-models" >
< h2 > < a class = "toc-backref" href = "#id5" name = "permutation-iterator-models" > < tt class = "literal" > < span class = "pre" > permutation_iterator< / span > < / tt > models< / a > < / h2 >
< p > < tt class = "literal" > < span class = "pre" > permutation_iterator< / span > < / tt > models the same iterator traversal concepts
as < tt class = "literal" > < span class = "pre" > IndexIterator< / span > < / tt > and the same iterator access concepts as
< tt class = "literal" > < span class = "pre" > ElementIterator< / span > < / tt > .< / p >
< p > If < tt class = "literal" > < span class = "pre" > IndexIterator< / span > < / tt > models Single Pass Iterator and
< tt class = "literal" > < span class = "pre" > ElementIterator< / span > < / tt > models Readable Iterator then
< tt class = "literal" > < span class = "pre" > permutation_iterator< / span > < / tt > models Input Iterator.< / p >
< p > If < tt class = "literal" > < span class = "pre" > IndexIterator< / span > < / tt > models Forward Traversal Iterator and
< tt class = "literal" > < span class = "pre" > ElementIterator< / span > < / tt > models Readable Lvalue Iterator then
< tt class = "literal" > < span class = "pre" > permutation_iterator< / span > < / tt > models Forward Iterator.< / p >
< p > If < tt class = "literal" > < span class = "pre" > IndexIterator< / span > < / tt > models Bidirectional Traversal Iterator and
< tt class = "literal" > < span class = "pre" > ElementIterator< / span > < / tt > models Readable Lvalue Iterator then
< tt class = "literal" > < span class = "pre" > permutation_iterator< / span > < / tt > models Bidirectional Iterator.< / p >
< p > If < tt class = "literal" > < span class = "pre" > IndexIterator< / span > < / tt > models Random Access Traversal Iterator and
< tt class = "literal" > < span class = "pre" > ElementIterator< / span > < / tt > models Readable Lvalue Iterator then
< tt class = "literal" > < span class = "pre" > permutation_iterator< / span > < / tt > models Random Access Iterator.< / p >
2004-01-18 20:54:59 +00:00
< p > < tt class = "literal" > < span class = "pre" > permutation_iterator< E1,< / span > < span class = "pre" > X,< / span > < span class = "pre" > V1,< / span > < span class = "pre" > C2,< / span > < span class = "pre" > R1,< / span > < span class = "pre" > D1> < / span > < / tt > is interoperable
with < tt class = "literal" > < span class = "pre" > permutation_iterator< E2,< / span > < span class = "pre" > Y,< / span > < span class = "pre" > V2,< / span > < span class = "pre" > C2,< / span > < span class = "pre" > R2,< / span > < span class = "pre" > D2> < / span > < / tt > if and only if
< tt class = "literal" > < span class = "pre" > X< / span > < / tt > is interoperable with < tt class = "literal" > < span class = "pre" > Y< / span > < / tt > and < tt class = "literal" > < span class = "pre" > E1< / span > < / tt > is convertible
to < tt class = "literal" > < span class = "pre" > E2< / span > < / tt > .< / p >
2003-08-05 19:48:41 +00:00
< / div >
< div class = "section" id = "permutation-iterator-operations" >
2004-01-13 21:00:31 +00:00
< h2 > < a class = "toc-backref" href = "#id6" name = "permutation-iterator-operations" > < tt class = "literal" > < span class = "pre" > permutation_iterator< / span > < / tt > operations< / a > < / h2 >
< p > In addition to those operations required by the concepts that
< tt class = "literal" > < span class = "pre" > permutation_iterator< / span > < / tt > models, < tt class = "literal" > < span class = "pre" > permutation_iterator< / span > < / tt > provides the
following operations.< / p >
< p > < tt class = "literal" > < span class = "pre" > permutation_iterator();< / span > < / tt > < / p >
< table class = "field-list" frame = "void" rules = "none" >
< col class = "field-name" / >
< col class = "field-body" / >
< tbody valign = "top" >
2004-01-18 20:54:59 +00:00
< tr class = "field" > < th class = "field-name" > Effects:< / th > < td class = "field-body" > Default constructs < tt class = "literal" > < span class = "pre" > m_elt< / span > < / tt > and < tt class = "literal" > < span class = "pre" > m_order< / span > < / tt > .< / td >
2004-01-13 21:00:31 +00:00
< / tr >
< / tbody >
< / table >
< p > < tt class = "literal" > < span class = "pre" > explicit< / span > < span class = "pre" > permutation_iterator(ElementIterator< / span > < span class = "pre" > x,< / span > < span class = "pre" > IndexIterator< / span > < span class = "pre" > y);< / span > < / tt > < / p >
< table class = "field-list" frame = "void" rules = "none" >
< col class = "field-name" / >
< col class = "field-body" / >
< tbody valign = "top" >
2004-01-18 20:54:59 +00:00
< tr class = "field" > < th class = "field-name" > Effects:< / th > < td class = "field-body" > Constructs < tt class = "literal" > < span class = "pre" > m_elt< / span > < / tt > from < tt class = "literal" > < span class = "pre" > x< / span > < / tt > and < tt class = "literal" > < span class = "pre" > m_order< / span > < / tt > from < tt class = "literal" > < span class = "pre" > y< / span > < / tt > .< / td >
2004-01-13 21:00:31 +00:00
< / tr >
< / tbody >
< / table >
2004-01-12 04:17:26 +00:00
< pre class = "literal-block" >
2004-01-13 21:00:31 +00:00
template< class OEIter, class OIIter, class V, class C, class R, class D >
permutation_iterator(
permutation_iterator< OEIter, OIIter, V, C, R, D> const& r
, typename enable_if_convertible< OEIter, ElementIterator> ::type* = 0
, typename enable_if_convertible< OIIter, IndexIterator> ::type* = 0
);
2004-01-12 04:17:26 +00:00
< / pre >
< table class = "field-list" frame = "void" rules = "none" >
< col class = "field-name" / >
< col class = "field-body" / >
< tbody valign = "top" >
2004-01-18 20:54:59 +00:00
< tr class = "field" > < th class = "field-name" > Effects:< / th > < td class = "field-body" > Constructs < tt class = "literal" > < span class = "pre" > m_elt< / span > < / tt > from < tt class = "literal" > < span class = "pre" > r.m_elt< / span > < / tt > and
2004-01-13 21:00:31 +00:00
< tt class = "literal" > < span class = "pre" > m_order< / span > < / tt > from < tt class = "literal" > < span class = "pre" > y.m_order< / span > < / tt > .< / td >
< / tr >
< / tbody >
< / table >
< p > < tt class = "literal" > < span class = "pre" > reference< / span > < span class = "pre" > operator*()< / span > < span class = "pre" > const;< / span > < / tt > < / p >
< table class = "field-list" frame = "void" rules = "none" >
< col class = "field-name" / >
< col class = "field-body" / >
< tbody valign = "top" >
2004-01-18 20:54:59 +00:00
< tr class = "field" > < th class = "field-name" > Returns:< / th > < td class = "field-body" > < tt class = "literal" > < span class = "pre" > *(m_elt< / span > < span class = "pre" > +< / span > < span class = "pre" > *m_order)< / span > < / tt > < / td >
2004-01-13 21:00:31 +00:00
< / tr >
< / tbody >
< / table >
< p > < tt class = "literal" > < span class = "pre" > permutation_iterator& < / span > < span class = "pre" > operator++();< / span > < / tt > < / p >
< table class = "field-list" frame = "void" rules = "none" >
< col class = "field-name" / >
< col class = "field-body" / >
< tbody valign = "top" >
< tr class = "field" > < th class = "field-name" > Effects:< / th > < td class = "field-body" > < tt class = "literal" > < span class = "pre" > ++m_order< / span > < / tt > < / td >
< / tr >
< tr class = "field" > < th class = "field-name" > Returns:< / th > < td class = "field-body" > < tt class = "literal" > < span class = "pre" > *this< / span > < / tt > < / td >
2004-01-12 04:17:26 +00:00
< / tr >
< / tbody >
< / table >
2004-01-18 20:54:59 +00:00
< p > < tt class = "literal" > < span class = "pre" > ElementIterator< / span > < span class = "pre" > const& < / span > < span class = "pre" > base()< / span > < span class = "pre" > const;< / span > < / tt > < / p >
2004-01-12 04:17:26 +00:00
< table class = "field-list" frame = "void" rules = "none" >
< col class = "field-name" / >
< col class = "field-body" / >
< tbody valign = "top" >
2004-01-18 20:54:59 +00:00
< tr class = "field" > < th class = "field-name" > Returns:< / th > < td class = "field-body" > < tt class = "literal" > < span class = "pre" > m_order< / span > < / tt > < / td >
2004-01-12 04:17:26 +00:00
< / tr >
< / tbody >
< / table >
2004-01-13 21:00:31 +00:00
< pre class = "literal-block" >
template < class ElementIterator, class IndexIterator>
permutation_iterator< ElementIterator, IndexIterator>
make_permutation_iterator(ElementIterator e, IndexIterator i);
< / pre >
< table class = "field-list" frame = "void" rules = "none" >
< col class = "field-name" / >
< col class = "field-body" / >
< tbody valign = "top" >
< tr class = "field" > < th class = "field-name" > Returns:< / th > < td class = "field-body" > < tt class = "literal" > < span class = "pre" > permutation_iterator< ElementIterator,< / span > < span class = "pre" > IndexIterator> (e,< / span > < span class = "pre" > i)< / span > < / tt > < / td >
< / tr >
< / tbody >
< / table >
2003-08-05 19:48:41 +00:00
< / div >
< / div >
2004-01-12 04:17:26 +00:00
< div class = "section" id = "example" >
2004-01-13 21:00:31 +00:00
< h1 > < a class = "toc-backref" href = "#id7" name = "example" > Example< / a > < / h1 >
2004-01-12 04:17:26 +00:00
< pre class = "literal-block" >
using namespace boost;
int i = 0;
typedef std::vector< int > element_range_type;
typedef std::list< int > index_type;
static const int element_range_size = 10;
static const int index_size = 4;
element_range_type elements( element_range_size );
for(element_range_type::iterator el_it = elements.begin() ; el_it != elements.end() ; ++el_it)
*el_it = std::distance(elements.begin(), el_it);
index_type indices( index_size );
for(index_type::iterator i_it = indices.begin() ; i_it != indices.end() ; ++i_it )
*i_it = element_range_size - index_size + std::distance(indices.begin(), i_it);
std::reverse( indices.begin(), indices.end() );
typedef permutation_iterator< element_range_type::iterator, index_type::iterator > permutation_type;
permutation_type begin = make_permutation_iterator( elements.begin(), indices.begin() );
permutation_type it = begin;
permutation_type end = make_permutation_iterator( elements.begin(), indices.end() );
std::cout < < " The original range is : " ;
std::copy( elements.begin(), elements.end(), std::ostream_iterator< int > ( std::cout, " " ) );
std::cout < < " \n" ;
std::cout < < " The reindexing scheme is : " ;
std::copy( indices.begin(), indices.end(), std::ostream_iterator< int > ( std::cout, " " ) );
std::cout < < " \n" ;
std::cout < < " The permutated range is : " ;
std::copy( begin, end, std::ostream_iterator< int > ( std::cout, " " ) );
std::cout < < " \n" ;
std::cout < < " Elements at even indices in the permutation : " ;
it = begin;
for(i = 0; i < index_size / 2 ; ++i, it+=2 ) std::cout < < *it < < " " ;
std::cout < < " \n" ;
std::cout < < " Permutation backwards : " ;
it = begin + (index_size);
assert( it != begin );
for( ; it-- != begin ; ) std::cout < < *it < < " " ;
std::cout < < " \n" ;
std::cout < < " Iterate backward with stride 2 : " ;
it = begin + (index_size - 1);
for(i = 0 ; i < index_size / 2 ; ++i, it-=2 ) std::cout < < *it < < " " ;
std::cout < < " \n" ;
< / pre >
< p > The output is:< / p >
< pre class = "literal-block" >
The original range is : 0 1 2 3 4 5 6 7 8 9
The reindexing scheme is : 9 8 7 6
The permutated range is : 9 8 7 6
Elements at even indices in the permutation : 9 7
Permutation backwards : 6 7 8 9
Iterate backward with stride 2 : 6 8
< / pre >
2004-01-12 16:10:29 +00:00
< p > The source code for this example can be found < a class = "reference" href = "../example/permutation_iterator_example.cpp" > here< / a > .< / p >
2003-08-05 19:48:41 +00:00
< / div >
2004-01-12 02:49:55 +00:00
< / div >
2004-01-13 15:59:47 +00:00
< hr class = "footer" / >
2004-01-12 15:26:20 +00:00
< div class = "footer" >
< a class = "reference" href = "permutation_iterator.rst" > View document source< / a > .
Generated by < a class = "reference" href = "http://docutils.sourceforge.net/" > Docutils< / a > from < a class = "reference" href = "http://docutils.sourceforge.net/rst.html" > reStructuredText< / a > source.
< / div >
2003-08-05 19:48:41 +00:00
< / body >
< / html >
