WEMObjectVector.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 "MLWEMIncludes.h"
 
#include <mlTemplateHelpers.h>
 
ML_START_NAMESPACE
 
 
template <class T>
class WEMObjectVector
{
public:
  WEMObjectVector(unsigned int init = 0, unsigned int bs = 8192);
  ~WEMObjectVector();
  WEMObjectVector(WEMObjectVector &&other) noexcept;
  WEMObjectVector& operator=(WEMObjectVector &&other) noexcept;
  unsigned int num() const { return _length; }
  T* append(unsigned int *pos);
  void deleteAt(unsigned int pos);
  void destroy();
 
private:
 
  unsigned int _length;
  unsigned int _capacity;
  unsigned int _BLOCKSIZE;
  std::vector<T*> _block;
  std::vector<unsigned int> _deleted;
 
private:
  void expand();
};
 
 
namespace WEMInternal
{
  template <typename T>
  using object_reset_t = decltype(std::declval<T&>().reset());
 
  template <typename T>
  constexpr bool has_reset_v = is_detected_v<object_reset_t, T>;
}
 
 
template <class T>
WEMObjectVector<T>::WEMObjectVector(unsigned int init,unsigned int bs)
  : _length(0)
  , _capacity(0)
  , _BLOCKSIZE(bs)
{
  if (init > 0)
  {
    const unsigned int iBS = init/_BLOCKSIZE+1;
    _block.resize(iBS);
    for (unsigned int i = 0; i < iBS; i++)
    {
      _block[i] = new T[_BLOCKSIZE];
    }
    _capacity = iBS * _BLOCKSIZE;
  }
}
 
 
template <class T>
WEMObjectVector<T>::~WEMObjectVector()
{
  destroy();
}
 
template <class T>
WEMObjectVector<T>::WEMObjectVector(WEMObjectVector &&other) noexcept
{
  *this = std::move(other);
}
 
template <class T>
WEMObjectVector<T>& WEMObjectVector<T>::operator=(WEMObjectVector &&other) noexcept
{
  _length = other._length;
  other._length = 0;
  _capacity = other._capacity;
  other._capacity = 0;
  _BLOCKSIZE = other._BLOCKSIZE;
  other._BLOCKSIZE = 0;
  _block = std::move(other._block);
  _deleted = std::move(other._deleted);
  return *this;
}
 
 
template <class T>
void WEMObjectVector<T>::destroy()
{
  if (_capacity > 0)
  {
    for (size_t i=0;i<_block.size();i++)
    {
      delete [] _block[i]; _block[i] = nullptr;
    }
    _block.clear();
  }
  _deleted.clear();
  _length = _capacity = 0;
}
 
 
template <class T>
void WEMObjectVector<T>::expand()
{
  T* newBlock = nullptr;
  newBlock = new T[_BLOCKSIZE];
  _block.push_back(newBlock);
 
  _capacity += _BLOCKSIZE;
}
 
 
template <class T>
T* WEMObjectVector<T>::append(unsigned int *pos)
{
  T *elem = nullptr;
 
  if (!_deleted.empty())
  {
    *pos = _deleted.back();
    _deleted.pop_back();
    elem = &(_block[*pos/_BLOCKSIZE][*pos%_BLOCKSIZE]);
 
    // All type T must implement ::reset(). This should not be done via virtual
    // inheritance because the virtual base function hides the necessity to
    // implement this function in all derived classes.
    static_assert(WEMInternal::has_reset_v<T>, "Type T must implement ::reset() to reset the object back to the default constructed state.");
    elem->reset();
 
    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