dchain::PartialCandidateItr< CandidateClass > Class Template Reference

#include <PartialCandidateItr.h>

Public Types
typedef LabeledCandidate< CandidateClass >	value_type
typedef dchain::candidateitr::difference_type	difference_type
typedef dchain::candidateitr::size_type	size_type
typedef value_type &	reference
typedef value_type *	pointer
typedef std::bidirectional_iterator_tag	iterator_category

Public Member Functions
	PartialCandidateItr ()
	PartialCandidateItr (const PartialCandidateItr< CandidateClass > &aOtherItr)
virtual	~PartialCandidateItr ()
const PartialCandidateItr< CandidateClass > &	operator= (const PartialCandidateItr< CandidateClass > &aOtherItr)
PartialCandidateItr< CandidateClass > &	operator++ ()
PartialCandidateItr< CandidateClass >	operator++ (int)
PartialCandidateItr< CandidateClass > &	operator-- ()
PartialCandidateItr< CandidateClass >	operator-- (int)
const LabeledCandidate< CandidateClass > &	operator* () const
bool	operator== (const PartialCandidateItr< CandidateClass > &aOtherItr) const
bool	operator!= (const PartialCandidateItr< CandidateClass > &aOtherItr) const

Protected Member Functions
	PartialCandidateItr (const IndexedLabeledCandidates< CandidateClass > *aList, const size_type aIndex, const conjugation::Label aLabel)
IndexedLabeledCandidates< CandidateClass > *	indexedCandidates () const
size_type	index () const
conjugation::Label	label () const

Friends
class	LabeledCandidateList< CandidateClass >

Detailed Description

template<class CandidateClass>
class dchain::PartialCandidateItr< CandidateClass >

Definition at line 47 of file PartialCandidateItr.h.

Member Typedef Documentation

difference_type

template<class CandidateClass >

typedef dchain::candidateitr::difference_type dchain::PartialCandidateItr< CandidateClass >::difference_type

Definition at line 56 of file PartialCandidateItr.h.

iterator_category

template<class CandidateClass >

typedef std::bidirectional_iterator_tag dchain::PartialCandidateItr< CandidateClass >::iterator_category

Definition at line 61 of file PartialCandidateItr.h.

pointer

template<class CandidateClass >

typedef value_type* dchain::PartialCandidateItr< CandidateClass >::pointer

Definition at line 59 of file PartialCandidateItr.h.

reference

template<class CandidateClass >

typedef value_type& dchain::PartialCandidateItr< CandidateClass >::reference

Definition at line 58 of file PartialCandidateItr.h.

size_type

template<class CandidateClass >

typedef dchain::candidateitr::size_type dchain::PartialCandidateItr< CandidateClass >::size_type

Definition at line 57 of file PartialCandidateItr.h.

value_type

template<class CandidateClass >

typedef LabeledCandidate<CandidateClass> dchain::PartialCandidateItr< CandidateClass >::value_type

Definition at line 55 of file PartialCandidateItr.h.

Constructor & Destructor Documentation

PartialCandidateItr() [1/3]

template<class CandidateClass >

dchain::PartialCandidateItr< CandidateClass >::PartialCandidateItr

inline

Definition at line 150 of file PartialCandidateItr.h.

{
}

PartialCandidateItr() [2/3]

template<class CandidateClass >

dchain::PartialCandidateItr< CandidateClass >::PartialCandidateItr ( const PartialCandidateItr< CandidateClass > &  aOtherItr )

inline

Definition at line 156 of file PartialCandidateItr.h.

                                                                                                                   :
   m_indexedCandidates( aOtherItr.indexedCandidates() ) ,
   m_index( aOtherItr.index() ) ,
   m_label( aOtherItr.label() )
{
}

~PartialCandidateItr()

template<class CandidateClass >

virtual dchain::PartialCandidateItr< CandidateClass >::~PartialCandidateItr ( )

inlinevirtual

Definition at line 67 of file PartialCandidateItr.h.

{}

PartialCandidateItr() [3/3]

template<class CandidateClass >

