WEMFastVector.h

Go to the documentation of this file.

/*************************************************************************************
**
** Copyright 2007, MeVis Medical Solutions AG
**
** The user may use this file in accordance with the license agreement provided with
** the Software or, alternatively, in accordance with the terms contained in a
** written agreement between the user and MeVis Medical Solutions AG.
**
** For further information use the contact form at https://www.mevislab.de/contact
**
**************************************************************************************/
 
#pragma once
 
#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] : nullptr; }
  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;
  _block = new T*[init];
 
  for (unsigned int i = 0; i < init; i ++)
  {
    _block[i] = nullptr;
  }
}
 
 
template <class T>
WEMFastVector<T>::~WEMFastVector()
{
  destroy();
  delete [] _block;
  _block = nullptr;
}
 
 
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 ++)
  {
    delete _block[i]; _block[i] = nullptr;
  }
  _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