WEMIndexVector.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 "WEMObjectVector.h"
 
#include <mlContainerHelpers.h>
 
ML_START_NAMESPACE
 
 
template <class T>
class WEMIndexVector
{
public:
 
  WEMIndexVector(unsigned int init = 0,unsigned int bs = 8192);
  WEMIndexVector(WEMIndexVector &&other) noexcept = default;
  WEMIndexVector &operator=(WEMIndexVector &&other) noexcept = default;
  ~WEMIndexVector();
  unsigned int num() const {return static_cast<unsigned int>(_pointers.size());}
  T* at(unsigned int pos) const { return (pos<_pointers.size()) ? _pointers[pos] : nullptr; }
  T* first() { return at(0); }
  const T* first() const { return first(); }
  T* append();
  int remove(T *t);
  void destroy();
  void reorder(const std::vector<unsigned int>& indexOrder);
 
private:
 
  void swap(unsigned int i, unsigned int j);
  std::vector<T*> _pointers;
  std::vector<int> _positions;
  WEMObjectVector<T> _objects;
};
 
 
template <typename T>
using WEMIndexVectorProxy = ContainerProxy<WEMIndexVector<T>, T, unsigned int, &WEMIndexVector<T>::num, &WEMIndexVector<T>::at>;
 
 
template <class T>
WEMIndexVector<T>::WEMIndexVector(unsigned int init,unsigned int bs):_objects(init,bs)
{
  _pointers.reserve(init);
  _positions.reserve(init);
}
 
 
template <class T>
WEMIndexVector<T>::~WEMIndexVector()
{
  destroy();
}
 
 
template <class T>
void WEMIndexVector<T>::destroy()
{
  _pointers.clear();
  _positions.clear();
  _objects.destroy();
}
 
 
template <class T>
void WEMIndexVector<T>::swap(unsigned int i,unsigned int j)
{
  T* tTemp = nullptr;
  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>
T* WEMIndexVector<T>::append()
{
  unsigned int pos;
  T *t = _objects.append(&pos);
  if (t)
  {
    unsigned int entryNumber = static_cast<unsigned int>(_pointers.size());
    _pointers.push_back(t);
    _positions.push_back(pos);
    t->setEntryNumber(entryNumber);
  }
  return t;
}
 
 
template <class T>
int WEMIndexVector<T>::remove(T *t)
{
  if (t == nullptr) { 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);
 
  _pointers.pop_back();
  _positions.pop_back();
 
  return i;
}
 
 
template <class T>
void WEMIndexVector<T>::reorder(const std::vector<unsigned int>& indexOrder)
{
  if (indexOrder.size() == _pointers.size())
  {
    std::vector<T*> tempPointers;
    std::vector<int> tempPositions;
    tempPointers.resize(indexOrder.size());
    tempPositions.resize(indexOrder.size());
 
    for (size_t i = 0; i < indexOrder.size(); ++i)
    {
      const unsigned int index = indexOrder.at(i);
      tempPointers[i] = _pointers.at(index);
      tempPositions[i] = _positions.at(index);
    }
    for (size_t i = 0; i < indexOrder.size(); ++i)
    {
      _pointers[i] = tempPointers.at(i);
      _positions[i] = tempPositions.at(i);
      at(static_cast<unsigned int>(i))->setEntryNumber(static_cast<int>(i));
    }
  }
  else
  {
    WEM_ERROR("Vector of re-ordered indices must have the same size as the internal vectors!");
  }
}
 
 
ML_END_NAMESPACE