MeVisLab/Standard/Sources/ML/MLWEM/WEMDataStructure/WEMFastVector.h

Go to the documentation of this file.

// **InsertLicense** code
//----------------------------------------------------------------------------------

#ifndef __WEMFastVector_H
#define __WEMFastVector_H

#include "MLWEMIncludes.h"

ML_START_NAMESPACE


template <class T>
class WEMFastVector 
{
public:

  WEMFastVector(unsigned int init);
  virtual ~WEMFastVector();
  inline unsigned int num() const {return _length;}
  inline T* at(unsigned int pos) const { return (pos < _length) ? _block[pos] : NULL; }
  inline T* first() {return at(0);}
  inline const T* first() const {return at(0);}
  inline T* last() {return at(_length - 1);}
  inline const T* last() const {return at(_length - 1);}
  virtual unsigned int append(T* elem);
  virtual void swap(unsigned int p1, unsigned int p2);
  virtual void clear();
  virtual void destroy();
  virtual void deleteAt(unsigned int pos);
  virtual void deleteLast();
  virtual int remove(T* elem);
  virtual int lookup(T* elem) const;
  virtual int removeUnSwapped(T* elem);
  virtual void replace(T* elem, unsigned int pos);

private:

  unsigned int _length;
  unsigned int _capacity;
  T* *_block;
};


template <class T>
WEMFastVector<T>::WEMFastVector(unsigned int init)
{
  _length    = 0;
  _capacity  = init;
  ML_CHECK_NEW(_block, T*[init]);

  for (unsigned int i = 0; i < init; i ++) 
  { 
    _block[i] = NULL; 
  }
}


template <class T>
WEMFastVector<T>::~WEMFastVector()
{
  destroy();
  ML_DELETE_ARRAY(_block);
}


template <class T>
void WEMFastVector<T>::clear()
{
  _length = 0;
}


template <class T>
void WEMFastVector<T>::destroy()
{
  // _capacity is used here to delete all blocks, also the hidden (deleted) ones
  for (unsigned int i = 0; i < _capacity; i ++) 
  { 
    ML_DELETE(_block[i]); 
  }
  _length = 0;
}


template <class T>
unsigned int WEMFastVector<T>::append(T* elem)
{
  if (elem)
  {
    if (_length < _capacity) 
    {
      _block[_length] = elem;
      _length ++;
    }
  }
  return _length - 1;
}


template <class T>
void WEMFastVector<T>::replace(T* elem, unsigned int pos)
{
  _block[pos] = elem;
}


template <class T>
void WEMFastVector<T>::swap(unsigned int p1, unsigned int p2)
{
  T* temp;
  if (p1 != p2) 
  {
    T*& pb1 = _block[p1];
    T*& pb2 = _block[p2];
    temp = pb1;
    pb1  = pb2;
    pb2  = temp;
  }
}


template <class T>
void WEMFastVector<T>::deleteAt(unsigned int pos)
{
  if (pos >= _length) { return; }

  if (pos != _length - 1) 
  {  
    swap(pos, _length - 1); 
  }
  deleteLast();
}


template <class T>
void WEMFastVector<T>::deleteLast()
{
  if (_length > 0) { _length --; }
}


template <class T>
int WEMFastVector<T>::lookup(T* elem) const
{
  int pos = -1;
  for (unsigned int i = 0; i < _length; i ++) 
  {
    if (at(i) == elem) 
    {
      pos = i;
      break;
    }
  }
  return pos;
}


template <class T>
int WEMFastVector<T>::remove(T* elem)
{
  int pos = lookup(elem);
  if (pos != -1) 
  { 
    deleteAt(pos); 
  }
  return pos;
}


template <class T>
int WEMFastVector<T>::removeUnSwapped(T* elem)
{
  int pos = lookup(elem);
  if (pos != -1) 
  {
    for (unsigned int i = pos; i < _length - 1; i ++)
    {
      _block[i] = _block[i + 1];
    }
    deleteLast();
  }
  return pos;
}


ML_END_NAMESPACE

#endif // __WEMFastVector_H