TriaRawIterator< Accessor > Class Template Reference
[Grid classesIterators on mesh-like containers]

Inheritance diagram for TriaRawIterator< Accessor >:

Inheritance graph
[legend]

List of all members.

Classes

class  ExcAdvanceInvalidObject
class  ExcDereferenceInvalidCell
class  ExcDereferenceInvalidObject
class  ExcInvalidComparison

Public Types

typedef Accessor AccessorType

Public Member Functions

 TriaRawIterator ()
 TriaRawIterator (const TriaRawIterator &)
 TriaRawIterator (const Accessor &a)
template<typename OtherAccessor >
 TriaRawIterator (const OtherAccessor &a)
 TriaRawIterator (const Triangulation< Accessor::dimension, Accessor::space_dimension > *parent, const int level, const int index, const typename AccessorType::AccessorData *local_data=0)
template<typename OtherAccessor >
 TriaRawIterator (const TriaRawIterator< OtherAccessor > &i)
template<typename OtherAccessor >
 TriaRawIterator (const TriaIterator< OtherAccessor > &i)
template<typename OtherAccessor >
 TriaRawIterator (const TriaActiveIterator< OtherAccessor > &i)
TriaRawIteratoroperator= (const TriaRawIterator &)
bool operator== (const TriaRawIterator &) const
bool operator!= (const TriaRawIterator &) const
bool operator< (const TriaRawIterator &) const
IteratorState::IteratorStates state () const
void print (std::ostream &out) const
unsigned int memory_consumption () const
Dereferencing
const Accessor & operator* () const
Accessor & operator* ()
const Accessor * operator-> () const
Accessor * operator-> ()
Advancement of iterators
TriaRawIteratoroperator++ ()
TriaRawIterator operator++ (int)
TriaRawIteratoroperator-- ()
TriaRawIterator operator-- (int)

Protected Attributes

Accessor accessor

Friends

class TriaRawIterator
class TriaIterator
class TriaActiveIterator


Detailed Description

template<typename Accessor>
class TriaRawIterator< Accessor >

This class implements an iterator, analogous to those of the standard template library (STL). It fulfills the requirements of a bidirectional iterator. See the C++ documentation for further details of iterator specification and usage.

In addition to the STL iterators an iterator of this class provides a -> operator, i.e. you can write statements like

 i->set_refine_flag ();

Iterators are used whenever a loop over all lines, quads, cells etc. is to be performed. These loops can then be coded like this:

   cell_iterator i   = tria.begin();
   cell_iterator end = tria.end();
   for (; i!=end; ++i)
     if (cell->at_boundary())
       cell->set_refine_flag();

Note the usage of ++i instead of i++ since this does not involve temporaries and copying. It is recommended to use a fixed value end inside the loop instead of tria.end(), since the creation and copying of these iterators is rather expensive compared to normal pointers.

The objects pointed to are accessors, derived from TriaAccessorBase. Which kind of accessor is determined by the template argument Accessor. These accessors are not so much data structures as they are a collection of functions providing access to the data stored in Tringulation or DoFHandler objects. Using these accessors, the structure of these classes is hidden from the application program.

Which iterator to use when

Attention:
Application programs will rarely use TriaRawIterator, but rather one of the derived classes TriaIterator or TriaActiveIterator.

Purpose

Iterators are not much slower than operating directly on the data structures, since they perform the loops that you had to handcode yourself anyway. Most iterator and accessor functions are inlined.

The main functionality of iterators, resides in the ++ and -- operators. These move the iterator forward or backward just as if it were a pointer into an array. Here, this operation is not so easy, since it may include skipping some elements and the transition between the triangulation levels. This is completely hidden from the user, though you can still create an iterator pointing to an arbitrary element. Actually, the operation of moving iterators back and forth is not done in the iterator classes, but rather in the accessor classes. Since these are passed as template arguments, you can write your own versions here to add more functionality.

Furthermore, the iterators decribed here satisfy the requirement of input and bidirectional iterators as stated by the C++ standard and the STL documentation. It is therefore possible to use the functions from the algorithm section of the C++ standard, e.g. count_if (see the documentation for Triangulation for an example) and several others.

Implementation

The iterator class itself does not have much functionality. It only becomes useful when assigned an Accessor (the second template parameter), which really does the access to data. An Accessor has to fulfil some requirements:

Then the iterator is able to do what it is supposed to. All of the necessary functions are implemented in the Accessor base class, but you may write your own version (non-virtual, since we use templates) to add functionality.

The accessors provided by the library are distributed in three groups, determined by whether they access the data of Triangulation, DoFHandler or MGDoFHandler. They are derived from TriaAccessor, DoFAccessor and MGDoFAccessor, respectively. In each group, there is an accessor to cells, which have more functionality.

