ExtensibleObject.h

#pragma once
 
#include "JsonValue.h"
#include "Library.h"
 
#include <any>
#include <unordered_map>
#include <utility>
#include <vector>
 
namespace CesiumUtility {
struct CESIUMUTILITY_API ExtensibleObject {
  template <typename T> bool hasExtension() const noexcept {
    auto it = this->extensions.find(T::ExtensionName);
    return it != this->extensions.end();
  }
 
  template <typename T> const T* getExtension() const noexcept {
    auto it = this->extensions.find(T::ExtensionName);
    if (it == this->extensions.end()) {
      return nullptr;
    }
 
    return std::any_cast<T>(&it->second);
  }
 
  template <typename T> T* getExtension() noexcept {
    return const_cast<T*>(std::as_const(*this).getExtension<T>());
  }
 
  const JsonValue*
  getGenericExtension(const std::string& extensionName) const noexcept;
 
  JsonValue* getGenericExtension(const std::string& extensionName) noexcept;
 
  template <typename T, typename... ConstructorArgumentTypes>
  T& addExtension(ConstructorArgumentTypes&&... constructorArguments) {
    std::any& extension =
        extensions
            .try_emplace(
                T::ExtensionName,
                std::make_any<T>(std::forward<ConstructorArgumentTypes>(
                    constructorArguments)...))
            .first->second;
    return std::any_cast<T&>(extension);
  }
 
  template <typename T> void removeExtension() {
    extensions.erase(T::ExtensionName);
  }
 
  std::unordered_map<std::string, std::any> extensions;
 
  JsonValue::Object extras;
 
  JsonValue::Object unknownProperties;
 
  int64_t getSizeBytes() const {
    int64_t accum = 0;
    accum += int64_t(sizeof(ExtensibleObject));
 
    accum += int64_t(
        this->extras.size() * (sizeof(std::string) + sizeof(JsonValue)));
    for (const auto& [k, v] : this->extras) {
      accum += int64_t(k.capacity() * sizeof(char) - sizeof(std::string));
      accum += v.getSizeBytes() - int64_t(sizeof(JsonValue));
    }
 
    accum += int64_t(
        this->unknownProperties.size() *
        (sizeof(std::string) + sizeof(JsonValue)));
    for (const auto& [k, v] : this->unknownProperties) {
      accum += int64_t(k.capacity() * sizeof(char) - sizeof(std::string));
      accum += v.getSizeBytes() - int64_t(sizeof(JsonValue));
    }
 
    return accum;
  }
};
} // namespace CesiumUtility