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

Go to the documentation of this file.

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

#ifndef __WEMVector_H
#define __WEMVector_H

#include "MLWEMIncludes.h"


ML_START_NAMESPACE


template <class T>
class WEMVector 
{
public:

  WEMVector(unsigned int init = 0,unsigned int bs = 8192);
  virtual ~WEMVector();
  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 first();}
  inline T* last() {return at(_length-1);}
  inline const T* last() const {return last();}
  virtual unsigned int append(T* elem);
  virtual void swap(unsigned int p1,unsigned int p2);
  virtual void clear();
  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 destroy();
  virtual void replace(T* elem,unsigned int pos);
  void reserve(unsigned int init);

private:

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

protected:

  virtual void expand();
  virtual unsigned int appendUnsafe(T* elem);
};


template <class T>
WEMVector<T>::WEMVector(unsigned int init,unsigned int bs)
{
  _BLOCKSIZE = bs;
  _length    = 0;
  _capacity  = init;
  _block     = NULL;
  if (_capacity > 0)
  {
    ML_CHECK_NEW(_block, T*[_capacity])      
  }
  for (unsigned int i=0; i < _capacity; i++) 
  {
    _block[i] = NULL;
  }
}


template <class T>
WEMVector<T>::~WEMVector()
{
  clear();
}


template <class T>
void WEMVector<T>::clear()
{
  if (_capacity > 0) 
  {
    ML_DELETE_ARRAY(_block);
  }
  _length = _capacity = 0;
}


template <class T>
void WEMVector<T>::destroy()
{
  for (unsigned int i = 0; i < _length; i++) 
  {
    ML_DELETE(_block[i]);            
  }
  _length = 0;
}


template <class T>
void WEMVector<T>::expand()
{
  T* *newblock = NULL;
  ML_CHECK_NEW(newblock, T*[_capacity+_BLOCKSIZE]);

  for (unsigned int i = 0; i < _length; i++) 
  { 
    newblock[i] = _block[i]; 
  }
  ML_DELETE_ARRAY(_block); 

  _block = newblock;
  _capacity += _BLOCKSIZE;
}


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


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


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


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


template <class T>
void WEMVector<T>::deleteAt(unsigned int pos)
{
  if (pos != _length-1)
  {  
    swap(pos,_length-1); 
  }
  deleteLast();
}


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


template <class T>
int WEMVector<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 WEMVector<T>::remove(T* elem)
{
  const int pos = lookup(elem);
  if (pos != -1)
  { 
    deleteAt(pos); 
  }
  return pos;
}


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


template <class T>
void WEMVector<T>::reserve(unsigned int init)
{
  if (init <= _capacity) { return; }

  T* *newblock = NULL;
  ML_CHECK_NEW(newblock, T*[init]);  
  for (unsigned int i = 0; i < _length; i++) 
  { 
    newblock[i] = _block[i]; 
  }
  if(_capacity > 0) 
  { 
    ML_DELETE_ARRAY(_block); 
  }
  _block = newblock;
  _capacity = init;
}


ML_END_NAMESPACE

#endif // __WEMVector_H