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

Go to the documentation of this file.

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

#ifndef __WEMContainer_H
#define __WEMContainer_H

#include "WEMBase/WEMPrimitive.h"
#include "WEMVector.h"


ML_START_NAMESPACE


template <class T>
class WEMContainer : public WEMVector<WEMPrimitive> 
{
public:

  WEMContainer(unsigned int init = 0,unsigned int bs = 8192);
  ~WEMContainer();
  T* at(unsigned int pos);
  const T* at(unsigned int pos) const;
  void swap(unsigned int i,unsigned int j);
  unsigned int append(WEMPrimitive *wp);
  int remove(WEMPrimitive *wp);
  void replace(WEMPrimitive *wp,unsigned int pos);
  virtual void destroy();
};


template <class T>
WEMContainer<T>::WEMContainer(unsigned int init,unsigned int bs) :
WEMVector<WEMPrimitive>(init,bs) 
{  
}


template <class T>
WEMContainer<T>::~WEMContainer()
{
}


template <class T>
T* WEMContainer<T>::at(unsigned int pos) 
{
  WEMPrimitive *wp = WEMVector<WEMPrimitive>::at(pos);
  if (wp) 
  {
    return reinterpret_cast<T*>(wp); 
  } 
  else 
  { 
    return NULL; 
  }
}


template <class T>
const T* WEMContainer<T>::at(unsigned int pos) const
{
  return at(pos);
}


template <class T>
void WEMContainer<T>::destroy()
{
  //    This is the only safe way to delete entries in this vector!!
  //
  //    Everything else (no overloading, parent call, direct block access)
  //    goes to WEMVector and causes 'double free or corruption'

  const unsigned int n = num();

  for (unsigned int i=0;i<n;i++) 
  {
    if (at(i)) 
    { 
      T* toDel = at(i); 
      ML_DELETE(toDel); 
    }
    WEMVector<WEMPrimitive>::replace(NULL,i);
  }
  clear();
}


template <class T>
void WEMContainer<T>::swap(unsigned int i, unsigned int j)
{
  WEMVector<WEMPrimitive>::swap(i,j);
  at(i)->setHeapPosition(i);
  at(j)->setHeapPosition(j);
}


template <class T>
unsigned int WEMContainer<T>::append(WEMPrimitive *wp) 
{
  if (wp == NULL)                  { return (num()-1); }
  if (wp->getHeapPosition() != -1) { return (num()-1); }

  const int vecLength = WEMVector<WEMPrimitive>::appendUnsafe(wp);
  last()->setHeapPosition(num()-1);
  return vecLength;
}


template <class T>
void WEMContainer<T>::replace(WEMPrimitive *wp, unsigned int pos)
{
  WEMVector<WEMPrimitive>::replace(wp,pos);
  if (wp) 
  { 
    wp->setHeapPosition(pos); 
  }
}


template <class T>
int WEMContainer<T>::remove(WEMPrimitive *wp)
{
  if (wp == NULL)  { return -1; }
  const int i = wp->getHeapPosition();
  const int n = num();
  if (i >= n)      { return -1; }
  if (i <= -1)     { return -1; }

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

  return i;
}


ML_END_NAMESPACE

#endif //__WEMContainer_H