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;
};
} // namespace CesiumUtility