MeVisLab/Standard/Sources/ML/MLCSO/CSOTools/CSOObjectVector.h

Go to the documentation of this file.

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

//----------------------------------------------------------------------------------


#ifndef __CSOObjectVector_H
#define __CSOObjectVector_H

#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] : NULL; }
  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)
{
  ML_TRACE_IN("template <class T>void deleteVector(CSOObjectVector<T> *vector,bool deleteEntries=true)");

  if (vector==NULL)  { return; }
  if (deleteEntries) { vector->destroy(); }
  ML_DELETE(vector);
}


template <class T>
CSOObjectVector<T>::CSOObjectVector(unsigned int init,unsigned int bs)
{
  ML_TRACE_IN("template <class T>CSOObjectVector<T>::CSOObjectVector(unsigned int init,unsigned int bs)");

  BLOCKSIZE = bs;
  length    = 0;
  capacity  = init;
  block     = NULL;
  if (capacity) {
    ML_CHECK_NEW(block, T*[capacity])      
  }
}


template <class T>
CSOObjectVector<T>::~CSOObjectVector()
{
  ML_TRACE_IN_TIME_CRITICAL("template <class T>CSOObjectVector<T>::~CSOObjectVector()");

  clear();
}


template <class T>
void CSOObjectVector<T>::clear()
{
  ML_TRACE_IN("template <class T>void CSOObjectVector<T>::clear()");

  if (capacity > 0) {
    ML_DELETE_ARRAY(block);
  }
  length = capacity = 0;
}


template <class T>
void CSOObjectVector<T>::destroy()
{
  ML_TRACE_IN("template <class T>void CSOObjectVector<T>::destroy()");

  for (unsigned int i = 0; i < length; ++i) {
    ML_DELETE(block[i]);            
  }
  length = 0;
}


template <class T>
void CSOObjectVector<T>::expand()
{
  ML_TRACE_IN("template <class T>void CSOObjectVector<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 CSOObjectVector<T>::append(T* elem)
{
  ML_TRACE_IN_TIME_CRITICAL("template <class T>unsigned int CSOObjectVector<T>::append(T* elem)");

  if (elem != NULL) {
    if (length == capacity) { expand(); }
    block[length] = elem;
    length++;
  }
  return length-1;
}


template <class T>
unsigned int CSOObjectVector<T>::appendUnsafe(T* elem)
{
  ML_TRACE_IN_TIME_CRITICAL("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)
{
  ML_TRACE_IN_TIME_CRITICAL("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)
{
  ML_TRACE_IN_TIME_CRITICAL("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)
{
  ML_TRACE_IN_TIME_CRITICAL("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()
{
  ML_TRACE_IN_TIME_CRITICAL("template <class T>void CSOObjectVector<T>::deleteLast()");

  if (length>0) { 
    length--; 
    block[length] = NULL;
  }
}


template <class T>
int CSOObjectVector<T>::lookup(T* elem) const
{
  ML_TRACE_IN_TIME_CRITICAL("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 = i;
      break;
    }
  }
  return pos;
}


template <class T>
int CSOObjectVector<T>::remove(T* elem)
{
  ML_TRACE_IN_TIME_CRITICAL("template <class T>int CSOObjectVector<T>::remove(T* elem)");

  int pos = lookup(elem);
  if (pos != -1) { deleteAt(pos); }
  return pos;
}


template <class T>
int CSOObjectVector<T>::removeUnSwapped(T* elem)
{
  ML_TRACE_IN_TIME_CRITICAL("template <class T>int CSOObjectVector<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 CSOObjectVector<T>::reserve(unsigned int init)
{
  ML_TRACE_IN("template <class T>void CSOObjectVector<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 // __CSOObjectVector_H