Main Page | Namespace List | Class Hierarchy | Alphabetical List | Class List | Directories | File List | Namespace Members | Class Members | File Members | Related Pages

dchain::PartialCandidateItr< CandidateClass > Class Template Reference

#include <PartialCandidateItr.h>

List of all members.

Public Types

typedef dchain::candidateitr::difference_type difference_type
typedef dchain::candidateitr::difference_type difference_type
typedef std::bidirectional_iterator_tag iterator_category
typedef std::bidirectional_iterator_tag iterator_category
typedef value_typepointer
typedef value_typepointer
typedef value_typereference
typedef value_typereference
typedef dchain::candidateitr::size_type size_type
typedef dchain::candidateitr::size_type size_type
typedef LabeledCandidate<
CandidateClass > 
value_type
typedef LabeledCandidate<
CandidateClass > 
value_type

Public Member Functions

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

Protected Member Functions

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

Private Attributes

size_type m_index
IndexedLabeledCandidates<
CandidateClass > * 
m_indexedCandidates
IndexedLabeledCandidates<
CandidateClass > * 
m_indexedCandidates
conjugation::Label m_label

Friends

class LabeledCandidateList< CandidateClass >

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


Member Typedef Documentation

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

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

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

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

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

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

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

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

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

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

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

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


Constructor & Destructor Documentation

template<class CandidateClass>
dchain::PartialCandidateItr< CandidateClass >::PartialCandidateItr  )  [inline]
 

00151 {
00152 }

template<class CandidateClass>
dchain::PartialCandidateItr< CandidateClass >::PartialCandidateItr const PartialCandidateItr< CandidateClass > &  aOtherItr  )  [inline]
 

00156                                                                                                                    :
00157    m_indexedCandidates( aOtherItr.indexedCandidates() ) ,
00158    m_index( aOtherItr.index() ) ,
00159    m_label( aOtherItr.label() )
00160 {
00161 }

template<class CandidateClass>
virtual dchain::PartialCandidateItr< CandidateClass >::~PartialCandidateItr  )  [inline, virtual]
 

00067 {}

template<class CandidateClass>
dchain::PartialCandidateItr< CandidateClass >::PartialCandidateItr const IndexedLabeledCandidates< CandidateClass > *  aList,
const size_type  aIndex,
const conjugation::Label  aLabel
[inline, protected]
 

00167                                       :
00168    // cast away const as const_iterator can be assocciated with a non-const list,
00169    //   but only const lists use this constructor
00170    m_indexedCandidates( (IndexedLabeledCandidates< CandidateClass >*)aList ) ,
00171    m_index( aIndex ) ,
00172    m_label( aLabel )
00173 {
00174    // move to first entry with correct label
00175    if ( ( m_index < size_type( (*m_indexedCandidates).size() ) ) &&
00176          ( (*m_indexedCandidates).labeledCandidateClass( m_index ) != m_label )
00177       ) {
00178       operator++() ;
00179    }
00180 }

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

template<class CandidateClass>
dchain::PartialCandidateItr< CandidateClass >::PartialCandidateItr const PartialCandidateItr< CandidateClass > &  aOtherItr  ) 
 

template<class CandidateClass>
virtual dchain::PartialCandidateItr< CandidateClass >::~PartialCandidateItr  )  [inline, virtual]
 

00067 {}

template<class CandidateClass>
dchain::PartialCandidateItr< CandidateClass >::PartialCandidateItr const IndexedLabeledCandidates< CandidateClass > *  aList,
const size_type  aIndex,
const conjugation::Label  aLabel
[protected]
 


Member Function Documentation

template<class CandidateClass>
size_type dchain::PartialCandidateItr< CandidateClass >::index  )  const [protected]
 

template<class CandidateClass>
PartialCandidateItr< CandidateClass >::size_type dchain::PartialCandidateItr< CandidateClass >::index  )  const [inline, protected]
 

00133 {
00134    return ( m_index ) ;
00135 }

template<class CandidateClass>
IndexedLabeledCandidates< CandidateClass >* dchain::PartialCandidateItr< CandidateClass >::indexedCandidates  )  const [protected]
 

template<class CandidateClass>
IndexedLabeledCandidates< CandidateClass > * dchain::PartialCandidateItr< CandidateClass >::indexedCandidates  )  const [inline, protected]
 

00125 {
00126    return ( m_indexedCandidates ) ;
00127 }

template<class CandidateClass>
conjugation::Label dchain::PartialCandidateItr< CandidateClass >::label  )  const [protected]
 

template<class CandidateClass>
conjugation::Label dchain::PartialCandidateItr< CandidateClass >::label  )  const [inline, protected]
 

00140 {
00141    return ( m_label ) ;
00142 }

template<class CandidateClass>
const LabeledCandidate< CandidateClass >& dchain::PartialCandidateItr< CandidateClass >::operator *  )  const
 

Reimplemented in dchain::PartialItr< T >, dchain::PartialItr< T >, dchain::PartialItr< CDDecay >, and dchain::PartialItr< CDDecay >.

