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

dchain::WholeCandidateItr< CandidateClass > Class Template Reference

#include <WholeCandidateItr.h>

List of all members.

Public Types

typedef dchain::candidateitr::difference_type difference_type
typedef dchain::candidateitr::difference_type difference_type
typedef dchain::candidateitr::size_type distance_type
typedef dchain::candidateitr::size_type distance_type
typedef std::random_access_iterator_tag iterator_category
typedef std::random_access_iterator_tag iterator_category
typedef const LabeledCandidate<
CandidateClass > * 		pointer
typedef const LabeledCandidate<
CandidateClass > * 		pointer
typedef const LabeledCandidate<
CandidateClass > & 		reference
typedef const LabeledCandidate<
CandidateClass > & 		reference
typedef dchain::candidateitr::size_type size_type
typedef dchain::candidateitr::size_type size_type
typedef const LabeledCandidate<
CandidateClass > 		value_type
typedef const LabeledCandidate<
CandidateClass > 		value_type

Public Member Functions

const LabeledCandidate< CandidateClass > & operator * () const
const LabeledCandidate< CandidateClass > & operator * () const
bool operator!= (const WholeCandidateItr< CandidateClass > &aOtherItr) const
bool operator!= (const WholeCandidateItr< CandidateClass > &aOtherItr) const
WholeCandidateItr< CandidateClass > operator+ (difference_type n)
WholeCandidateItr< CandidateClass > operator+ (difference_type n)
WholeCandidateItr< CandidateClass > operator++ (int)
WholeCandidateItr< CandidateClass > & operator++ ()
WholeCandidateItr< CandidateClass > operator++ (int)
WholeCandidateItr< CandidateClass > & operator++ ()
WholeCandidateItr< CandidateClass > & operator+= (difference_type n)
WholeCandidateItr< CandidateClass > & operator+= (difference_type n)
difference_type operator- (const WholeCandidateItr< CandidateClass > &aOtherItr) const
WholeCandidateItr< CandidateClass > operator- (difference_type n)
difference_type operator- (const WholeCandidateItr< CandidateClass > &aOtherItr) const
WholeCandidateItr< CandidateClass > operator- (difference_type n)
WholeCandidateItr< CandidateClass > operator-- (int)
WholeCandidateItr< CandidateClass > & operator-- ()
WholeCandidateItr< CandidateClass > operator-- (int)
WholeCandidateItr< CandidateClass > & operator-- ()
WholeCandidateItr< CandidateClass > & operator-= (difference_type n)
WholeCandidateItr< CandidateClass > & operator-= (difference_type n)
bool operator< (const WholeCandidateItr< CandidateClass > &aOtherItr) const
bool operator< (const WholeCandidateItr< CandidateClass > &aOtherItr) const
bool operator<= (const WholeCandidateItr< CandidateClass > &aOtherItr) const
bool operator<= (const WholeCandidateItr< CandidateClass > &aOtherItr) const
const WholeCandidateItr & operator= (const WholeCandidateItr< CandidateClass > &aOtherItr)
const WholeCandidateItr & operator= (const WholeCandidateItr< CandidateClass > &aOtherItr)
bool operator== (const WholeCandidateItr< CandidateClass > &aOtherItr) const
bool operator== (const WholeCandidateItr< CandidateClass > &aOtherItr) const
bool operator> (const WholeCandidateItr< CandidateClass > &aOtherItr) const
bool operator> (const WholeCandidateItr< CandidateClass > &aOtherItr) const
bool operator>= (const WholeCandidateItr< CandidateClass > &aOtherItr) const
bool operator>= (const WholeCandidateItr< CandidateClass > &aOtherItr) const
const LabeledCandidate< CandidateClass > & operator[] (size_type n) const
const LabeledCandidate< CandidateClass > & operator[] (size_type n) const
 WholeCandidateItr (const WholeCandidateItr< CandidateClass > &aOtherItr)
 WholeCandidateItr (const WholeCandidateItr< CandidateClass > &aOtherItr)
virtual ~WholeCandidateItr ()
virtual ~WholeCandidateItr ()

