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)
{
  if (!vector) 
  { 
    return; 
  }
  if (deleteEntries) 
  { 
    vector->destroy(); 
  }
  ML_DELETE(vector);
}


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()
{
  clear();
}


template <class T>
void CSOObjectVector<T>::clear()
{
  if (capacity > 0) 
  {
    ML_DELETE_ARRAY(block);
  }
  length = capacity = 0;
}


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()
{
  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)
{
  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] = NULL;
  }
}


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)
{
  int pos = lookup(elem);
  if (pos != -1)
  { 
    deleteAt(pos); 
  }
  return pos;
}


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)
{
  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