MemoryBuffer.cpp

#include "MemoryBuffer.h"
 
#include "../StringView.h"
 
#include <algorithm>
#include <cstring>
 
std::string Cogs::Memory::MemToHexString(const void* memory, size_t size) {
  const char*       digits = "0123456789ABCDEF";
  std::string       output;
  const uint8_t*    ptr = static_cast<const uint8_t*>(memory);
  constexpr size_t  bytesPerLine = 32;
  uint32_t          offset = 0;
  char              buffer[16];
 
  output.reserve(size * 4);
 
  for (; size >= bytesPerLine; size -= bytesPerLine, offset += bytesPerLine) {
    snprintf(buffer, sizeof(buffer), "0x%08X: ", offset);
    output += buffer;
 
    for (size_t count = 0; count++ < bytesPerLine; ) {
      output += digits[*ptr >> 4];
      output += digits[*ptr++ & 0x0F];
      output += " ";
 
      if (!(count & 0x03)) {
        output += " ";
      }
    }
    output += "\n";
  }
  if (size) {
    snprintf(buffer, sizeof(buffer), "0x%08X: ", offset);
    output += buffer;
 
    for (size_t count = 0; size--; ) {
      output += digits[*ptr >> 4];
      output += digits[*ptr++ & 0x0F];
      output += " ";
 
      if (!(++count & 0x03)) {
        output += " ";
      }
    }
    output += "\n";
  }
  return output;
}
 
Cogs::Memory::MemoryBuffer::MemoryBuffer(const void* memory, size_t size) {
  buffer = const_cast<void*>(memory);
  currentSize = size;
  storageSize = 0;
  currentPos = 0;
  allocator = nullptr;
}
 
void Cogs::Memory::MemoryBuffer::reset(size_t size, Allocator * allocator)
{
  if (allocator == this->allocator) {
    resize(size, false, false);
  }
  else {
    release();
    this->allocator = allocator;
    resize(size, false, false);
  }
}
 
bool Cogs::Memory::MemoryBuffer::resize(size_t size, bool keep, bool forceRealloc) {
  assert(allocator);
 
  if (currentSize == size) {
    return true;
  }
 
  if (forceRealloc || (size > storageSize)) {
    void* newBuffer = nullptr;
 
    if (size) {
      newBuffer = allocator->allocate(size, 0, type);
 
      if (!newBuffer) {
        return false;
      }
      if (buffer && keep) {
        std::memcpy(newBuffer, buffer, std::min(size, currentSize));
      }
    }
    release();
 
    storageSize = size;
    buffer = newBuffer;
  }
  currentSize = size;
  currentPos = std::min(currentPos, currentSize);
  return true;
}
 
bool Cogs::Memory::MemoryBuffer::reserve(size_t size) {
  assert(allocator);
 
  if (size > storageSize) {
    void* newBuffer = allocator->allocate(size, 0, type);
 
    if (!newBuffer) {
      return false;
    }
    if (buffer) {
      std::memcpy(newBuffer, buffer, currentSize);
      allocator->deallocate(buffer, storageSize, type);
    }
    storageSize = size;
    buffer = newBuffer;
  }
  return true;
}
 
void Cogs::Memory::MemoryBuffer::copy(const MemoryBuffer & other) {
  resize(other.size(), false);
 
  if (size()) {
    std::memcpy(buffer, other.buffer, currentSize);
  }
  type = other.type;
}
 
void Cogs::Memory::MemoryBuffer::swap(MemoryBuffer & other) {
  std::swap(buffer, other.buffer);
  std::swap(storageSize, other.storageSize);
  std::swap(currentSize, other.currentSize);
  std::swap(currentPos, other.currentPos);
  std::swap(allocator, other.allocator);
  std::swap(type, other.type);
}
 
size_t Cogs::Memory::MemoryBuffer::read(void* dest, size_t noofbytes) {
  size_t  bytesRead = std::min(noofbytes, unreadSize());
 
  std::memcpy(dest, static_cast<uint8_t*>(buffer) + currentPos, bytesRead);
  currentPos += bytesRead;
 
  return bytesRead;
}
 
glm::vec2 Cogs::Memory::MemoryBuffer::readFloat2() {
  glm::vec2 v;
 
  v.x = readFloat();
  v.y = readFloat();
  return v;
}
 
glm::vec3 Cogs::Memory::MemoryBuffer::readFloat3() {
  glm::vec3 v;
 
  for (int i = 0; i < 3; ++i) {
    v[i] = readFloat();
  }
  return v;
}
 