dchain::PartialCandidateItr< CandidateClass >::PartialCandidateItr ( const IndexedLabeledCandidates< CandidateClass > *  aList, const size_type  aIndex, const conjugation::Label  aLabel  )

inlineprotected

Definition at line 165 of file PartialCandidateItr.h.

                                      :
   // cast away const as const_iterator can be assocciated with a non-const list,
   //   but only const lists use this constructor
   m_indexedCandidates( (IndexedLabeledCandidates< CandidateClass >*)aList ) ,
   m_index( aIndex ) ,
   m_label( aLabel )
{
   // move to first entry with correct label
   if ( ( m_index < size_type( (*m_indexedCandidates).size() ) ) &&
     ( (*m_indexedCandidates).labeledCandidateClass( m_index ) != m_label )
      ) {
      operator++() ;
   }
}

Member Function Documentation

index()

template<class CandidateClass >

PartialCandidateItr< CandidateClass >::size_type dchain::PartialCandidateItr< CandidateClass >::index

inlineprotected

Definition at line 132 of file PartialCandidateItr.h.

{
   return ( m_index ) ;
}

Referenced by dchain::PartialCandidateItr< CandidateClass >::operator=(), and dchain::PartialCandidateItr< CandidateClass >::operator==().

indexedCandidates()

template<class CandidateClass >

IndexedLabeledCandidates< CandidateClass > * dchain::PartialCandidateItr< CandidateClass >::indexedCandidates

inlineprotected

Definition at line 124 of file PartialCandidateItr.h.

{
   return ( m_indexedCandidates ) ;
}

Referenced by dchain::PartialCandidateItr< CandidateClass >::operator=(), and dchain::PartialCandidateItr< CandidateClass >::operator==().

label()

template<class CandidateClass >

conjugation::Label dchain::PartialCandidateItr< CandidateClass >::label

inlineprotected

Definition at line 139 of file PartialCandidateItr.h.

{
   return ( m_label ) ;
}

Referenced by dchain::PartialCandidateItr< CandidateClass >::operator=(), and dchain::PartialCandidateItr< CandidateClass >::operator==().

operator!=()

template<class CandidateClass >

bool dchain::PartialCandidateItr< CandidateClass >::operator!= ( const PartialCandidateItr< CandidateClass > &  aOtherItr ) const

inline

Definition at line 311 of file PartialCandidateItr.h.

{
   // There needs to be a final test on the label as itrs with two different labels
   //   have the same values for the past-the-end value
   return ( ( m_index != aOtherItr.index() ) ||
     ( m_indexedCandidates != aOtherItr.indexedCandidates() ) ||
     ( m_label != aOtherItr.label() ) ) ;
}

operator*()

template<class CandidateClass >

const LabeledCandidate< CandidateClass > & dchain::PartialCandidateItr< CandidateClass >::operator*

inline

Definition at line 293 of file PartialCandidateItr.h.

{
   return ( (*m_indexedCandidates).labeledCandidateClass( m_index ) ) ;
}

operator++() [1/2]

template<class CandidateClass >

PartialCandidateItr< CandidateClass > & dchain::PartialCandidateItr< CandidateClass >::operator++

inline

Definition at line 202 of file PartialCandidateItr.h.

{
   ++m_index ;
   // This while loop find next match to label.
   // The order is done for efficiency reasons.  It is more likely a label
   //   will match than the end of the list has been reached.  However this
   //   will can cause an access to an uninitiallized location, but the
   //   loop will still terminate correctly.
   // update: the efficiency doesn't matter but reading invalid memory
   //   makes our automated memory checkers have fits
   while (
     ( m_index < size_type( (*m_indexedCandidates).size() ) &&
       ( (*m_indexedCandidates).labeledCandidateClass( m_index ) != m_label )
     ) ) {
      ++m_index ;
   }
   return ( *this ) ;
}

Referenced by dchain::PartialItr< T >::operator++(), and dchain::PartialCandidateItr< CandidateClass >::PartialCandidateItr().

operator++() [2/2]

template<class CandidateClass >

PartialCandidateItr< CandidateClass > dchain::PartialCandidateItr< CandidateClass >::operator++ ( int  )

