WEMVector.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, int fixedBufferSize = 32>
class WEMVector
{
public:
 
  WEMVector(unsigned int init = 0);
  WEMVector(WEMVector &&other) noexcept;
  WEMVector &operator=(WEMVector &&other) noexcept;
 
  virtual ~WEMVector();
  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 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;
  T* *_block;
 
  T* _fixedBuffer[fixedBufferSize];
 
protected:
 
  virtual void expand();
  virtual unsigned int appendUnsafe(T* elem);
};
 
 
template <class T, int fixedBufferSize>
WEMVector<T, fixedBufferSize>::WEMVector(unsigned int init)
{
  _length    = 0;
  _capacity  = fixedBufferSize;
  _block     = _fixedBuffer;
 
  if (init > _capacity) {
    _capacity = init;
    _block = new T*[_capacity];
  }
}
 
template <class T, int fixedBufferSize>
WEMVector<T, fixedBufferSize>::WEMVector(WEMVector &&other) noexcept
{
  *this = std::move(other);
}
 
template <class T, int fixedBufferSize>
WEMVector<T, fixedBufferSize>& WEMVector<T, fixedBufferSize>::operator=(WEMVector &&other) noexcept
{
  _length = other._length;
  other._length = 0;
  _capacity = other._capacity;
  other._capacity = fixedBufferSize;
 
  if (other._block == other._fixedBuffer)
  {
    _block = _fixedBuffer;
    for (auto i = 0u; i < _length; ++i)
    {
      _fixedBuffer[i] = other._fixedBuffer[i];
    }
  }
  else
  {
    _block = other._block;
  }
  other._block = other._fixedBuffer;
 
  return *this;
}
 
 
template <class T, int fixedBufferSize>
WEMVector<T, fixedBufferSize>::~WEMVector()
{
  clear();
}
 
 
template <class T, int fixedBufferSize>
void WEMVector<T, fixedBufferSize>::clear()
{
  if (_block != _fixedBuffer)
  {
    delete [] _block;
    _block = nullptr;
  }
  _length = 0;
 
  _capacity = fixedBufferSize;
  _block = _fixedBuffer;
}
 
 
template <class T, int fixedBufferSize>
void WEMVector<T, fixedBufferSize>::destroy()
{
  for (unsigned int i = 0; i < _length; i++)
  {
    delete _block[i]; _block[i] = nullptr;
  }
  _length = 0;
}
 
 
template <class T, int fixedBufferSize>
void WEMVector<T, fixedBufferSize>::expand()
{
  reserve(_capacity * 2);
}
 
 
template <class T, int fixedBufferSize>
unsigned int WEMVector<T, fixedBufferSize>::append(T* elem)
{
  if (elem)
  {
    if (_length == _capacity)
    {
      expand();
    }
    _block[_length] = elem;
    _length++;
  }
  return _length-1;
}
 
 
template <class T, int fixedBufferSize>
unsigned int WEMVector<T, fixedBufferSize>::appendUnsafe(T* elem)
{
  if (_length == _capacity)
  {
    expand();
  }
  _block[_length] = elem;
  _length++;
  return _length-1;
}
 
 
template <class T, int fixedBufferSize>
void WEMVector<T, fixedBufferSize>::replace(T* elem,unsigned int pos)
{
  _block[pos] = elem;
}
 
 
template <class T, int fixedBufferSize>
void WEMVector<T, fixedBufferSize>::swap(unsigned int p1,unsigned int p2)
{
  T* temp = nullptr;
  if (p1 != p2)
  {
    T*& pb1 = _block[p1];
    T*& pb2 = _block[p2];
    temp = pb1;
    pb1  = pb2;
    pb2  = temp;
  }
}
 
 
template <class T, int fixedBufferSize>
void WEMVector<T, fixedBufferSize>::deleteAt(unsigned int pos)
{
  if (pos != _length-1)
  {
    swap(pos,_length-1);
  }
  deleteLast();
}
 
 
template <class T, int fixedBufferSize>
void WEMVector<T, fixedBufferSize>::deleteLast()
{
  if (_length > 0)
  {
    _length--;
  }
}
 
 
template <class T, int fixedBufferSize>
int WEMVector<T, fixedBufferSize>::lookup(T* elem) const
{
  int pos = -1;
  for (unsigned int i = 0; i < _length; i++)
  {
    if (_block[i] == elem)
    {
      pos = i;
      break;
    }
  }
  return pos;
}
 
 
template <class T, int fixedBufferSize>
int WEMVector<T, fixedBufferSize>::remove(T* elem)
{
  const int pos = lookup(elem);
  if (pos != -1)
  {
    deleteAt(pos);
  }
  return pos;
}
 
 
template <class T, int fixedBufferSize>
int WEMVector<T, fixedBufferSize>::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, int fixedBufferSize>
void WEMVector<T, fixedBufferSize>::reserve(unsigned int init)
{
  if (init <= _capacity) { return; }
 
  T* *newblock = nullptr;
  newblock = new T*[init];
  for (unsigned int i = 0; i < _length; i++)
  {
    newblock[i] = _block[i];
  }
  if (_block != _fixedBuffer)
  {
    delete [] _block;
    _block = nullptr;
  }
  _block = newblock;
  _capacity = init;
}
 
 
ML_END_NAMESPACE