Attention:
It seems impossible to preserve constness of a triangulation through iterator usage. Thus, if you declare pointers to a const triangulation object, you should be well aware that you might involuntarily alter the data stored in the triangulation.
Note:
More information on valid and invalid iterators can be found in the documentation of TriaAccessorBase, where the iterator states are checked and implemented.

Past-the-end iterators

There is a representation of past-the-end-pointers, denoted by special values of the member variables present_level and present_index: If present_level>=0 and present_index>=0, then the object is valid (there is no check whether the triangulation really has that many levels or that many cells on the present level when we investigate the state of an iterator; however, in many places where an iterator is dereferenced we make this check); if present_level==-1 and present_index==-1, then the iterator points past the end; in all other cases, the iterator is considered invalid. You can check this by calling the state() function.

An iterator is also invalid, if the pointer pointing to the Triangulation object is invalid or zero.

Finally, an iterator is invalid, if the element pointed to by present_level and present_index is not used, i.e. if the used flag is set to false.

The last two checks are not made in state() since both cases should only occur upon unitialized construction through memcpy and the like (the parent triangulation can only be set upon construction). If an iterator is constructed empty through the empty constructor, present_level==-2 and present_index==-2. Thus, the iterator is invalid anyway, regardless of the state of the triangulation pointer and the state of the element pointed to.

Past-the-end iterators may also be used to compare an iterator with the before-the-start value, when running backwards. There is no distiction between the iterators pointing past the two ends of a vector.

By defining only one value to be past-the-end and making all other values invalid provides a second track of security: if we should have forgotten a check in the library when an iterator is incremented or decremented, we automatically convert the iterator from the allowed state "past-the-end" to the disallowed state "invalid" which increases the chance that somehwen earlier than for past-the-end iterators an exception is raised.

Triangulation

Author:
Wolfgang Bangerth, 1998

documentation update Guido Kanschat, 2004


Member Typedef Documentation

template<typename Accessor>
typedef Accessor TriaRawIterator< Accessor >::AccessorType

Declare the type of the Accessor for use in the outside world. This way other functions can use the Accessor's type without knowledge of how the exact implementation actually is.


Constructor & Destructor Documentation

template<typename Accessor>
TriaRawIterator< Accessor >::TriaRawIterator (  ) 

Empty constructor. Such an object is not usable!

template<typename Accessor>
TriaRawIterator< Accessor >::TriaRawIterator ( const TriaRawIterator< Accessor > &   ) 

Copy constructor.

template<typename Accessor>
TriaRawIterator< Accessor >::TriaRawIterator ( const Accessor &  a  ) 

Construct an iterator from the given accessor; the given accessor needs not be of the same type as the accessor of this class is, but it needs to be convertible.

Through this constructor, it is also possible to construct objects for derived iterators:

				      * DoFCellAccessor dof_accessor;
				      * Triangulation::active_cell_iterator cell
				      *   = accessor;
				      * 

template<typename Accessor>
template<typename OtherAccessor >
TriaRawIterator< Accessor >::TriaRawIterator ( const OtherAccessor &  a  )  [inline]

Constructor. Assumes that the other accessor type is convertible to the current one.

template<typename Accessor>
TriaRawIterator< Accessor >::TriaRawIterator ( const Triangulation< Accessor::dimension, Accessor::space_dimension > *  parent,
const int  level,
const int  index,
const typename AccessorType::AccessorData *  local_data = 0 
)

Proper constructor, initialized with the triangulation, the level and index of the object pointed to. The last parameter is of a type declared by the accessor class.

template<typename Accessor>
template<typename OtherAccessor >
TriaRawIterator< Accessor >::TriaRawIterator ( const TriaRawIterator< OtherAccessor > &  i  )  [inline]

This is a conversion operator (constructor) which takes another iterator type and copies the data; this conversion works, if there is a conversion path from the OtherAccessor class to the Accessor class of this object. One such path would be derived class to base class, which for example may be used to get a Triangulationraw_cell_iterator from a DoFHandlerraw_cell_iterator, since the DoFAccessor class is derived from the TriaAccessorBase class.

template<typename Accessor>
template<typename OtherAccessor >
TriaRawIterator< Accessor >::TriaRawIterator ( const TriaIterator< OtherAccessor > &  i  )  [inline]

Conversion constructor. Same as above with the difference that it converts from TriaIterator classes (not TriaRawIterator).

template<typename Accessor>
template<typename OtherAccessor >
TriaRawIterator< Accessor >::TriaRawIterator ( const TriaActiveIterator< OtherAccessor > &  i  )  [inline]

Conversion constructor. Same as above with the difference that it converts from TriaActiveIterator classes (not TriaRawIterator).


Member Function Documentation

template<typename Accessor>
const Accessor& TriaRawIterator< Accessor >::operator* (  )  const

Dereferencing operator, returns a reference to an accessor. Usage is thus like (*i).index ();

This function has to be specialized explicitly for the different Pointees, to allow an iterator<1,TriangulationLevel<1>::LinesData> to point to tria->lines.cells[index] while for one dimension higher it has to point to tria->quads.cells[index].