inline

Definition at line 223 of file PartialCandidateItr.h.

{
   PartialCandidateItr< CandidateClass > tmp( *this ) ;
   ++m_index ;
   // This while loop find next match to label.
   // The order is done for efficiency reasons.  It is more likely a label
   //   will match than the end of the list has been reached.  However this
   //   will can cause an access to an uninitiallized location, but the
   //   loop will still terminate correctly.
   while (
     ( (*m_indexedCandidates).labeledCandidateClass( m_index ) != m_label ) &&
     ( m_index < size_type( (*m_indexedCandidates).size() ) ) ) {
      ++m_index ;
   }
   return ( tmp ) ;
}

operator--() [1/2]

template<class CandidateClass >

PartialCandidateItr< CandidateClass > & dchain::PartialCandidateItr< CandidateClass >::operator--

inline

Definition at line 242 of file PartialCandidateItr.h.

{
   // As the index is 'unsigned' it should not go below zero.  This behavior is completely
   //   consistent with the STL reverse_iterator adaptor. (See pp254 of Musser & Saini)
   //
   if ( 0 != m_index ) {
      --m_index ;
   }
   // This while loop find next match to label.
   // The order is done for efficiency reasons.  It is more likely a label
   //   will match than the end of the list has been reached.  However this
   //   will can cause an access to an uninitiallized location, but the
   //   loop will still terminate correctly.
   while (
     ( (*m_indexedCandidates).labeledCandidateClass( m_index ) != m_label ) &&
     ( m_index != 0 ) ) {
      --m_index ;
   }
   return ( *this ) ;
}

Referenced by dchain::PartialItr< T >::operator--().

operator--() [2/2]

template<class CandidateClass >

PartialCandidateItr< CandidateClass > dchain::PartialCandidateItr< CandidateClass >::operator-- ( int  )

inline

Definition at line 265 of file PartialCandidateItr.h.

{
   PartialCandidateItr< CandidateClass > tmp( *this ) ;
   // As the index is 'unsigned' it should not go below zero.  This behavior is completely
   //   consistent with the STL reverse_iterator adaptor. (See pp254 of Musser & Saini)
   //
   if ( 0 != m_index ) {
      --m_index ;
   }
   // This while loop find next match to label.
   // The order is done for efficiency reasons.  It is more likely a label
   //   will match than the end of the list has been reached.  However this
   //   will can cause an access to an uninitiallized location, but the
   //   loop will still terminate correctly.
   while (
     ( (*m_indexedCandidates).labeledCandidateClass( m_index ) != m_label ) &&
     ( m_index != 0 ) ) {
      --m_index ;
   }
   return ( tmp ) ;
}

operator=()

template<class CandidateClass >

const PartialCandidateItr< CandidateClass > & dchain::PartialCandidateItr< CandidateClass >::operator= ( const PartialCandidateItr< CandidateClass > &  aOtherItr )

inline

Definition at line 188 of file PartialCandidateItr.h.

{
   m_indexedCandidates = aOtherItr.indexedCandidates() ;
   m_index = aOtherItr.index() ;
   m_label = aOtherItr.label() ;
   return ( *this ) ;
}

Referenced by dchain::PartialItr< T >::operator=().

operator==()

template<class CandidateClass >

bool dchain::PartialCandidateItr< CandidateClass >::operator== ( const PartialCandidateItr< CandidateClass > &  aOtherItr ) const

inline

Definition at line 300 of file PartialCandidateItr.h.

{
   // There needs to be a final test on the label as itrs with two different labels
   //   have the same values for the past-the-end value
   return ( ( m_index == aOtherItr.index() ) &&
     ( m_indexedCandidates == aOtherItr.indexedCandidates() ) &&
     ( m_label == aOtherItr.label() ) ) ;
}

Friends And Related Function Documentation

LabeledCandidateList< CandidateClass >

template<class CandidateClass >

friend class LabeledCandidateList< CandidateClass >

friend

Definition at line 311 of file PartialCandidateItr.h.

---

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

• PartialCandidateItr.h