template<class CandidateClass>
const LabeledCandidate< CandidateClass > & dchain::PartialCandidateItr< CandidateClass >::operator *  )  const [inline]
 

Reimplemented in dchain::PartialItr< T >, dchain::PartialItr< T >, dchain::PartialItr< CDDecay >, and dchain::PartialItr< CDDecay >.

00294 {
00295    return ( (*m_indexedCandidates).labeledCandidateClass( m_index ) ) ;
00296 }

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

template<class CandidateClass>
bool dchain::PartialCandidateItr< CandidateClass >::operator!= const PartialCandidateItr< CandidateClass > &  aOtherItr  )  const [inline]
 

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

template<class CandidateClass>
PartialCandidateItr< CandidateClass > dchain::PartialCandidateItr< CandidateClass >::operator++ int   ) 
 

Reimplemented in dchain::PartialItr< T >, dchain::PartialItr< T >, dchain::PartialItr< CDDecay >, and dchain::PartialItr< CDDecay >.

template<class CandidateClass>
PartialCandidateItr< CandidateClass >& dchain::PartialCandidateItr< CandidateClass >::operator++  ) 
 

Reimplemented in dchain::PartialItr< T >, dchain::PartialItr< T >, dchain::PartialItr< CDDecay >, and dchain::PartialItr< CDDecay >.

template<class CandidateClass>
PartialCandidateItr< CandidateClass > dchain::PartialCandidateItr< CandidateClass >::operator++ int   )  [inline]
 

Reimplemented in dchain::PartialItr< T >, dchain::PartialItr< T >, dchain::PartialItr< CDDecay >, and dchain::PartialItr< CDDecay >.

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

template<class CandidateClass>
PartialCandidateItr< CandidateClass > & dchain::PartialCandidateItr< CandidateClass >::operator++  )  [inline]
 

Reimplemented in dchain::PartialItr< T >, dchain::PartialItr< T >, dchain::PartialItr< CDDecay >, and dchain::PartialItr< CDDecay >.

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

template<class CandidateClass>
PartialCandidateItr< CandidateClass > dchain::PartialCandidateItr< CandidateClass >::operator-- int   ) 
 

Reimplemented in dchain::PartialItr< T >, dchain::PartialItr< T >, dchain::PartialItr< CDDecay >, and dchain::PartialItr< CDDecay >.

template<class CandidateClass>
PartialCandidateItr< CandidateClass >& dchain::PartialCandidateItr< CandidateClass >::operator--  ) 
 

Reimplemented in dchain::PartialItr< T >, dchain::PartialItr< T >, dchain::PartialItr< CDDecay >, and dchain::PartialItr< CDDecay >.

template<class CandidateClass>
PartialCandidateItr< CandidateClass > dchain::PartialCandidateItr< CandidateClass >::operator-- int   )  [inline]
 

Reimplemented in dchain::PartialItr< T >, dchain::PartialItr< T >, dchain::PartialItr< CDDecay >, and dchain::PartialItr< CDDecay >.

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

template<class CandidateClass>
PartialCandidateItr< CandidateClass > & dchain::PartialCandidateItr< CandidateClass >::operator--  )  [inline]
 

Reimplemented in dchain::PartialItr< T >, dchain::PartialItr< T >, dchain::PartialItr< CDDecay >, and dchain::PartialItr< CDDecay >.

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

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

template<class CandidateClass>
const PartialCandidateItr< CandidateClass > & dchain::PartialCandidateItr< CandidateClass >::operator= const PartialCandidateItr< CandidateClass > &  aOtherItr  )  [inline]
 

00189 {
00190    m_indexedCandidates = aOtherItr.indexedCandidates() ;
00191    m_index = aOtherItr.index() ;
00192    m_label = aOtherItr.label() ;
00193    return ( *this ) ;
00194 }

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

template<class CandidateClass>
bool dchain::PartialCandidateItr< CandidateClass >::operator== const PartialCandidateItr< CandidateClass > &  aOtherItr  )  const [inline]
 

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


Friends And Related Function Documentation

template<class CandidateClass>
LabeledCandidateList< CandidateClass > [friend]
 


Member Data Documentation

template<class CandidateClass>
size_type dchain::PartialCandidateItr< CandidateClass >::m_index [private]
 

template<class CandidateClass>
IndexedLabeledCandidates< CandidateClass >* dchain::PartialCandidateItr< CandidateClass >::m_indexedCandidates [private]
 

template<class CandidateClass>
IndexedLabeledCandidates< CandidateClass >* dchain::PartialCandidateItr< CandidateClass >::m_indexedCandidates [private]
 

template<class CandidateClass>
conjugation::Label dchain::PartialCandidateItr< CandidateClass >::m_label [private]
 


The documentation for this class was generated from the following files:
Generated on Wed Feb 2 19:17:06 2011 for BOSS6.5.5 by  doxygen 1.3.9.1