Protected Member Functions

size_type index () const
size_type index () const
IndexedLabeledCandidates<
CandidateClass > * 		indexedCandidates () const
IndexedLabeledCandidates<
CandidateClass > * 		indexedCandidates () const
 WholeCandidateItr (const IndexedLabeledCandidates< CandidateClass > *aList, const size_type aIndex)
 WholeCandidateItr (const IndexedLabeledCandidates< CandidateClass > *aList, const size_type aIndex)

Private Member Functions

 WholeCandidateItr ()
 WholeCandidateItr ()

Private Attributes

size_type m_index
IndexedLabeledCandidates<
CandidateClass > * 		m_indexedCandidates
IndexedLabeledCandidates<
CandidateClass > * 		m_indexedCandidates

Friends

class LabeledCandidateList< CandidateClass >

template<class CandidateClass>
class dchain::WholeCandidateItr< CandidateClass >

Member Typedef Documentation

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

Reimplemented in dchain::WholeItr< T >, and dchain::WholeItr< T >.

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

Reimplemented in dchain::WholeItr< T >, and dchain::WholeItr< T >.

template<class CandidateClass>
typedef dchain::candidateitr::size_type dchain::WholeCandidateItr< CandidateClass >::distance_type
 

template<class CandidateClass>
typedef dchain::candidateitr::size_type dchain::WholeCandidateItr< CandidateClass >::distance_type
 

template<class CandidateClass>
typedef std::random_access_iterator_tag dchain::WholeCandidateItr< CandidateClass >::iterator_category
 

template<class CandidateClass>
typedef std::random_access_iterator_tag dchain::WholeCandidateItr< CandidateClass >::iterator_category
 

template<class CandidateClass>
typedef const LabeledCandidate<CandidateClass>* dchain::WholeCandidateItr< CandidateClass >::pointer
 

template<class CandidateClass>
typedef const LabeledCandidate<CandidateClass>* dchain::WholeCandidateItr< CandidateClass >::pointer
 

template<class CandidateClass>
typedef const LabeledCandidate<CandidateClass>& dchain::WholeCandidateItr< CandidateClass >::reference
 

template<class CandidateClass>
typedef const LabeledCandidate<CandidateClass>& dchain::WholeCandidateItr< CandidateClass >::reference
 

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

Reimplemented in dchain::WholeItr< T >, and dchain::WholeItr< T >.

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

Reimplemented in dchain::WholeItr< T >, and dchain::WholeItr< T >.

template<class CandidateClass>
typedef const LabeledCandidate<CandidateClass> dchain::WholeCandidateItr< CandidateClass >::value_type
 

template<class CandidateClass>
typedef const LabeledCandidate<CandidateClass> dchain::WholeCandidateItr< CandidateClass >::value_type
 

Constructor & Destructor Documentation

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

00146                                                                                                              :
00147    m_indexedCandidates( aOtherItr.indexedCandidates() ) ,
00148    m_index( aOtherItr.index() )
00149 {
00150 }

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

00063 {}

template<class CandidateClass>
dchain::WholeCandidateItr< CandidateClass >::WholeCandidateItr (  const IndexedLabeledCandidates< CandidateClass > *  aList,
const size_type  aIndex
)  [inline, protected]
  

00155                                                                      :
00156 // cast away const as const_itr can be assocciated with a non-const list,
00157 //   but only const lists use this constructor
00158    m_indexedCandidates( (IndexedLabeledCandidates< CandidateClass >*)aList ) ,
00159    m_index( aIndex )
00160 {   
00161 }

template<class CandidateClass>
dchain::WholeCandidateItr< CandidateClass >::WholeCandidateItr (   )  [private]
 

template<class CandidateClass>
dchain::WholeCandidateItr< CandidateClass >::WholeCandidateItr (  const WholeCandidateItr< CandidateClass > &  aOtherItr  ) 
 

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

00063 {}

template<class CandidateClass>
dchain::WholeCandidateItr< CandidateClass >::WholeCandidateItr (  const IndexedLabeledCandidates< CandidateClass > *  aList,
const size_type  aIndex
)  [protected]
 

