Classes
struct	Pred< IterType, PredType >
Functions
template<typename PredType , typename IterType >
	variant_filter_iterator (const IterType &d, const IterType &e, const PredType &p)
	variant_filter_iterator ()
	variant_filter_iterator (const Iterator &rhs)
template<class OtherType , class OtherReferenceType , class OtherPointerType >
	variant_filter_iterator (const variant_filter_iterator< Predicate, OtherType, OtherReferenceType, OtherPointerType > &rhs)
virtual	~variant_filter_iterator ()
ReferenceType	operator* () const
PointerType	operator-> () const
Iterator &	operator++ ()
const Iterator	operator++ (int)
bool	equal (const variant_filter_iterator &other) const
void	swap (Iterator &lhs, Iterator &rhs)
Iterator &	operator= (const Iterator &rhs)
void	satisfy_predicate ()
template<class Predicate , class Type , class ReferenceType , class PointerType >
bool	operator== (const variant_filter_iterator< Predicate, Type, ReferenceType, PointerType > &x, const variant_filter_iterator< Predicate, Type, ReferenceType, PointerType > &y)
template<class Predicate , class Type , class ReferenceType , class PointerType >
bool	operator!= (const variant_filter_iterator< Predicate, Type, ReferenceType, PointerType > &x, const variant_filter_iterator< Predicate, Type, ReferenceType, PointerType > &y)
Variables
IterType	iter_data
IterBase *	data
IterBase *	end
PredBase *	pred

Function Documentation

bool equal ( const variant_filter_iterator & other ) const

forwards on the the equal function defined for the IterBase pointer. Possibly also compare the end pointers, but this is usually not important and would require an additional dynamic cast.

Definition at line 450 of file variant_filter_iterator.h.

References data.

Referenced by libMesh::UnstructuredMesh::copy_nodes_and_elements().

  {
    return data->equal(other.data);
  }

template<class Predicate , class Type , class ReferenceType , class PointerType >

bool operator!=	(	const variant_filter_iterator< Predicate, Type, ReferenceType, PointerType > &	x,
		const variant_filter_iterator< Predicate, Type, ReferenceType, PointerType > &	y
	)		`[inline, private]`

Definition at line 515 of file variant_filter_iterator.h.

{
  return !(x == y);
}

ReferenceType operator* ( ) const

unary op*() forwards on to Iter::op*()

Definition at line 409 of file variant_filter_iterator.h.

References data.

  {
    return **data;
  }

Iterator& operator++ ( )

op++() forwards on to Iter::op++()

Definition at line 426 of file variant_filter_iterator.h.

References data, and satisfy_predicate().

  {
    ++*data;
    this->satisfy_predicate();
    return (*this);
  }

const Iterator operator++ ( int )

postfix op++(), creates a temporary!

Definition at line 436 of file variant_filter_iterator.h.

References data, and satisfy_predicate().

  {
    Iterator oldValue(*this); // standard is to return old value
    ++*data;
    this->satisfy_predicate();
    return oldValue;
  }

PointerType operator-> ( ) const

op->()

Definition at line 418 of file variant_filter_iterator.h.

  {
    return (&**this);
  }

Iterator& operator= ( const Iterator & rhs )

Assignment operator.

Definition at line 473 of file variant_filter_iterator.h.

References swap().

  {
    Iterator temp(rhs);
    swap(temp, *this);
    return *this;
  }

template<class Predicate , class Type , class ReferenceType , class PointerType >

bool operator==	(	const variant_filter_iterator< Predicate, Type, ReferenceType, PointerType > &	x,
		const variant_filter_iterator< Predicate, Type, ReferenceType, PointerType > &	y
	)		`[inline, private]`

Definition at line 504 of file variant_filter_iterator.h.

{
  return x.equal(y);
}

void satisfy_predicate ( ) [private]

Advances the data pointer until it reaches the end or the predicate is satisfied.

Definition at line 488 of file variant_filter_iterator.h.

References data, and end.

Referenced by operator++(), and variant_filter_iterator().

  {
    while ( !data->equal(end) && !(*pred)(data) )
      ++(*data);
  }

void swap	(	Iterator &	lhs,
		Iterator &	rhs
	)

swap, used to implement op=

Definition at line 458 of file variant_filter_iterator.h.

Referenced by libMesh::DenseMatrix< T >::_lu_decompose(), operator=(), and libMesh::PetscMatrix< T >::swap().

  {
    // Swap the data pointers
    std::swap (lhs.data, rhs.data);

    // Swap the end pointers
    std::swap (lhs.end, rhs.end);

    // Also swap the predicate objects.
    std::swap (lhs.pred, rhs.pred);
  }

template<typename PredType , typename IterType >

variant_filter_iterator	(	const IterType &	d,
		const IterType &	e,
		const PredType &	p
	)

Templated Constructor. Allows you to construct the iterator and predicate from any types. Also advances the data pointer to the first entry which satisfies the predicate.

