CSOObjectVector.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 "CSOHeapObject.h"
 
 
ML_START_NAMESPACE
 
 
template <class T>
class CSOObjectVector
{
 
public:
 
  CSOObjectVector(unsigned int init = 0,unsigned int bs = 65535);
  virtual ~CSOObjectVector();
 
  inline unsigned int num() const {return length;}
  inline T* atBoundsCheck(unsigned int pos) const { return (pos<length) ? block[pos] : nullptr; }
  inline T* at(unsigned int pos) const { return block[pos]; }
  inline T* firstBoundsCheck() const {return atBoundsCheck(0);}
  inline T* first() const {return at(0);}
  inline T* lastBoundsCheck() const {return atBoundsCheck(length-1);}
  inline 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 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>
void deleteVector(CSOObjectVector<T> *vector,bool deleteEntries=true)
{
  if (!vector)
  {
    return;
  }
  if (deleteEntries)
  {
    vector->destroy();
  }
  delete vector;
  vector = nullptr;
}
 
 
template <class T>
CSOObjectVector<T>::CSOObjectVector(unsigned int init,unsigned int bs)
{
  BLOCKSIZE = bs;
  length    = 0;
  capacity  = init;
  block     = nullptr;
  if (capacity)
  {
    block = new T * [capacity];
  }
}
 
 
template <class T>
CSOObjectVector<T>::~CSOObjectVector()
{
  clear();
}
 
 
template <class T>
void CSOObjectVector<T>::clear()
{
  if (capacity > 0)
  {
    delete [] block;
    block = nullptr;
  }
  length = capacity = 0;
}
 
 
template <class T>
void CSOObjectVector<T>::destroy()
{
  for (unsigned int i = 0; i < length; ++i)
  {
    delete block[i]; block[i] = nullptr;
  }
  length = 0;
}
 
 
template <class T>
void CSOObjectVector<T>::expand()
{
  T* *newblock = nullptr;
  newblock = new T*[capacity+BLOCKSIZE];
 
  for (unsigned int i = 0; i < length; ++i)
  {
    newblock[i] = block[i];
  }
  delete [] block;
  block = nullptr;
 
  block = newblock;
  capacity += BLOCKSIZE;
}
 
 
template <class T>
unsigned int CSOObjectVector<T>::append(T* elem)
{
  if (elem)
  {
    if (length == capacity)
    {
      expand();
    }
    block[length] = elem;
    length++;
  }
  return length-1;
}
 
 
template <class T>
unsigned int CSOObjectVector<T>::appendUnsafe(T* elem)
{
  if (length == capacity)
  {
    expand();
  }
  block[length] = elem;
  length++;
  return length-1;
}
 
 
template <class T>
void CSOObjectVector<T>::replace(T* elem,unsigned int pos)
{
  block[pos] = elem;
}
 
 
template <class T>
void CSOObjectVector<T>::swap(unsigned int p1,unsigned int p2)
{
  T* temp;
  if (p1 != p2)
  {
    T*& pb1 = block[p1]; //use a temp reference to avoid redundant dereferencing
    T*& pb2 = block[p2];
    temp = pb1;
    pb1 = pb2;
    pb2 = temp;
  }
}
 
 
template <class T>
void CSOObjectVector<T>::deleteAt(unsigned int pos)
{
  if (pos != length-1)
  {
    swap(pos,length-1);
  }
  deleteLast();
}
 
 
template <class T>
void CSOObjectVector<T>::deleteLast()
{
  if (length > 0)
  {
    length--;
    block[length] = nullptr;
  }
}
 
 
template <class T>
int CSOObjectVector<T>::lookup(T* elem) const
{
  int pos = -1;
  for (unsigned int i = 0; i < length; ++i)
  {
    if (at(i) == elem)
    {
      pos = static_cast<int>(i);
      break;
    }
  }
  return pos;
}
 
 
template <class T>
int CSOObjectVector<T>::remove(T* elem)
{
  int pos = lookup(elem);
  if (pos != -1)
  {
    deleteAt(static_cast<unsigned int>(pos));
  }
  return pos;
}
 
 
template <class T>
int CSOObjectVector<T>::removeUnSwapped(T* elem)
{
  const int pos = lookup(elem);
  if (pos != -1)
  {
    for (unsigned int i = static_cast<unsigned int>(pos); i < length-1; ++i)
    {
      block[i] = block[i+1];
    }
    deleteLast();
  }
  return pos;
}
 
 
template <class T>
void CSOObjectVector<T>::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(capacity > 0)
  {
    delete [] block;
    block = nullptr;
  }
  block = newblock;
  capacity = init;
}
 
 
ML_END_NAMESPACE