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

Go to the documentation of this file.

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

#ifndef __WEMObjectVector_H
#define __WEMObjectVector_H

#include "MLWEMIncludes.h"

ML_START_NAMESPACE


template <class T>
class WEMObjectVector 
{
public:

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

private:

  unsigned int length;
  unsigned int capacity;
  unsigned int BLOCKSIZE;
  T **block;
  std::vector<unsigned int> deleted;

protected:

  virtual void expand();
};


template <class T>
WEMObjectVector<T>::WEMObjectVector(unsigned int init,unsigned int bs)
{
  BLOCKSIZE = bs;
  length    = 0;
  capacity  = 0;
  block     = NULL;
  deleted.clear();
  
  if (init > 0)
  {
    const unsigned int iBS = init/BLOCKSIZE+1;
    ML_CHECK_NEW(block, T*[iBS])
    for (unsigned int i = 0; i < iBS; i++) 
    {
      ML_CHECK_NEW(block[i], T[BLOCKSIZE]);
    }
    capacity = iBS * BLOCKSIZE;
  }
}


template <class T>
WEMObjectVector<T>::~WEMObjectVector()
{
  destroy();
}


template <class T>
void WEMObjectVector<T>::destroy()
{
  if (capacity > 0) 
  {
    const unsigned int cBRatio = capacity/BLOCKSIZE;
    for (unsigned int i=0;i<cBRatio;i++) 
    {
      ML_DELETE_ARRAY(block[i]);
    }
    ML_DELETE_ARRAY(block);
  }
  deleted.clear();
  length = capacity = 0;
}


template <class T>
void WEMObjectVector<T>::expand()
{
  unsigned int i = 0;
  const unsigned int cBS = capacity/BLOCKSIZE;
  T* *newblock = NULL;

  ML_CHECK_NEW(newblock, T*[cBS+1]);
  for (i = 0; i < cBS; i++)
  { 
    newblock[i] = block[i]; 
  }

  ML_CHECK_NEW(newblock[cBS], T[BLOCKSIZE]);

  if (capacity > 0) 
  {
    ML_DELETE_ARRAY(block);
  }
  block = newblock;
  capacity += BLOCKSIZE;
}


template <class T>
T* WEMObjectVector<T>::append(unsigned int *pos)
{
  T *elem = NULL;

  if (deleted.size() > 0) 
  {
    *pos = deleted.back();
    deleted.pop_back();
    elem = &(block[*pos/BLOCKSIZE][*pos%BLOCKSIZE]);
    return elem;
  }

  if (length == capacity) 
  { 
    expand(); 
  }

  elem = &(block[length/BLOCKSIZE][length%BLOCKSIZE]);

  *pos = length;
  length ++;
  return elem;
}


template <class T>
void WEMObjectVector<T>::deleteAt(unsigned int pos)
{
  deleted.push_back(pos);
}


ML_END_NAMESPACE

#endif // __WEMObjectVector_H