You must not dereference invalid or past the end iterators.

Referenced by TriaRawIterator< Accessor >::operator->().

template<typename Accessor>
Accessor& TriaRawIterator< Accessor >::operator* (  ) 

Dereferencing operator, non-const version.

template<typename Accessor>
const Accessor* TriaRawIterator< Accessor >::operator-> (  )  const

Dereferencing operator, returns a reference of the cell pointed to. Usage is thus like i->index ();

There is a const and a non-const version.

template<typename Accessor>
Accessor* TriaRawIterator< Accessor >::operator-> (  ) 

Dereferencing operator, non-const version.

template<typename Accessor>
TriaRawIterator& TriaRawIterator< Accessor >::operator= ( const TriaRawIterator< Accessor > &   ) 

template<typename Accessor>
bool TriaRawIterator< Accessor >::operator== ( const TriaRawIterator< Accessor > &   )  const

Compare for equality.

template<typename Accessor>
bool TriaRawIterator< Accessor >::operator!= ( const TriaRawIterator< Accessor > &   )  const

Compare for inequality.

template<typename Accessor>
bool TriaRawIterator< Accessor >::operator< ( const TriaRawIterator< Accessor > &   )  const

Offer a weak ordering of iterators, which is needed to make maps with iterators being keys. An iterator pointing to an element a is less than another iterator pointing to an element b if level(a)<level(b) or (level(a)==level(b) and index(a)<index(b)).

Comparing iterators of which one or both are invalid is an error. The past-the-end iterator is always ordered last. Two past-the-end iterators rank the same, thus false is returned in that case.

template<typename Accessor>
TriaRawIterator& TriaRawIterator< Accessor >::operator++ (  ) 

Prefix ++ operator: ++i. This operator advances the iterator to the next element and returns a reference to *this.

The next element is next on this level if there are more. If the present element is the last on this level, the first on the next level is accessed. This is only valid for iterators pointing to cells, faces have no level.

Reimplemented in TriaIterator< Accessor >, TriaActiveIterator< Accessor >, and TriaIterator< Accessor >.

template<typename Accessor>
TriaRawIterator TriaRawIterator< Accessor >::operator++ ( int   ) 

Postfix ++ operator: i++. This operator advances the iterator to the next element, but returns an iterator to the element priviously pointed to. Since this involves a temporary and a copy operation and since an iterator is quite a large object for a pointer, use the prefix operator ++i whenever possible, especially in the head of for loops (for (; i!=end; ++i)) since there you normally never need the returned value.

Reimplemented in TriaIterator< Accessor >, TriaActiveIterator< Accessor >, and TriaIterator< Accessor >.

template<typename Accessor>
TriaRawIterator& TriaRawIterator< Accessor >::operator-- (  ) 

Prefix -- operator: --i. This operator advances the iterator to the previous element and returns a reference to *this.

The previous element is previous on this level if index>0. If the present element is the first on this level, the last on the previous level is accessed. This is only valid for iterators pointing to cells, faces have no level.

Reimplemented in TriaIterator< Accessor >, TriaActiveIterator< Accessor >, and TriaIterator< Accessor >.

template<typename Accessor>
TriaRawIterator TriaRawIterator< Accessor >::operator-- ( int   ) 

Postfix -- operator: i--. This operator advances the iterator to the previous element, but returns an iterator to the element priviously pointed to. Since this involves a temporary and a copy operation and since an iterator is quite a large object for a pointer, use the prefix operator --i whenever possible, especially in the head of for loops (for (; i!=end; --i)) since there you normally never need the returned value.

Reimplemented in TriaIterator< Accessor >, TriaActiveIterator< Accessor >, and TriaIterator< Accessor >.

template<typename Accessor>
IteratorState::IteratorStates TriaRawIterator< Accessor >::state (  )  const

template<typename Accessor>
void TriaRawIterator< Accessor >::print ( std::ostream &  out  )  const

Print the iterator to out. The format is like level.index.

Referenced by operator<<().

template<typename Accessor>
unsigned int TriaRawIterator< Accessor >::memory_consumption (  )  const

Determine an estimate for the memory consumption (in bytes) of this object.


Friends And Related Function Documentation

template<typename Accessor>
friend class TriaRawIterator [friend]

Make all other iterator class templates friends of this class. This is necessary for the implementation of conversion constructors.

In fact, we would not need them to be friends if they were for different dimensions, but the compiler dislikes giving a fixed dimension and variable accessor since then it says that would be a artial specialization.

template<typename Accessor>
friend class TriaIterator [friend]

template<typename Accessor>
friend class TriaActiveIterator [friend]


Member Data Documentation

template<typename Accessor>
Accessor TriaRawIterator< Accessor >::accessor [protected]


The documentation for this class was generated from the following file:

deal.II documentation generated on Sat Aug 15 16:52:30 2009 by doxygen 1.5.9