glm::vec4 Cogs::Memory::MemoryBuffer::readFloat4() {
  glm::vec4 v;
 
  for (int i = 0; i < 4; ++i) {
    v[i] = readFloat();
  }
  return v;
}
 
glm::quat Cogs::Memory::MemoryBuffer::readQuaternion() {
  glm::quat q;
 
  for (int i = 0; i < 4; ++i) {
    q[i] = readFloat();
  }
  return q;
}
 
glm::mat4 Cogs::Memory::MemoryBuffer::readMatrix() {
  glm::mat4 m;
 
  for (int col = 0; col < 4; ++col) {
    m[col] = readFloat4();
  }
  return m;
}
 
std::string Cogs::Memory::MemoryBuffer::readString() {
  size_t      length = read32();
  std::string str;
 
  if (length) {
    str.resize(--length);
    read(str.data(), length);
 
    // Historically strings were written to MemoryBuffer with null-terminators.  For backwards compatibility
    // with older versions of ProximityView this functionality needs to be kept.  So skip over the null-
    // terminator we didn't read above.
    ++currentPos;
  }
  return str;
}
 
bool Cogs::Memory::MemoryBuffer::write(const void* src, size_t bytes) {
  if (!allocator) {
    return false;
  }
  if ((currentSize + bytes) > storageSize) {
    if (!reserve(std::max<size_t>(1024, std::max<size_t>(currentSize + bytes, storageSize * 3 / 2)))) {
      return false;
    }
  }
  memcpy(static_cast<uint8_t*>(buffer) + currentPos, src, bytes);
  currentPos += bytes;
  currentSize = currentPos;
  return true;
}
 
bool Cogs::Memory::MemoryBuffer::writeFloat2(const glm::vec2& value) {
  bool result = true;
 
  result &= writeFloat(value.x);
  result &= writeFloat(value.y);
 
  return result;
}
 
bool Cogs::Memory::MemoryBuffer::writeFloat3(const glm::vec3& value) {
  bool result = true;
 
  for (int i = 0; i < 3; ++i) {
    result &= writeFloat(value[i]);
  }
  return result;
}
 
bool Cogs::Memory::MemoryBuffer::writeFloat4(const glm::vec4& value) {
  bool result = true;
 
  for (int i = 0; i < 4; ++i) {
    result &= writeFloat(value[i]);
  }
  return result;
}
 
bool Cogs::Memory::MemoryBuffer::writeQuaternion(const glm::quat& value) {
  bool result = true;
 
  for (int i = 0; i < 4; ++i) {
    result &= writeFloat(value[i]);
  }
  return result;
}
 
bool Cogs::Memory::MemoryBuffer::writeMatrix(const glm::mat4& value) {
  bool result = true;
 
  for (int col = 0; col < 4; ++col) {
    result &= writeFloat4(value[col]);
  }
  return result;
}
 
bool Cogs::Memory::MemoryBuffer::writeString(const StringView& str) {
  size_t  length = str.size();
  bool    success = true;
 
  // Strings, unfortunately, need to be written with null-terminators to ensure newer versions
  // of ProximityView are binary compatible with older versions installed on customer vessels.
  success &= write32(static_cast<uint32_t>(length + 1));
  success &= write(str.data(), length);
  success &= write8(0);
 
  return success;
}
 
void Cogs::Memory::MemoryBuffer::seek(int64_t offset, Anchor from) {
  switch (from) {
    case Anchor::Start:     currentPos = offset;                break;
    case Anchor::Current:   currentPos += offset;               break;
    case Anchor::End:       currentPos = currentSize + offset;  break;
  }
  currentPos = std::clamp<int64_t>(currentPos, 0, currentSize);
}
 
bool Cogs::Memory::MemoryBuffer::areContentsEqual(const MemoryBuffer& rhs) const {
  if (size() == rhs.size()) {
    return !memcmp(data(), rhs.data(), size());
  }
  return false;
}
 
void Cogs::Memory::MemoryBuffer::release() {
  if (buffer) {
    if (allocator) {
      allocator->deallocate(buffer, storageSize, type);
    }
    buffer = nullptr;
    storageSize = 0;
    currentSize = 0;
  }
}
 
void Cogs::Memory::MemoryBuffer::changeType(MemBlockType newType)
{
  if (buffer && allocator) {
    allocator->changeType(buffer, storageSize, type, newType);
  }
  type = newType;
}