TDynamicBuffer.h

Go to the documentation of this file.

#pragma once
#include <cassert>
#include <malloc.h>
#include <misc/gen/dbgutils.h>
#include <misc/global.h>
 
namespace sf
{
 
struct Allocator
{
    typedef int handle_t;
 
    static void* allocmem(handle_t&, size_t sz)
    {
      auto rv = ::malloc(sz);
      assert(rv);
      return rv;
    }
 
    static void* reallocmem(handle_t&, void* p, size_t sz)
    {
      auto rv = ::realloc(p, sz);
      assert(rv);
      return rv;
    }
 
    static void freemem(handle_t, void*& p)
    {
      ::free(p);
      p = nullptr;
    }
};
 
template<typename Alloc = Allocator>
class TDynamicBuffer
{
  public:
    TDynamicBuffer();
 
    TDynamicBuffer(const TDynamicBuffer& db);
 
    explicit TDynamicBuffer(size_t sz);
 
    ~TDynamicBuffer();
 
    void reserve(size_t sz, bool shrink = false);
 
    void resize(size_t sz, bool shrink = false);
 
    void offset(size_t ofs);
 
    [[nodiscard]] size_t offset() const;
 
    size_t size();
 
    [[nodiscard]] size_t size() const;
 
    [[nodiscard]] size_t reserved() const;
 
    void* data();
 
    [[nodiscard]] const void* data() const;
 
    char* c_str();
 
    [[nodiscard]] const char* c_str() const;
 
    template<typename T>
    T* ptr(size_t offset = 0)
    {
      return reinterpret_cast<T*>(static_cast<char*>(_reference->_data) + (offset + _reference->_offset));
    }
 
    template<typename T>
    const T* ptr(size_t offset = 0) const
    {
      return reinterpret_cast<T*>(static_cast<char*>(_reference->_data) + (offset + _reference->_offset));
    }
 
    void grow(size_t sz);
 
    void zero(bool reserved = false);
 
    void set(int c = 0, bool reserved = false);
 
    void* data(size_t offset);
 
    [[nodiscard]] const void* data(size_t offset) const;
 
    explicit operator void*();
 
    explicit operator const char*() const;
 
    explicit operator char*();
 
    explicit operator const void*() const;
 
    char& operator[](size_t i);
 
    char operator[](size_t i) const;
 
    TDynamicBuffer& operator=(const TDynamicBuffer& db);
 