template<class CandidateClass>
dchain::WholeCandidateItr< CandidateClass >::WholeCandidateItr (   )  [private]
 

Member Function Documentation

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

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

00136 {
00137    return ( m_index ) ;
00138 }

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

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

00129 {
00130    return ( m_indexedCandidates ) ;
00131 }

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

Reimplemented in dchain::WholeItr< T >, and dchain::WholeItr< T >.

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

Reimplemented in dchain::WholeItr< T >, and dchain::WholeItr< T >.

00253 {
00254    return ( (*m_indexedCandidates).labeledCandidateClass( m_index ) ) ;
00255 }

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

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

00283 {
00284    return ( ( m_index != aOtherItr.index() ) ||
00285             ( m_indexedCandidates != aOtherItr.indexedCandidates() ) ) ;
00286 }

template<class CandidateClass>
WholeCandidateItr< CandidateClass > dchain::WholeCandidateItr< CandidateClass >::operator+ (  difference_type  n  ) 
 

Reimplemented in dchain::WholeItr< T >, and dchain::WholeItr< T >.

template<class CandidateClass>
WholeCandidateItr< CandidateClass > dchain::WholeCandidateItr< CandidateClass >::operator+ (  difference_type  n  )  [inline]
 

Reimplemented in dchain::WholeItr< T >, and dchain::WholeItr< T >.

00225 {
00226    WholeCandidateItr tmp( *this ) ;
00227    return ( tmp += n ) ;
00228 }

template<class CandidateClass>
WholeCandidateItr< CandidateClass > dchain::WholeCandidateItr< CandidateClass >::operator++ (  int   ) 
 

Reimplemented in dchain::WholeItr< T >, and dchain::WholeItr< T >.

template<class CandidateClass>
WholeCandidateItr< CandidateClass >& dchain::WholeCandidateItr< CandidateClass >::operator++ (   ) 
 

Reimplemented in dchain::WholeItr< T >, and dchain::WholeItr< T >.

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

Reimplemented in dchain::WholeItr< T >, and dchain::WholeItr< T >.

00191 {
00192    WholeCandidateItr tmp( *this ) ;
00193    ++m_index ;
00194    return ( tmp ) ;
00195 }

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

Reimplemented in dchain::WholeItr< T >, and dchain::WholeItr< T >.

00183 {
00184    ++m_index ;
00185    return ( *this ) ;
00186 }

template<class CandidateClass>
WholeCandidateItr< CandidateClass >& dchain::WholeCandidateItr< CandidateClass >::operator+= (  difference_type  n  ) 
 

Reimplemented in dchain::WholeItr< T >, and dchain::WholeItr< T >.

template<class CandidateClass>
WholeCandidateItr< CandidateClass > & dchain::WholeCandidateItr< CandidateClass >::operator+= (  difference_type  n  )  [inline]
 

Reimplemented in dchain::WholeItr< T >, and dchain::WholeItr< T >.

00217 {
00218    m_index += n ;
00219    return( *this ) ;
00220 }

template<class CandidateClass>
difference_type dchain::WholeCandidateItr< CandidateClass >::operator- (  const WholeCandidateItr< CandidateClass > &  aOtherItr  )  const
 

template<class CandidateClass>
WholeCandidateItr< CandidateClass > dchain::WholeCandidateItr< CandidateClass >::operator- (  difference_type  n  ) 
 

Reimplemented in dchain::WholeItr< T >, and dchain::WholeItr< T >.

template<class CandidateClass>
WholeCandidateItr< CandidateClass >::difference_type dchain::WholeCandidateItr< CandidateClass >::operator- (  const WholeCandidateItr< CandidateClass > &  aOtherItr  )  const [inline]
  

00268 {
00269    return ( m_index - aOtherItr.index() ) ;
00270 }

template<class CandidateClass>
WholeCandidateItr< CandidateClass > dchain::WholeCandidateItr< CandidateClass >::operator- (  difference_type  n  )  [inline]
 

