ImmutableString.cpp

#include <mutex>
#include <OsoMemoryProfiler/OsoMemoryProfiler.h>
#include "ImmutableString.h"
#include "Collections/PoolBase.h"
 
namespace {
  using namespace Cogs;
  using namespace Cogs::Collections;
 
  constexpr size_t S = sizeof(size_t);
  constexpr size_t shortStringSize = 32;
 
  constexpr size_t getByteSize(size_t N)
  {
    return S + N + 1;
  }
 
  constexpr bool isShortString(size_t byteSize)
  {
    return byteSize < shortStringSize;
  }
 
  struct StaticStore {
    PoolBase shortStringPool = PoolBase(shortStringSize, 128, 128, Memory::Allocator::defaultAllocator(), MemBlockType::Strings);
    std::mutex lock;
  };
 
  StaticStore& getStore()
  {
    static StaticStore store;
    return store;
  }
 
}
 
 
Cogs::ImmutableString::ImmutableString(const Cogs::StringView& view)
{
  release();
  if (!view.empty()) {
    const size_t N = view.size();
    assert(N != 0);
    assert(ptr == nullptr);
 
    const size_t byteSize = getByteSize(N);
    if (isShortString(byteSize)) {
      StaticStore& store = getStore();
      std::lock_guard guard(store.lock);
      ptr = static_cast<char*>(store.shortStringPool.allocate());
    }
    else {
      ptr = new char[byteSize];
      OsoMP_Allocate(uint8_t(MemBlockType::Strings), ptr, byteSize, nullptr, 0);
    }
    assert(ptr);
    std::memcpy(ptr, &N, S);
    std::memcpy(ptr + S, view.data(), N);
    ptr[S + N] = '\0';
  }
}
 
void Cogs::ImmutableString::release()
{
  if (ptr) {
    size_t N = 0;
    std::memcpy(&N, ptr, sizeof(N));
 
    const size_t byteSize = getByteSize(N);
    if (isShortString(byteSize)) {
      StaticStore& store = getStore();
      std::lock_guard guard(store.lock);
      store.shortStringPool.deallocate(ptr);
    }
    else {
      OsoMP_Free(uint8_t(MemBlockType::Strings), ptr, nullptr, 0);
      delete[] ptr;
    }
    ptr = nullptr;
  }
}