MeVisLab/Standard/Sources/ML/MLWEM/WEMDataStructure/WEMIndexVector.h

Go to the documentation of this file.

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

#ifndef __WEMIndexVector_H
#define __WEMIndexVector_H

#include "WEMObjectVector.h"


ML_START_NAMESPACE


template <class T>
class WEMIndexVector 
{
public:

  WEMIndexVector(unsigned int init = 0,unsigned int bs = 8192);
  virtual ~WEMIndexVector();
  inline unsigned int num() const {return length;}
  inline T* at(unsigned int pos) const { return (pos<length) ? pointers[pos] : NULL; }
  inline T* first() { return at(0); }
  inline const T* first() const { return first(); }
  T* append();
  int remove(T *t);
  virtual void destroy();

private:

  void swap(unsigned int i,unsigned int j);
  virtual void expand();
  unsigned int length;
  unsigned int capacity;
  unsigned int BLOCKSIZE;
  T* *pointers;
  int *positions;
  WEMObjectVector<T> *objects;
};


template <class T>
WEMIndexVector<T>::WEMIndexVector(unsigned int init,unsigned int bs)
{
  BLOCKSIZE = bs;
  length    = 0;
  capacity  = init;
  pointers  = NULL;
  positions = NULL;
  objects   = NULL;

  objects = new WEMObjectVector<T>(capacity,BLOCKSIZE);
  if (capacity > 0)
  {
    ML_CHECK_NEW(pointers,   T*[capacity]);
    ML_CHECK_NEW(positions, int[capacity]);
  }
  for (unsigned int i = 0; i < capacity; i++) 
  {
    pointers[i]  = NULL;
    positions[i] = -1;
  }
}


template <class T>
WEMIndexVector<T>::~WEMIndexVector()
{
  destroy();
  ML_DELETE(objects);
}


template <class T>
void WEMIndexVector<T>::destroy()
{
  ML_DELETE_ARRAY(pointers);
  ML_DELETE_ARRAY(positions);

  length = capacity = 0;
  objects->destroy();
}


template <class T>
void WEMIndexVector<T>::swap(unsigned int i,unsigned int j)
{
  T* tTemp = NULL;
  int pTemp;
  if (i != j) 
  {
    T*& pi = pointers[i];
    T*& pj = pointers[j];
    tTemp = pi;
    pi    = pj;
    pj    = tTemp;

    pTemp        = positions[i];
    positions[i] = positions[j];
    positions[j] = pTemp;

    pointers[i]->setEntryNumber(i);
    pointers[j]->setEntryNumber(j);
  }
}


template <class T>
void WEMIndexVector<T>::expand()
{
  T* *newpointers   = NULL;
  int *newpositions = NULL;
  ML_CHECK_NEW(newpointers, T*[capacity+BLOCKSIZE]);
  ML_CHECK_NEW(newpositions, int[capacity+BLOCKSIZE]);

  for (unsigned int i=0;i<length;i++) 
  {
    newpointers[i]  = pointers[i];
    newpositions[i] = positions[i];
  }

  ML_DELETE_ARRAY(pointers);
  ML_DELETE_ARRAY(positions);

  pointers = newpointers;
  positions = newpositions;

  capacity += BLOCKSIZE;
}


template <class T>
T* WEMIndexVector<T>::append()
{
  unsigned int pos;
  T *t = objects->append(&pos);
  if (t) 
  {
    if (length == capacity) 
    { 
      expand(); 
    }
    pointers[length] = t;
    positions[length] = pos;
    t->setEntryNumber(length);
    length++;
  }
  return t;
}


template <class T>
int WEMIndexVector<T>::remove(T *t)
{
  if (t == NULL) { return -1; }
  const int i = t->getEntryNumber();
  const int n = num();
  if (i >= n)     { return -1; }
  if (i <= -1)    { return -1; }

  objects->deleteAt(positions[i]);

  if (i != n - 1) 
  { 
    swap(i,n - 1); 
  }
  at(n - 1)->setEntryNumber(-1);

  if (length) length --;

  return i;
}


ML_END_NAMESPACE

#endif