gmDualVector.h

Go to the documentation of this file.

/************************************************************************
**
** Copyright (C) 2014 by Carlos Augusto Teixera Mendes
** All rights reserved.
**
** This file is part of the "GeMA" software. It's use should respect
** the terms in the license agreement that can be found together
** with this source code.
** It is provided AS IS, with NO WARRANTY OF ANY KIND,
** INCLUDING THE WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR
** A PARTICULAR PURPOSE.
**
************************************************************************/
 
#ifndef _GEMA_DUAL_VECTOR_H_
#define _GEMA_DUAL_VECTOR_H_
 
#include "gmPODVector.h"
 
template <class T> class GmDualVector
{
public:
  static_assert(!QTypeInfo<T>::isComplex, "Not a POD type");
 
  typedef T DataType;
 
  GmDualVector() { _fixedData = NULL; _fixedSize = 0; }
 
  GmDualVector(size_t nvalues) { _fixedData = NULL; _fixedSize = 0; if(!addValues(nvalues)) throw(std::bad_alloc()); }
 
  ~GmDualVector() { free(_fixedData); } // Plain C deallocation - see addValues()
 
  bool isDual() const { return true; }
 
  size_t size() const { return _fixedSize + _growData.size(); }
 
  const T* iptr(size_t index) const
  {
    assert(index < size());
    if(index < _fixedSize) //[[likely]]
      return _fixedData + index;
    else //[[unlikely]]
      return _growData.data() + (index - _fixedSize);
  }
 
  T* iptr(size_t index)
  {
    assert(index < size());
    if(index < _fixedSize) //[[likely]]
      return _fixedData + index;
    else //[[unlikely]]
      return _growData.data() + (index - _fixedSize);
  }
 
  const T& operator[](size_t index) const { return *iptr(index); }
 
  T& operator[](size_t index) { return *iptr(index); }
 
  // -------------------
  class iterator
  {
  public:
    using iterator_category = std::random_access_iterator_tag;
    using value_type        = T;
    using difference_type   = std::ptrdiff_t;
    using pointer           = T*;
    using reference         = T&;
 
    iterator() : _vec(NULL), _index(0) {}
    iterator(GmDualVector<T>* vec, size_t index) : _vec(vec), _index(index) {}
 
    reference operator*()  const                  { return (*_vec)[_index]; }
    pointer   operator->() const                  { return &(*_vec)[_index]; }
    reference operator[](difference_type n) const { return (*_vec)[_index + n]; }
 
    iterator& operator++()                                 { ++_index; return *this; }
    iterator  operator++(int)                              { iterator tmp = *this; ++_index; return tmp; }
    iterator& operator--()                                 { --_index; return *this; }
    iterator  operator--(int)                              { iterator tmp = *this; --_index; return tmp; }
    iterator& operator+=(difference_type n)                { _index += n; return *this; }
    iterator& operator-=(difference_type n)                { _index -= n; return *this; }
    iterator  operator+ (difference_type n) const          { return iterator(_vec, _index + n); }
    iterator  operator- (difference_type n) const          { return iterator(_vec, _index - n); }
    difference_type operator-(const iterator& other) const { assert(_vec == other._vec); return (difference_type)_index - (difference_type)other._index; }
 
    bool operator==(const iterator& other) const { assert(_vec == other._vec); return _index == other._index; }
    bool operator!=(const iterator& other) const { assert(_vec == other._vec); return _index != other._index; }
    bool operator< (const iterator& other) const { assert(_vec == other._vec); return _index <  other._index; }
    bool operator> (const iterator& other) const { assert(_vec == other._vec); return _index >  other._index; }
    bool operator<=(const iterator& other) const { assert(_vec == other._vec); return _index <= other._index; }
    bool operator>=(const iterator& other) const { assert(_vec == other._vec); return _index >= other._index; }
 
  private:
    GmDualVector<T>* _vec;   
    size_t           _index; 
  };
 
  iterator begin() { return iterator(this, 0); }
  iterator end()   { return iterator(this, size()); }
  // -------------------
 
  bool addValues(size_t numAddedValues, bool tight = false)
  {
    S_TRACE();
    if(numAddedValues == 0)
      return true;
 
    if(size() > std::numeric_limits<size_t>::max() - numAddedValues)
    {
      gmWarnMsg(GmPanicLogger(), QObject::tr("Dual vector: Error adding %1 values. Vector size would surpass the maximum possible capacity.").arg(numAddedValues));
      return false;
    }
 
    // If the fixed part is empty, lets use it to store the requested size
    if(!_fixedData || (tight && !_growData.size()))
    {
      assert(_growData.size() == 0);
      // We use realloc for the allocation to, hopefully, grow the vector without moving when tight is true
      // We can do that since T is a POD type
      T* newPtr = (T*)realloc(_fixedData, (_fixedSize + numAddedValues) * sizeof(T));
      if(!newPtr)
      {
        if(!_fixedData)
          gmWarnMsg(GmPanicLogger(), QObject::tr("Dual vector: Error allocating a new vector with %1 entries of %2 bytes.")
                                                 .arg(_fixedSize + numAddedValues).arg(sizeof(T)));
        else
          gmWarnMsg(GmPanicLogger(), QObject::tr("Dual vector: Error resizing a vector with %1 entries of %2 bytes to a vector with %3 entries.")
                                                 .arg(_fixedSize).arg(sizeof(T)).arg(_fixedSize + numAddedValues));
        return false;
      }
      _fixedData  = newPtr;
      _fixedSize += numAddedValues;
      return true;
    }
 
    // Fixed part already exists. Lets use the grow part of the vector
    if(tight)
      return _growData.resize(_growData.size() + numAddedValues, GmPODVectorTightGrow);
    else
      return _growData.resize(_growData.size() + numAddedValues);
  }
 
  void restoreSize(size_t oldNumValues)
  {
    S_TRACE();
    assert(oldNumValues <= size());
 
    if(oldNumValues > 0)
    {
      assert(oldNumValues >= _fixedSize);
      _growData.resize(oldNumValues - _fixedSize);
    }
    else
      clear();
  }
 
  void clear()
  {
    S_TRACE();
    free(_fixedData);
    _fixedData = NULL; 
    _fixedSize = 0;
    _growData.clear();
  }
 
  void zero(size_t index = 0)
  { 
    S_TRACE();
 
    if(!_fixedSize)
      return;
    assert(index >= 0 && index < size());
 
    if(index >= _fixedSize) // All the zeroed data belongs to the grow part
      _growData.zero(index - _fixedSize);
    else // Index starts at the fixed part
    {
      memset(_fixedData + index, 0, (_fixedSize - index) * sizeof(T));
      _growData.zero();
    }
  }
 
  size_t usedMemory() const { return (_fixedSize + _growData.capacity()) * sizeof(T); }
 
  int numDumpBuffers() const { return 1 + (_growData.size() > 0); }
 
  char* dumpBuffer(int i) const { assert(i >= 0 && i < numDumpBuffers()); return (char*)(i ? _growData.data() : _fixedData); }
 
  size_t dumpBufferSize(int i) const { assert(i >= 0 && i < numDumpBuffers()); return (i ? _growData.size() : _fixedSize) * sizeof(T); }
 
protected:
  T*     _fixedData; 
  size_t _fixedSize; 
 
  GmPODVector<T> _growData; 
 
private:
  Q_DISABLE_COPY(GmDualVector);
};
 
 
 
