BaseKeySortedVector< T, T_key > Class Template Reference

#include <NodeVector.h>

List of all members.


Detailed Description

template<class T, class T_key>
class BaseKeySortedVector< T, T_key >

A STL-vector that supports inserts sorted by an OverlayKey found somewhere in the type.

Author:
Sebastian Mies


Public Types

typedef std::vector< T
>::iterator 
iterator
typedef std::vector< T
>::const_iterator 
const_iterator

Public Member Functions

 BaseKeySortedVector (uint16_t maxSize=0, const Comparator< OverlayKey > *comparator=NULL)
 ~BaseKeySortedVector ()
bool isAddable (const T &element) const
bool isFull () const
bool isEmpty () const
bool add (const T &element)
const T & find (const OverlayKey &key) const

Static Public Attributes

static const T UNSPECIFIED_ELEMENT

Private Attributes

const Comparator< OverlayKey > * comparator
uint16_t maxSize


Member Typedef Documentation

template<class T, class T_key>
typedef std::vector<T>::const_iterator BaseKeySortedVector< T, T_key >::const_iterator

template<class T, class T_key>
typedef std::vector<T>::iterator BaseKeySortedVector< T, T_key >::iterator


Constructor & Destructor Documentation

template<class T, class T_key>
BaseKeySortedVector< T, T_key >::BaseKeySortedVector ( uint16_t  maxSize = 0,
const Comparator< OverlayKey > *  comparator = NULL 
) [inline]

00079                                                               :
00080         std::vector<T>(),
00081         comparator(comparator),
00082         maxSize(maxSize) {};

template<class T, class T_key>
BaseKeySortedVector< T, T_key >::~BaseKeySortedVector (  )  [inline]

00084 {};


Member Function Documentation

template<class T, class T_key>
bool BaseKeySortedVector< T, T_key >::add ( const T &  element  )  [inline]

00111     {
00112         // check if handle is addable
00113         if ( isAddable(element) )
00114         { // yes ->
00115 
00116             // add handle to the appropriate position
00117             if ( ( std::vector<T>::size() != 0 ) && comparator )
00118             {
00119                 for ( iterator i = std::vector<T>::begin();
00120                         i != std::vector<T>::end(); i++ )
00121                     if ( comparator->compare(T_key::key(element),
00122                                 T_key::key(*i)) < 0 )
00123                     {
00124                         std::vector<T>::insert( i, element );
00125                         break;
00126                     }
00127             }
00128             else
00129             {
00130                 push_back(element);
00131             }
00132 
00133             // adjust size
00134             if ((maxSize != 0) && (std::vector<T>::size() >= maxSize))
00135             {
00136                 std::vector<T>::resize(maxSize);
00137             }
00138 
00139             return true;
00140         }
00141         else
00142         {
00143             return false;
00144         }
00145 
00146     };

template<class T, class T_key>
const T& BaseKeySortedVector< T, T_key >::find ( const OverlayKey key  )  const [inline]

00149     {
00150         for ( const_iterator i = std::vector<T>::begin();
00151                 i != std::vector<T>::end(); i++)
00152         {
00153             if (T_key::key(*i) == key) return *i;
00154         }
00155         return UNSPECIFIED_ELEMENT;
00156     };

template<class T, class T_key>
bool BaseKeySortedVector< T, T_key >::isAddable ( const T &  element  )  const [inline]

00094     {
00095         return ( std::vector<T>::size() != maxSize ||
00096                 (comparator && ( comparator->compare( T_key::key(element),
00097                     T_key::key(std::vector<T>::back()) ) < 0 )));
00098     };

template<class T, class T_key>
bool BaseKeySortedVector< T, T_key >::isEmpty (  )  const [inline]

00106     {
00107         return (std::vector<T>::size() == 0);
00108     };

template<class T, class T_key>
bool BaseKeySortedVector< T, T_key >::isFull (  )  const [inline]

00101     {
00102         return (std::vector<T>::size() == maxSize);
00103     };


Member Data Documentation

template<class T, class T_key>
const Comparator<OverlayKey>* BaseKeySortedVector< T, T_key >::comparator [private]

template<class T, class T_key>
uint16_t BaseKeySortedVector< T, T_key >::maxSize [private]

template<class T, class T_key>
const T BaseKeySortedVector< T, T_key >::UNSPECIFIED_ELEMENT [static]


The documentation for this class was generated from the following file:
Generated on Fri May 11 14:52:39 2007 for ITM OverSim by  doxygen 1.4.7