JsonValue.h

#pragma once
 
#include "Library.h"
 
#include <cmath>
#include <cstdint>
#include <initializer_list>
#include <map>
#include <optional>
#include <stdexcept>
#include <string>
#include <string_view>
#include <type_traits>
#include <variant>
#include <vector>
 
namespace CesiumUtility {
 
template <typename T, typename U>
constexpr std::optional<T> losslessNarrow(U u) noexcept {
  constexpr const bool is_different_signedness =
      (std::is_signed<T>::value != std::is_signed<U>::value);
 
  const T t = static_cast<T>(u);
 
  if (static_cast<U>(t) != u ||
      (is_different_signedness && ((t < T{}) != (u < U{})))) {
    return std::nullopt;
  }
 
  return t;
}
 
template <typename T, typename U>
constexpr T losslessNarrowOrDefault(U u, T defaultValue) noexcept {
  constexpr const bool is_different_signedness =
      (std::is_signed<T>::value != std::is_signed<U>::value);
 
  const T t = static_cast<T>(u);
 
  if (static_cast<U>(t) != u ||
      (is_different_signedness && ((t < T{}) != (u < U{})))) {
    return defaultValue;
  }
 
  return t;
}
 
class CESIUMUTILITY_API JsonValue final {
public:
  using Null = std::nullptr_t;
 
  using Bool = bool;
 
  using String = std::string;
 
  using Object = std::map<std::string, JsonValue>;
 
  using Array = std::vector<JsonValue>;
 
  JsonValue() noexcept : value() {}
 
  JsonValue(std::nullptr_t) noexcept : value(nullptr) {}
 
  JsonValue(double v) noexcept {
    if (std::isnan(v) || std::isinf(v)) {
      value = nullptr;
    } else {
      value = v;
    }
  }
 
  JsonValue(std::int8_t v) noexcept : value(static_cast<std::int64_t>(v)) {}
 
  JsonValue(std::uint8_t v) noexcept : value(static_cast<std::uint64_t>(v)) {}
 
  JsonValue(std::int16_t v) noexcept : value(static_cast<std::int64_t>(v)) {}
 
  JsonValue(std::uint16_t v) noexcept : value(static_cast<std::uint64_t>(v)) {}
 
  JsonValue(std::int32_t v) noexcept : value(static_cast<std::int64_t>(v)) {}
 
  JsonValue(std::uint32_t v) noexcept : value(static_cast<std::uint64_t>(v)) {}
 
  JsonValue(std::int64_t v) noexcept : value(v) {}
 
  JsonValue(std::uint64_t v) noexcept : value(v) {}
 
  JsonValue(bool v) noexcept : value(v) {}
 
  JsonValue(const std::string& v) : value(v) {}
 
  JsonValue(std::string&& v) noexcept : value(std::move(v)) {}
 
  JsonValue(const char* v) : value(std::string(v)) {}
 
  JsonValue(const std::map<std::string, JsonValue>& v) : value(v) {}
 
  JsonValue(std::map<std::string, JsonValue>&& v) : value(std::move(v)) {}
 
  JsonValue(const std::vector<JsonValue>& v) : value(v) {}
 
  JsonValue(std::vector<JsonValue>&& v) noexcept : value(std::move(v)) {}
 
  JsonValue(std::initializer_list<JsonValue> v)
      : value(std::vector<JsonValue>(v)) {}
 
  JsonValue(std::initializer_list<std::pair<const std::string, JsonValue>> v)
      : value(std::map<std::string, JsonValue>(v)) {}
 
  [[nodiscard]] const JsonValue*
  getValuePtrForKey(const std::string& key) const;
  [[nodiscard]] JsonValue* getValuePtrForKey(const std::string& key);
 
  template <typename T>
  const T* getValuePtrForKey(const std::string& key) const {
    const JsonValue* pValue = this->getValuePtrForKey(key);
    if (!pValue) {
      return nullptr;
    }
 
    return std::get_if<T>(&pValue->value);
  }
 
  template <typename T> T* getValuePtrForKey(const std::string& key) {
    JsonValue* pValue = this->getValuePtrForKey(key);
    return std::get_if<T>(&pValue->value);
  }
 
