Strings.cpp

#include "Strings.h"
 
#include "MemoryContext.h"
 
#include "Foundation/Memory/Allocator.h"
#include "Foundation/Memory/MemoryBuffer.h"
#include "Foundation/Platform/Threads.h"
 
#include <string.h>
#include <vector>
#include <unordered_map>
 
 
namespace
{
  struct StringData
  {
    Cogs::Core::StringRef next = Cogs::Core::NoString;
    Cogs::StringView str;
  };
 
  struct StringStorage
  {
    StringStorage() : strings(Cogs::MemBlockType::Strings)
    {
      StringData& null = strings.grow();
      null.str = Cogs::StringView();
    }
 
    Cogs::Memory::TypedBuffer<StringData> strings;
    std::unordered_map<size_t, Cogs::Core::StringRef> stringsByHash;
    Cogs::Mutex stringMutex;
  };
 
  StringStorage& getStorage()
  {
    static StringStorage storage;
    return storage;
  }
 
}
 
 
void Cogs::Core::Strings::cleanup()
{
  auto& storage = getStorage();
  Cogs::Memory::TypedBuffer<StringData> strings;
  {
    LockGuard lock(storage.stringMutex);
    strings = std::move(storage.strings);
    storage.strings.clear();  // This will trigger an assert if we try to use strings any more
    storage.stringsByHash.clear();
  }
 
#if defined(__has_feature)
#if __has_feature(address_sanitizer)
#define ASAN 1
#endif
#endif
 
#if defined(DEBUG) || defined(COGS_PARANOIA) || defined(ASAN) || defined(OSOMP_EnableProfiler)
  // Not strictly necessary, but failing to deallocate these strings clutters leak analysis.
  for (auto& str : strings) {
    MemoryContext::getStringsAllocator()->deallocate(const_cast<char*>(str.str.data()), str.str.size() + 1, MemBlockType::Strings);
  }
#endif
}
 
 
Cogs::Core::StringRef Cogs::Core::Strings::add(StringView str)
{
  size_t hash = str.hash();
  
  StringStorage& storage = getStorage();
  LockGuard lock(storage.stringMutex);
  assert(storage.strings.byteSize() != 0);
 
  StringRef head = NoString;
 
  // If we have seen the hash before, run through the linked strings and see if
  // we find a match. Usually there is just one string, but in case of hash collisions,
  // there might be more than one.
  if (auto it = storage.stringsByHash.find(hash); it != storage.stringsByHash.end()) {
    head = it->second;
 
    StringRef ref = head;
    while (ref != NoString) {
      const StringData& stringData = storage.strings[ref.value];
      if (stringData.str == str) {
        // We have seen this string before, return reference.
        return ref;
      }
      ref = stringData.next;
    }
 
    // We have seen the hash, but not the string, the variable head new contains
    // the first string of the linked string of this hash.
  }
 
  // We have not seen this string before, allocate new string
  StringRef ref = StringRef{ static_cast<uint32_t>(storage.strings.size()) };
  char* strData = (char*)MemoryContext::getStringsAllocator()->allocate(str.size() + 1, 0, MemBlockType::Strings);
#ifdef _WIN32
  ::strncpy_s(strData, str.size() + 1, str.data(), str.size());
  strData[str.size()] = '\0';
#else
  strncpy(strData, str.data(), str.size());
  strData[str.size()] = '\0';
#endif
  StringData& stringData = storage.strings.grow();
  stringData.str = StringView(strData, str.size());
 
  // Link up new string by inserting it at the front. 
  stringData.next = head;
  storage.stringsByHash[hash] = ref;
 
  return ref;
}
 
Cogs::StringView Cogs::Core::Strings::get(StringRef ref)
{
  StringStorage& storage = getStorage();
  LockGuard lock(storage.stringMutex);
  assert(storage.strings.byteSize() != 0);
 
  return storage.strings[ref.value].str;
}
 
const char* Cogs::Core::Strings::getC(StringRef ref)
{
  StringStorage& storage = getStorage();
  LockGuard lock(storage.stringMutex);
  assert(storage.strings.byteSize() != 0);
 
  return storage.strings[ref.value].str.data();
}