template <class T> class GmDualVectorR : public GmDualVector<T>
{
public:
  GmDualVectorR() { _size = 0; }
 
  GmDualVectorR(size_t nvalues) : GmDualVector(nvalues) { _size = nvalues; }
 
  ~GmDualVectorR() { }
 
  size_t size() const
  { 
    assert(_size >= _fixedSize ? (_size == _fixedSize + _growData.size()) : (_growData.size() == 0));  
    return _size; 
  }
 
  bool addValues(size_t numAddedValues, bool tight = false)
  {
    S_TRACE();
 
    if(_size > std::numeric_limits<size_t>::max() - numAddedValues)
    {
      gmWarnMsg(GmPanicLogger(), QObject::tr("Dual vector: Error adding %1 values. Vector size would surpass the maximum possible capacity.").arg(numAddedValues));
      return false;
    }
 
    size_t nadd = numAddedValues;
    if(_size < _fixedSize) // There are available entries in the fixed part
    {
      assert(_growData.size() == 0);
      if(numAddedValues > _fixedSize - _size) // Carefull with negative values using size_t
        nadd = numAddedValues - (_fixedSize - _size);
      else
        nadd = 0;
    }
 
    if(!GmDualVector<T>::addValues(nadd, tight))
      return false;
    _size += numAddedValues;
    return true;
  }
 
  void restoreSize(size_t oldNumValues)
  {
    S_TRACE();
    GmDualVector<T>::restoreSize(qMax(oldNumValues, _fixedSize));
    _size = oldNumValues;
  }
 
  void removeValues(size_t index, size_t numValues)
  {
    S_TRACE();
    assert(index + numValues <= _size);
 
    if(index >= _fixedSize) // All the removed data belongs to the grow part
    {
      _growData.remove(index - _fixedSize, numValues);
      _size -= numValues;
    }
    else
    {
      // At least one of the removed entries is in the fixed part
      size_t fr = index + numValues;  // The first index in the remaining part of the vector that should be moved to the left
      size_t nr = _size - fr;         // The size of the remaining part of the vector that should be moved to the left
 
      // Move left all the remaining entries after the removed window
      for(size_t i = 0; i < nr; i++)
        *iptr(index+i) = *iptr(fr+i);
 
      // Adjust the sizes
      _size -= numValues;
      if(_size > _fixedSize) // Carefull with negative results using size_t
        _growData.resize(_size - _fixedSize);
      else
        _growData.clear();
    }
  }
 
  void clear()
  {
    S_TRACE();
    GmDualVector<T>::clear();
    _size = 0;
  }
 
  size_t dumpBufferSize(int i) const 
  { 
    assert(i >= 0 && i < numDumpBuffers()); 
    return (i ? _growData.size() : qMin(_size, _fixedSize)) * sizeof(T); 
  }
 
private:
  Q_DISABLE_COPY(GmDualVectorR);
 
  size_t _size; 
};
 
 
 
 
#endif