  template <
      typename To,
      typename std::enable_if<
          std::is_integral<To>::value ||
          std::is_floating_point<To>::value>::type* = nullptr>
  [[nodiscard]] std::optional<To>
  getSafeNumericalValueForKey(const std::string& key) const {
    const Object& pObject = std::get<Object>(this->value);
    const auto it = pObject.find(key);
    if (it == pObject.end()) {
      return std::nullopt;
    }
    return it->second.getSafeNumber<To>();
  }
 
  template <
      typename To,
      typename std::enable_if<
          std::is_integral<To>::value ||
          std::is_floating_point<To>::value>::type* = nullptr>
  [[nodiscard]] To getSafeNumericalValueOrDefaultForKey(
      const std::string& key,
      To defaultValue) const {
    const Object& pObject = std::get<Object>(this->value);
    const auto it = pObject.find(key);
    if (it == pObject.end()) {
      return defaultValue;
    }
    return it->second.getSafeNumberOrDefault<To>(defaultValue);
  }
 
  [[nodiscard]] inline bool hasKey(const std::string& key) const {
    const Object* pObject = std::get_if<Object>(&this->value);
    if (!pObject) {
      return false;
    }
 
    return pObject->find(key) != pObject->end();
  }
 
  template <
      typename To,
      typename std::enable_if<
          std::is_integral<To>::value ||
          std::is_floating_point<To>::value>::type* = nullptr>
  [[nodiscard]] std::optional<To> getSafeNumber() const {
    const std::uint64_t* uInt = std::get_if<std::uint64_t>(&this->value);
    if (uInt) {
      return losslessNarrow<To>(*uInt);
    }
 
    const std::int64_t* sInt = std::get_if<std::int64_t>(&this->value);
    if (sInt) {
      return losslessNarrow<To>(*sInt);
    }
 
    const double* real = std::get_if<double>(&this->value);
    if (real) {
      return losslessNarrow<To>(*real);
    }
 
    return std::nullopt;
  }
 
  template <
      typename To,
      typename std::enable_if<
          std::is_integral<To>::value ||
          std::is_floating_point<To>::value>::type* = nullptr>
  [[nodiscard]] To getSafeNumberOrDefault(To defaultValue) const noexcept {
    const std::uint64_t* uInt = std::get_if<std::uint64_t>(&this->value);
    if (uInt) {
      return losslessNarrowOrDefault<To>(*uInt, defaultValue);
    }
 
    const std::int64_t* sInt = std::get_if<std::int64_t>(&this->value);
    if (sInt) {
      return losslessNarrowOrDefault<To>(*sInt, defaultValue);
    }
 
    const double* real = std::get_if<double>(&this->value);
    if (real) {
      return losslessNarrowOrDefault<To>(*real, defaultValue);
    }
 
    return defaultValue;
  }
 
  [[nodiscard]] inline const JsonValue::Object& getObject() const {
    return std::get<JsonValue::Object>(this->value);
  }
 
  [[nodiscard]] inline const JsonValue::String& getString() const {
    return std::get<String>(this->value);
  }
 
  [[nodiscard]] inline const JsonValue::Array& getArray() const {
    return std::get<JsonValue::Array>(this->value);
  }
 
  [[nodiscard]] std::vector<std::string>
  getArrayOfStrings(const std::string& defaultString) const;
 
  [[nodiscard]] inline bool getBool() const {
    return std::get<bool>(this->value);
  }
 
  [[nodiscard]] inline double getDouble() const {
    return std::get<double>(this->value);
  }
 
  [[nodiscard]] std::uint64_t getUint64() const {
    return std::get<std::uint64_t>(this->value);
  }
 
  [[nodiscard]] std::int64_t getInt64() const {
    return std::get<std::int64_t>(this->value);
  }
 
  [[nodiscard]] inline bool getBoolOrDefault(bool defaultValue) const noexcept {
    const auto* v = std::get_if<bool>(&this->value);
    if (v) {
      return *v;
    }
 
    return defaultValue;
  }
 
