WEMContainer.h

Go to the documentation of this file.

/*************************************************************************************
**
** Copyright 2007, MeVis Medical Solutions AG
**
** The user may use this file in accordance with the license agreement provided with
** the Software or, alternatively, in accordance with the terms contained in a
** written agreement between the user and MeVis Medical Solutions AG.
**
** For further information use the contact form at https://www.mevislab.de/contact
**
**************************************************************************************/
 
#pragma once
 
#include "WEMBase/WEMPrimitive.h"
#include "WEMVector.h"
 
 
ML_START_NAMESPACE
 
 
template <class T>
class WEMContainer : public WEMVector<WEMPrimitive>
{
public:
 
  WEMContainer(unsigned int init = 0);
  WEMContainer(WEMContainer &&) noexcept = default;
  WEMContainer& operator=(WEMContainer &&) noexcept = default;
  ~WEMContainer() override;
  T* at(unsigned int pos);
  const T* at(unsigned int pos) const;
  void swap(unsigned int i,unsigned int j) override;
  unsigned int append(WEMPrimitive *wp) override;
  int remove(WEMPrimitive *wp) override;
  void replace(WEMPrimitive *wp,unsigned int pos) override;
  void destroy() override;
};
 
 
template <class T>
WEMContainer<T>::WEMContainer(unsigned int init) :
WEMVector<WEMPrimitive>(init)
{
}
 
 
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 nullptr;
  }
}
 
 
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);
      delete toDel;
      toDel = nullptr;
    }
    WEMVector<WEMPrimitive>::replace(nullptr,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 == nullptr)                  { 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 == nullptr)  { 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