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()

  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); }

  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();
  }

  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;
  }

private:
  Q_DISABLE_COPY(GmDualVectorR);

  size_t _size; 
};




#endif