  [[nodiscard]] inline const JsonValue::String
  getStringOrDefault(String defaultValue) const {
    const auto* v = std::get_if<JsonValue::String>(&this->value);
    if (v) {
      return *v;
    }
 
    return defaultValue;
  }
 
  [[nodiscard]] inline double
  getDoubleOrDefault(double defaultValue) const noexcept {
    const auto* v = std::get_if<double>(&this->value);
    if (v) {
      return *v;
    }
 
    return defaultValue;
  }
 
  [[nodiscard]] inline std::uint64_t
  getUint64OrDefault(std::uint64_t defaultValue) const noexcept {
    const auto* v = std::get_if<std::uint64_t>(&this->value);
    if (v) {
      return *v;
    }
 
    return defaultValue;
  }
 
  [[nodiscard]] inline std::int64_t
  getInt64OrDefault(std::int64_t defaultValue) const noexcept {
    const auto* v = std::get_if<std::int64_t>(&this->value);
    if (v) {
      return *v;
    }
 
    return defaultValue;
  }
 
  [[nodiscard]] inline bool isNull() const noexcept {
    return std::holds_alternative<Null>(this->value);
  }
 
  [[nodiscard]] inline bool isNumber() const noexcept {
    return isDouble() || isUint64() || isInt64();
  }
 
  [[nodiscard]] inline bool isBool() const noexcept {
    return std::holds_alternative<Bool>(this->value);
  }
 
  [[nodiscard]] inline bool isString() const noexcept {
    return std::holds_alternative<String>(this->value);
  }
 
  [[nodiscard]] inline bool isObject() const noexcept {
    return std::holds_alternative<Object>(this->value);
  }
 
  [[nodiscard]] inline bool isArray() const noexcept {
    return std::holds_alternative<Array>(this->value);
  }
 
  [[nodiscard]] inline bool isDouble() const noexcept {
    return std::holds_alternative<double>(this->value);
  }
 
  [[nodiscard]] inline bool isUint64() const noexcept {
    return std::holds_alternative<std::uint64_t>(this->value);
  }
 
  [[nodiscard]] inline bool isInt64() const noexcept {
    return std::holds_alternative<std::int64_t>(this->value);
  }
 
  inline bool operator==(const JsonValue& rhs) const noexcept {
    return this->value == rhs.value;
  };
 
  int64_t getSizeBytes() const noexcept {
    struct Operation {
      int64_t operator()([[maybe_unused]] const Null& /*inside*/) { return 0; }
      int64_t operator()([[maybe_unused]] const double& /*inside*/) {
        return 0;
      }
      int64_t operator()([[maybe_unused]] const std::uint64_t& /*inside*/) {
        return 0;
      }
      int64_t operator()([[maybe_unused]] const std::int64_t& /*inside*/) {
        return 0;
      }
      int64_t operator()([[maybe_unused]] const Bool& /*inside*/) { return 0; }
      int64_t operator()(const String& inside) {
        return int64_t(inside.capacity() * sizeof(char));
      }
      int64_t operator()(const Object& inside) {
        int64_t accum = 0;
        accum +=
            int64_t(inside.size() * (sizeof(std::string) + sizeof(JsonValue)));
        for (const auto& [k, v] : inside) {
          accum += int64_t(k.capacity() * sizeof(char) - sizeof(std::string));
          accum += v.getSizeBytes() - int64_t(sizeof(JsonValue));
        }
 
        return accum;
      }
      int64_t operator()(const Array& inside) {
        int64_t accum = 0;
        accum += int64_t(sizeof(JsonValue) * inside.capacity());
        for (const JsonValue& v : inside) {
          accum += v.getSizeBytes() - int64_t(sizeof(JsonValue));
        }
        return accum;
      }
    };
 
    return static_cast<int64_t>(sizeof(JsonValue)) +
           std::visit(Operation{}, this->value);
  }
 
  std::variant<
      Null,
      double,
      std::uint64_t,
      std::int64_t,
      Bool,
      String,
      Object,
      Array>
      value;
};
} // namespace CesiumUtility