Definition at line 342 of file variant_filter_iterator.h.

References satisfy_predicate().

                                              :
    data ( new Iter<IterType>(d) ), // note: uses default IterBase copy constructor
    end  ( new Iter<IterType>(e) ),
    pred ( new Pred<IterType,PredType>(p) )
  {
    this->satisfy_predicate();
  }

variant_filter_iterator ( )

Default Constructor.

Definition at line 355 of file variant_filter_iterator.h.

                             :
    data(NULL),
    end(NULL),
    pred(NULL) {}

variant_filter_iterator ( const Iterator & rhs )

Copy Constructor. Copy the internal data instead of sharing it.

Definition at line 364 of file variant_filter_iterator.h.

                                                :
    data (rhs.data != NULL ? rhs.data->clone() : NULL),
    end  (rhs.end  != NULL ? rhs.end->clone()  : NULL),
    pred (rhs.pred != NULL ? rhs.pred->clone() : NULL) {}

template<class OtherType , class OtherReferenceType , class OtherPointerType >

variant_filter_iterator ( const variant_filter_iterator< Predicate, OtherType, OtherReferenceType, OtherPointerType > & rhs )

Copy construct from another (similar) variant_filter_iterator. The Predicate is the same, but the Type, ReferenceType and PointerType are different. Example: You are iterating over a std::vector<int*> with std::vector<int*>::iterator Then, you have: Type=int* , ReferenceType=int*& , PointerType=int** On the other hand, when you iterate using std::vector<int*>::const_iterator you have: Type=int * const, ReferenceType=int * const & , PointerType=int * const *

Definition at line 383 of file variant_filter_iterator.h.

    : data (rhs.data != NULL ? rhs.data->const_clone() : NULL),
      end  (rhs.end  != NULL ? rhs.end->const_clone()  : NULL),
      pred (rhs.pred != NULL ? rhs.pred->const_clone() : NULL)
  {
    // libMesh::out << "Called templated copy constructor for variant_filter_iterator" << std::endl;
  }

virtual ~variant_filter_iterator ( ) [virtual]

Destructor

Definition at line 399 of file variant_filter_iterator.h.

References data, end, and pred.

  {
    delete data; data = NULL;
    delete end;  end  = NULL;
    delete pred; pred = NULL;
  }

Variable Documentation

IterBase* data

Ideally this private member data should have protected access. However, if we want a const_iterator to be constructable from an non-const one, templated versions of the same class (not related by inheritance) will need to know about these private members. Thus, they have public access.

Polymorphic pointer to the object. Don't confuse with the data pointer located in the Iter!

Definition at line 318 of file variant_filter_iterator.h.

Referenced by libMesh::Parallel::BinSorter< KeyType, IdxType >::binsort(), equal(), libMesh::QMonomial::init_2D(), libMesh::QMonomial::init_3D(), libMesh::Parallel::Histogram< KeyType, IdxType >::make_histogram(), libMesh::MeshFunction::operator()(), libMesh::Utility::ReverseBytes::operator()(), operator*(), operator++(), libMesh::PltLoader::read_block_data(), libMesh::PltLoader::read_feblock_data(), libMesh::PltLoader::read_fepoint_data(), libMesh::PltLoader::read_point_data(), satisfy_predicate(), libMesh::Parallel::sync_dofobject_data_by_id(), libMesh::Parallel::sync_dofobject_data_by_xyz(), libMesh::Parallel::sync_element_data_by_parent_id(), libMesh::Parallel::sync_node_data_by_element_id(), libMesh::VTKIO::system_vectors_to_vtk(), libMesh::ExodusII_IO_Helper::write_element_values(), libMesh::VTKIO::write_nodal_data(), libMesh::GnuPlotIO::write_solution(), and ~variant_filter_iterator().

IterBase* end

Also have a polymorphic pointer to the end object, this prevents iterating past the end.

Definition at line 324 of file variant_filter_iterator.h.

IterType iter_data

Original Authors: Corwin Joy * Michael Gradman cjoy@houston.rr.com * Michael.Gradman@caminus.com Caminus, Suite 1150, Two Allen Center, 1200 Smith Street, Houston, TX 77002 This class is an extension of variant_bidirectional_iterator to a filter_iterator similar to boost's. The filter iterator is modeled after a forward_iterator since to go backward and forward requires the storage of both a "begin" and "end" iterator to avoid stepping off the end or the beginning. To reduce complexity, we only allow traversal in one direction.

Author:: John W. Peterson, 2004. This is the iterator passed by the user.

Definition at line 49 of file variant_filter_iterator.h.

PredBase* pred

The predicate object. Must have op() capable of operating on IterBase* pointers. Therefore it has to follow the same paradigm as IterBase.

Definition at line 331 of file variant_filter_iterator.h.

Referenced by libMesh::Predicates::abstract_multi_predicate< T >::operator()(), and ~variant_filter_iterator().

Classes

Functions

Variables

Function Documentation

Variable Documentation