ExtensionWriterContext.h

#pragma once
 
#include "CesiumJsonWriter/JsonWriter.h"
#include "CesiumJsonWriter/Library.h"
 
#include <any>
#include <functional>
#include <map>
#include <string>
#include <unordered_map>
 
namespace CesiumJsonWriter {
 
enum class ExtensionState {
  Enabled,
 
  Disabled
};
 
class CESIUMJSONWRITER_API ExtensionWriterContext {
private:
  template <typename TExtension>
  using ExtensionHandler = std::function<
      void(const TExtension&, JsonWriter&, const ExtensionWriterContext&)>;
 
public:
  template <typename TExtended, typename TExtensionHandler>
  void registerExtension(const std::string& extensionName) {
    using TExtension = typename TExtensionHandler::ValueType;
 
    auto it =
        this->_extensions.emplace(extensionName, ObjectTypeToHandler()).first;
    it->second.insert_or_assign(
        TExtended::TypeName,
        [](const std::any& obj,
           JsonWriter& jsonWriter,
           const ExtensionWriterContext& context) {
          return TExtensionHandler::write(
              std::any_cast<const TExtension&>(obj),
              jsonWriter,
              context);
        });
  }
 
  template <typename TExtended, typename TExtensionHandler>
  void registerExtension() {
    registerExtension<TExtended, TExtensionHandler>(
        TExtensionHandler::ExtensionName);
  }
 
  ExtensionState getExtensionState(const std::string& extensionName) const;
 
  void
  setExtensionState(const std::string& extensionName, ExtensionState newState);
 
  ExtensionHandler<std::any> createExtensionHandler(
      const std::string_view& extensionName,
      const std::any& obj,
      const std::string& extendedObjectType) const;
 
private:
  using ObjectTypeToHandler =
      std::unordered_map<std::string, ExtensionHandler<std::any>>;
  using ExtensionNameMap = std::map<std::string, ObjectTypeToHandler>;
 
  ExtensionNameMap _extensions;
  std::unordered_map<std::string, ExtensionState> _extensionStates;
};
 
} // namespace CesiumJsonWriter