  private:
    struct Reference
    {
        typename Alloc::handle_t Handle;
        // Determines if a destructor frees the memory.
        unsigned _usage;
        // Reported size of the buffer.
        size_t _size;
        // Actual allocated size of memory.
        size_t _allocated;
        // Byte offset to the data.
        size_t _offset;
        // Pointer to the allocated chunk of memory.
        void* _data;
    }* _reference;
};
 
template<typename Alloc>
inline size_t TDynamicBuffer<Alloc>::size()
{
  return _reference->_size - _reference->_offset;
}
 
template<typename Alloc>
inline size_t TDynamicBuffer<Alloc>::size() const
{
  return _reference->_size - _reference->_offset;
}
 
template<typename Alloc>
inline void* TDynamicBuffer<Alloc>::data()
{
  return static_cast<char*>(_reference->_data) + _reference->_offset;
}
 
template<typename Alloc>
inline const void* TDynamicBuffer<Alloc>::data() const
{
  return static_cast<char*>(_reference->_data) + _reference->_offset;
}
 
template<typename Alloc>
inline char* TDynamicBuffer<Alloc>::c_str()
{
  return static_cast<char*>(_reference->_data) + _reference->_offset;
}
 
template<typename Alloc>
inline const char* TDynamicBuffer<Alloc>::c_str() const
{
  return static_cast<char*>(_reference->_data) + _reference->_offset;
}
 
template<typename Alloc>
inline void* TDynamicBuffer<Alloc>::data(size_t offset)
{
  // Compensate for the offset.
  offset += _reference->_offset;
  return &(static_cast<char*>(_reference->_data))[offset];
}
 
template<typename Alloc>
inline const void* TDynamicBuffer<Alloc>::data(size_t offset) const
{
  // Compensate for the offset.
  offset += _reference->_offset;
  return &(static_cast<char*>(_reference->_data))[offset];
}
 
template<typename Alloc>
inline char TDynamicBuffer<Alloc>::operator[](size_t i) const
{
  // Compensate for the offset.
  i += _reference->_offset;
  if (i > _reference->_size)
  {
    throw std::out_of_range("Index out of range!");
  }
  // Make sure that no data is accessed beyond its real size.
  return (static_cast<char*>(_reference->_data))[i];
}
 
template<typename Alloc>
inline char& TDynamicBuffer<Alloc>::operator[](size_t i)
{
  if (i > _reference->_size)
  {
    throw std::out_of_range("Index out of range!");
  }
  // Make sure that no dta is accessed beyond its real size.
  return (static_cast<char*>(_reference->_data))[i];
}
 
template<typename Alloc>
TDynamicBuffer<Alloc>& TDynamicBuffer<Alloc>::operator=(const TDynamicBuffer<Alloc>& db)
{
  // Prevent self copying.
  if (this == &db)
  {
    return *this;
  }
  // Avoid assigning same instance.
  if (_reference == db._reference)
  {
    return *this;
  }
  // Decrease usage count.
  _reference->_usage--;
  // If the usage is zero the reference and data buffer in it must be deleted.
  if (_reference->_usage == 0)
  {
    Alloc::freemem(_reference->Handle, _reference->_data);
    delete _reference;
  }
  // Assign reference of passed instance.
  _reference = db._reference;
  // Increment usage count.
  _reference->_usage++;
  // Return myself.
  return *this;
}
 
template<typename Alloc>
inline TDynamicBuffer<Alloc>::operator void*()
{
  return _reference->_data;
}
 
template<typename Alloc>
inline TDynamicBuffer<Alloc>::operator const void*() const
{
  return _reference->_data;
}
 
template<typename Alloc>
inline TDynamicBuffer<Alloc>::operator char*()
{
  return _reference->_data;
}
 
template<typename Alloc>
inline TDynamicBuffer<Alloc>::operator const char*() const
{
  return _reference->_data;
}
 
template<typename Alloc>
TDynamicBuffer<Alloc>::TDynamicBuffer()
{
  _reference = new Reference;
  _reference->_size = 0;
  _reference->_allocated = 0;
  _reference->_offset = 0;
  _reference->_data = nullptr;
  _reference->_usage = 1;
}
 
template<typename Alloc>
inline TDynamicBuffer<Alloc>::TDynamicBuffer(const TDynamicBuffer& db)
{
  _reference = db._reference;
  _reference->_usage++;
}
 
template<typename Alloc>
TDynamicBuffer<Alloc>::TDynamicBuffer(size_t sz)
{
  _reference = new Reference;
  _reference->_size = 0;
  _reference->_allocated = 0;
  _reference->_offset = 0;
  _reference->_data = nullptr;
  _reference->_usage = 1;
  resize(sz);
}
 
template<typename Alloc>
inline TDynamicBuffer<Alloc>::~TDynamicBuffer()
{
  _reference->_usage--;
  // If the usage is zero the reference and data buffer in it must be deleted.
  if (_reference->_usage == 0)
  {
    if (_reference->_data)
    {
      Alloc::freemem(_reference->Handle, _reference->_data);
    }
    delete _reference;
  }
}
 
template<typename Alloc>
void TDynamicBuffer<Alloc>::reserve(size_t sz, bool shrink)
{
  if (sz == 0)
  {
    if (shrink)
    {
      _reference->_allocated = 0;
      _reference->_offset = 0;
      if (_reference->_data)
      {
        Alloc::freemem(_reference->Handle, _reference->_data);
      }
    }
  }
  else
  {
    // Compensate for the offset.
    sz += _reference->_offset;
    // Only allocate memory when the requested size is larger or
    // if the buffer size is allowed to shrink and the new size is smaller.
    if ((sz > _reference->_allocated) || (sz < _reference->_allocated && shrink))
    {// Determine what is to be called.
      if (_reference->_data)
      {
        _reference->_data = Alloc::reallocmem(_reference->Handle, _reference->_data, sz);
      }
      else
      {
        _reference->_data = Alloc::allocmem(_reference->Handle, sz);
      }
      // Adjust the real size member.
      _reference->_allocated = sz;
    }
  }
}
 
template<typename Alloc>
inline void TDynamicBuffer<Alloc>::offset(size_t ofs)
{
  // Assign the new offset.
  _reference->_offset = ofs;
}
 
template<typename Alloc>
inline size_t TDynamicBuffer<Alloc>::offset() const
{
  return _reference->_offset;
}
 
template<typename Alloc>
void TDynamicBuffer<Alloc>::resize(size_t sz, bool shrink)
{
  // When resizing to zero the offset can ben cleared too.
  if (sz)
  {
    sz += _reference->_offset;
  }
  else
  {
    _reference->_offset = 0;
  }
  // Make sure enough space is there.
  reserve(sz, shrink);
  // Assign the new virtual size of this buffer.
  _reference->_size = sz;
}
 
template<typename Alloc>
void TDynamicBuffer<Alloc>::grow(size_t sz)
{
  // Compensate with the offset.
  sz += _reference->_offset;
  // Only when there is a change.
  if (sz != _reference->_size)
  {
    // Check if the current allocated space is sufficient.
    if (sz <= _reference->_allocated)
    {
      // Assign the new virtual size.
      _reference->_size = sz;
    }
    else
    {
      // Make a copy of the reference.
      Reference ref = *_reference;
      // Reset the reference to the initial values except the usage member.
      _reference->_size = 0;
      _reference->_allocated = 0;
      _reference->_offset = 0;
      _reference->_data = nullptr;
      // Make resize fill the ref again and also allocate the new larger
      // block of memory.
      resize(sz - _reference->_offset);
      // Copy the old data to the new allocated memory.
#if IS_WIN
      memcpy_s(_reference->_data, ref._size, ref._data, ref._size);
#else
      memcpy(_reference->_data, ref._data, ref._size);
#endif
      // Delete the previous allocated memory.
      if (ref._data)
      {
        Alloc::freemem(ref.Handle, ref._data);
      }
    }
  }
}
 
template<typename Alloc>
inline void TDynamicBuffer<Alloc>::set(int c, bool reserved)
{
  memset(_reference->_data, c, reserved ? _reference->_allocated : _reference->_size);
}
 
template<typename Alloc>
inline void TDynamicBuffer<Alloc>::zero(bool reserved)
{
  set(0, reserved);
}
 
template<typename Alloc>
inline size_t TDynamicBuffer<Alloc>::reserved() const
{
  return _reference->_allocated - _reference->_offset;
}
 
typedef TDynamicBuffer<Allocator> DynamicBuffer;
 
}// namespace sf