Reimplemented in dchain::WholeItr< T >, and dchain::WholeItr< T >.

00241 {
00242    WholeCandidateItr tmp( *this ) ;
00243    return ( tmp -= n ) ;
00244 }

template<class CandidateClass>
WholeCandidateItr< CandidateClass > dchain::WholeCandidateItr< CandidateClass >::operator-- (  int   ) 
 

Reimplemented in dchain::WholeItr< T >, and dchain::WholeItr< T >.

template<class CandidateClass>
WholeCandidateItr< CandidateClass >& dchain::WholeCandidateItr< CandidateClass >::operator-- (   ) 
 

Reimplemented in dchain::WholeItr< T >, and dchain::WholeItr< T >.

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

Reimplemented in dchain::WholeItr< T >, and dchain::WholeItr< T >.

00208 {
00209    WholeCandidateItr tmp( *this ) ;
00210    --m_index ;
00211    return ( tmp ) ;
00212 }

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

Reimplemented in dchain::WholeItr< T >, and dchain::WholeItr< T >.

00200 {
00201    --m_index ;
00202    return ( *this ) ;
00203 }

template<class CandidateClass>
WholeCandidateItr< CandidateClass >& dchain::WholeCandidateItr< CandidateClass >::operator-= (  difference_type  n  ) 
 

Reimplemented in dchain::WholeItr< T >, and dchain::WholeItr< T >.

template<class CandidateClass>
WholeCandidateItr< CandidateClass > & dchain::WholeCandidateItr< CandidateClass >::operator-= (  difference_type  n  )  [inline]
 

Reimplemented in dchain::WholeItr< T >, and dchain::WholeItr< T >.

00233 {
00234    m_index -= n ;
00235    return( *this ) ;
00236 }

template<class CandidateClass>
bool dchain::WholeCandidateItr< CandidateClass >::operator< (  const WholeCandidateItr< CandidateClass > &  aOtherItr  )  const
 

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

00291 {
00292    return ( ( m_index < aOtherItr.index() ) &&
00293             ( m_indexedCandidates == aOtherItr.indexedCandidates() ) ) ;
00294 }

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

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

00315 {
00316    return ( ( m_index <= aOtherItr.index() ) &&
00317             ( m_indexedCandidates == aOtherItr.indexedCandidates() ) ) ;
00318 }

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

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

00170 {
00171    m_indexedCandidates = aOtherItr.indexedCandidates() ;
00172    m_index = aOtherItr.index() ;
00173    return ( *this ) ;
00174 }

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

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

00275 {
00276    return ( ( m_index == aOtherItr.index() ) &&
00277             ( m_indexedCandidates == aOtherItr.indexedCandidates() ) ) ;
00278 }

template<class CandidateClass>
bool dchain::WholeCandidateItr< CandidateClass >::operator> (  const WholeCandidateItr< CandidateClass > &  aOtherItr  )  const
 

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

00299 {
00300    return ( ( m_index > aOtherItr.index() ) &&
00301             ( m_indexedCandidates == aOtherItr.indexedCandidates() ) ) ;
00302 }

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

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

00307 {
00308    return ( ( m_index >= aOtherItr.index() ) &&
00309             ( m_indexedCandidates == aOtherItr.indexedCandidates() ) ) ;
00310 }

template<class CandidateClass>
const LabeledCandidate< CandidateClass >& dchain::WholeCandidateItr< CandidateClass >::operator[] (  size_type  n  )  const
 

Reimplemented in dchain::WholeItr< T >, and dchain::WholeItr< T >.

template<class CandidateClass>
const LabeledCandidate< CandidateClass > & dchain::WholeCandidateItr< CandidateClass >::operator[] (  size_type  n  )  const [inline]
 

Reimplemented in dchain::WholeItr< T >, and dchain::WholeItr< T >.

00260 {
00261    return ( (*m_indexedCandidates).labeledCandidateClass( m_index + n ) ) ;
00262 }

Friends And Related Function Documentation

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

Member Data Documentation

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

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

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

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