MEM_alloc_string_storage.hh

Go to the documentation of this file.

/* SPDX-FileCopyrightText: 2024 Blender Authors
 *
 * SPDX-License-Identifier: GPL-2.0-or-later */
#pragma once
 
#include <any>
#include <cassert>
#include <string>
#include <unordered_map>
 
namespace intern::memutil {
 
template<typename keyT, template<typename> typename hashT> class AllocStringStorage {
  std::unordered_map<keyT, std::string, hashT<keyT>> storage_;
 
 public:
  bool contains(const keyT &key)
  {
    return storage_.count(key) != 0;
  }
 
  const char *find(const keyT &key)
  {
    if (storage_.count(key) != 0) {
      return storage_[key].c_str();
    }
    return nullptr;
  }
 
  const char *insert(const keyT &key, std::string alloc_string)
  {
#ifndef NDEBUG
    assert(storage_.count(key) == 0);
#endif
    return (storage_[key] = std::move(alloc_string)).c_str();
  }
};
 
namespace internal {
 
class AllocStringStorageContainer {
  std::unordered_map<std::string, std::any> storage_;
 
 public:
  template<typename keyT, template<typename> typename hashT>
  std::any &ensure_storage(const std::string &storage_identifier)
  {
    if (storage_.count(storage_identifier) == 0) {
      AllocStringStorage<keyT, hashT> storage_for_identifier;
      return (storage_[storage_identifier] = std::make_any<AllocStringStorage<keyT, hashT>>(
                  std::move(storage_for_identifier)));
    }
    return storage_[storage_identifier];
  }
};
 
AllocStringStorageContainer &ensure_storage_container();
 
}  // namespace internal
 
template<typename keyT, template<typename> typename hashT>
AllocStringStorage<keyT, hashT> &alloc_string_storage_get(const std::string &storage_identifier)
{
  internal::AllocStringStorageContainer &storage_container = internal::ensure_storage_container();
  std::any &storage = storage_container.ensure_storage<keyT, hashT>(storage_identifier);
  return std::any_cast<AllocStringStorage<keyT, hashT> &>(storage);
}
 
}  // namespace intern::memutil