MetadataConversions.h

#pragma once
 
#include <CesiumGltf/PropertyTypeTraits.h>
#include <CesiumUtility/JsonValue.h>
 
#include <glm/common.hpp>
#include <glm/gtx/string_cast.hpp>
 
#include <cerrno>
#include <cstdint>
#include <optional>
#include <string>
#include <string_view>
 
namespace CesiumGltf {
template <typename TTo, typename TFrom, typename Enable = void>
struct MetadataConversions {
  static std::optional<TTo> convert(TFrom /*from*/) { return std::nullopt; }
};
 
template <typename T> struct MetadataConversions<T, T> {
  static std::optional<T> convert(T from) { return from; }
};
 
#pragma region Conversions to boolean
template <typename TFrom>
struct MetadataConversions<
    bool,
    TFrom,
    std::enable_if_t<CesiumGltf::IsMetadataScalar<TFrom>::value>> {
  static std::optional<bool> convert(TFrom from) {
    return from != static_cast<TFrom>(0);
  }
};
 
template <> struct MetadataConversions<bool, std::string_view> {
private:
  static bool
  isEqualCaseInsensitive(const std::string_view& a, const std::string_view& b) {
    if (a.size() != b.size()) {
      return false;
    }
 
    for (size_t i = 0; i < a.size(); i++) {
      if (std::tolower(a[i]) != std::tolower(b[i])) {
        return false;
      }
    }
    return true;
  }
 
public:
  static std::optional<bool> convert(const std::string_view& from) {
    if (isEqualCaseInsensitive(from, "1") ||
        isEqualCaseInsensitive(from, "true") ||
        isEqualCaseInsensitive(from, "yes")) {
      return true;
    }
 
    if (isEqualCaseInsensitive(from, "0") ||
        isEqualCaseInsensitive(from, "false") ||
        isEqualCaseInsensitive(from, "no")) {
      return false;
    }
 
    return std::nullopt;
  }
};
 
template <> struct MetadataConversions<bool, std::string> {
public:
  static std::optional<bool> convert(const std::string& from) {
    return MetadataConversions<bool, std::string_view>::convert(
        std::string_view(from.data(), from.size()));
  }
};
 
#pragma endregion
 
#pragma region Conversions to integer
template <typename TTo, typename TFrom>
struct MetadataConversions<
    TTo,
    TFrom,
    std::enable_if_t<
        CesiumGltf::IsMetadataInteger<TTo>::value &&
        CesiumGltf::IsMetadataInteger<TFrom>::value &&
        !std::is_same_v<TTo, TFrom>>> {
  static std::optional<TTo> convert(TFrom from) {
    return CesiumUtility::losslessNarrow<TTo, TFrom>(from);
  }
};
 
template <typename TTo, typename TFrom>
struct MetadataConversions<
    TTo,
    TFrom,
    std::enable_if_t<
        CesiumGltf::IsMetadataInteger<TTo>::value &&
        CesiumGltf::IsMetadataFloating<TFrom>::value>> {
  static std::optional<TTo> convert(TFrom from) {
    if (double(std::numeric_limits<TTo>::max()) < from ||
        double(std::numeric_limits<TTo>::lowest()) > from) {
      // Floating-point number is outside the range of this integer type.
      return std::nullopt;
    }
 
    return static_cast<TTo>(from);
  }
};
 
template <typename TTo>
struct MetadataConversions<
    TTo,
    std::string,
    std::enable_if_t<
        CesiumGltf::IsMetadataInteger<TTo>::value && std::is_signed_v<TTo>>> {
  static std::optional<TTo> convert(const std::string& from) {
    if (from.size() == 0) {
      // Return early. Otherwise, empty strings will be parsed as 0, which is
      // misleading.
      return std::nullopt;
    }
 
    errno = 0;
 
    char* pLastUsed;
    int64_t parsedValue = std::strtoll(from.c_str(), &pLastUsed, 10);
    if (errno == 0 && pLastUsed == from.c_str() + from.size()) {
      // Successfully parsed the entire string as an integer of this type.
      return CesiumUtility::losslessNarrow<TTo, int64_t>(parsedValue);
    }
 
    errno = 0;
 
    // Failed to parse as an integer. Maybe we can parse as a double and
    // truncate it?
    double parsedDouble = std::strtod(from.c_str(), &pLastUsed);
    if (errno == 0 && pLastUsed == from.c_str() + from.size()) {
      // Successfully parsed the entire string as a double.
      // Convert it to an integer if we can.
      double truncated = glm::trunc(parsedDouble);
 
      int64_t asInteger = static_cast<int64_t>(truncated);
      double roundTrip = static_cast<double>(asInteger);
      if (roundTrip == truncated) {
        return CesiumUtility::losslessNarrow<TTo, int64_t>(asInteger);
      }
    }
 
    return std::nullopt;
  }
}; // namespace CesiumGltf
 
template <typename TTo>
struct MetadataConversions<
    TTo,
    std::string,
    std::enable_if_t<
        CesiumGltf::IsMetadataInteger<TTo>::value && !std::is_signed_v<TTo>>> {
  static std::optional<TTo> convert(const std::string& from) {
    if (from.size() == 0) {
      // Return early. Otherwise, empty strings will be parsed as 0, which is
      // misleading.
      return std::nullopt;
    }
 
    if (from.find('-') != std::string::npos) {
      // The string must be manually checked for a negative sign because for
      // std::strtoull accepts negative numbers and bitcasts them, which is not
      // desired!
      return std::nullopt;
    }
 
    errno = 0;
 
    char* pLastUsed;
    uint64_t parsedValue = std::strtoull(from.c_str(), &pLastUsed, 10);
    if (errno == 0 && pLastUsed == from.c_str() + from.size()) {
      // Successfully parsed the entire string as an integer of this type.
      return CesiumUtility::losslessNarrow<TTo, uint64_t>(parsedValue);
    }
 
    // Failed to parse as an integer. Maybe we can parse as a double and
    // truncate it?
    errno = 0;
 
    double parsedDouble = std::strtod(from.c_str(), &pLastUsed);
    if (errno == 0 && pLastUsed == from.c_str() + from.size()) {
      // Successfully parsed the entire string as a double.
      // Convert it to an integer if we can.
      double truncated = glm::trunc(parsedDouble);
 
      uint64_t asInteger = static_cast<uint64_t>(truncated);
      double roundTrip = static_cast<double>(asInteger);
      if (roundTrip == truncated) {
        return CesiumUtility::losslessNarrow<TTo, uint64_t>(asInteger);
      }
    }
 
    return std::nullopt;
  }
};
 
template <typename TTo>
struct MetadataConversions<
    TTo,
    std::string_view,
    std::enable_if_t<CesiumGltf::IsMetadataInteger<TTo>::value>> {
  static std::optional<TTo> convert(const std::string_view& from) {
    if (from.size() == 0) {
      // Return early. Otherwise, empty strings will be parsed as 0, which is
      // misleading.
      return std::nullopt;
    }
 
    // Amazingly, C++ has no* string parsing functions that work with strings
    // that might not be null-terminated. So we have to copy to a std::string
    // (which _is_ guaranteed to be null terminated) before parsing.
    // * except std::from_chars, but compiler/library support for the
    //   floating-point version of that method is spotty at best.
    return MetadataConversions<TTo, std::string>::convert(std::string(from));
  }
};
 
template <typename TTo>
struct MetadataConversions<
    TTo,
    bool,
    std::enable_if_t<CesiumGltf::IsMetadataInteger<TTo>::value>> {
  static std::optional<TTo> convert(bool from) { return from ? 1 : 0; }
};
#pragma endregion
 
#pragma region Conversions to float
template <> struct MetadataConversions<float, bool> {
  static std::optional<float> convert(bool from) { return from ? 1.0f : 0.0f; }
};
 
template <typename TFrom>
struct MetadataConversions<
    float,
    TFrom,
    std::enable_if_t<CesiumGltf::IsMetadataInteger<TFrom>::value>> {
  static std::optional<float> convert(TFrom from) {
    return static_cast<float>(from);
  }
};
 
template <> struct MetadataConversions<float, double> {
  static std::optional<float> convert(double from) {
    if (from > std::numeric_limits<float>::max() ||
        from < std::numeric_limits<float>::lowest()) {
      return std::nullopt;
    }
    return static_cast<float>(from);
  }
};
 
template <> struct MetadataConversions<float, std::string> {
  static std::optional<float> convert(const std::string& from) {
    if (from.size() == 0) {
      // Return early. Otherwise, empty strings will be parsed as 0, which is
      // misleading.
      return std::nullopt;
    }
 
    errno = 0;
 
    char* pLastUsed;
    float parsedValue = std::strtof(from.c_str(), &pLastUsed);
    if (errno == 0 && pLastUsed == from.c_str() + from.size() &&
        !std::isinf(parsedValue)) {
      // Successfully parsed the entire string as a float.
      return parsedValue;
    }
    return std::nullopt;
  }
};
 
template <> struct MetadataConversions<float, std::string_view> {
  static std::optional<float> convert(const std::string_view& from) {
    if (from.size() == 0) {
      // Return early. Otherwise, empty strings will be parsed as 0, which is
      // misleading.
      return std::nullopt;
    }
    // Amazingly, C++ has no* string parsing functions that work with strings
    // that might not be null-terminated. So we have to copy to a std::string
    // (which _is_ guaranteed to be null terminated) before parsing.
    // * except std::from_chars, but compiler/library support for the
    //   floating-point version of that method is spotty at best.
    return MetadataConversions<float, std::string>::convert(
        std::string(from.data(), from.size()));
  }
};
#pragma endregion
 
#pragma region Conversions to double
template <> struct MetadataConversions<double, bool> {
  static std::optional<double> convert(bool from) { return from ? 1.0 : 0.0; }
};
 
template <typename TFrom>
struct MetadataConversions<
    double,
    TFrom,
    std::enable_if_t<CesiumGltf::IsMetadataInteger<TFrom>::value>> {
  static std::optional<double> convert(TFrom from) {
    return static_cast<double>(from);
  }
};
 
template <> struct MetadataConversions<double, float> {
  static std::optional<double> convert(float from) {
    return static_cast<double>(from);
  }
};
 
template <> struct MetadataConversions<double, std::string> {
  static std::optional<double> convert(const std::string& from) {
    if (from.size() == 0) {
      // Return early. Otherwise, empty strings will be parsed as 0, which is
      // misleading.
      return std::nullopt;
    }
 
    errno = 0;
 
    char* pLastUsed;
    double parsedValue = std::strtod(from.c_str(), &pLastUsed);
    if (errno == 0 && pLastUsed == from.c_str() + from.size() &&
        !std::isinf(parsedValue)) {
      // Successfully parsed the entire string as a double.
      return parsedValue;
    }
    return std::nullopt;
  }
};
 
template <> struct MetadataConversions<double, std::string_view> {
  static std::optional<double> convert(const std::string_view& from) {
    if (from.size() == 0) {
      // Return early. Otherwise, empty strings will be parsed as 0, which is
      // misleading.
      return std::nullopt;
    }
 
    // Amazingly, C++ has no* string parsing functions that work with strings
    // that might not be null-terminated. So we have to copy to a std::string
    // (which _is_ guaranteed to be null terminated) before parsing.
    // * except std::from_chars, but compiler/library support for the
    //   floating-point version of that method is spotty at best.
    return MetadataConversions<double, std::string>::convert(std::string(from));
  }
};
#pragma endregion
 
#pragma region Conversions to string
template <> struct MetadataConversions<std::string, bool> {
  static std::optional<std::string> convert(bool from) {
    return from ? "true" : "false";
  }
};
 
template <typename TFrom>
struct MetadataConversions<
    std::string,
    TFrom,
    std::enable_if_t<IsMetadataScalar<TFrom>::value>> {
  static std::optional<std::string> convert(TFrom from) {
    return std::to_string(from);
  }
};
 
template <typename TFrom>
struct MetadataConversions<
    std::string,
    TFrom,
    std::enable_if_t<
        IsMetadataVecN<TFrom>::value || IsMetadataMatN<TFrom>::value>> {
  static std::optional<std::string> convert(const TFrom& from) {
    return glm::to_string(from);
  }
};
 
template <> struct MetadataConversions<std::string, std::string_view> {
  static std::optional<std::string> convert(const std::string_view& from) {
    return std::string(from.data(), from.size());
  }
};
 
#pragma endregion
 
#pragma region Conversions to glm::vecN
template <typename TTo>
struct MetadataConversions<
    TTo,
    bool,
    std::enable_if_t<IsMetadataVecN<TTo>::value>> {
  static std::optional<TTo> convert(bool from) {
    return from ? TTo(1) : TTo(0);
  }
};
 
template <typename TTo, typename TFrom>
struct MetadataConversions<
    TTo,
    TFrom,
    std::enable_if_t<
        CesiumGltf::IsMetadataVecN<TTo>::value &&
        CesiumGltf::IsMetadataScalar<TFrom>::value>> {
  static std::optional<TTo> convert(TFrom from) {
    using ToValueType = typename TTo::value_type;
 
    std::optional<ToValueType> maybeValue =
        MetadataConversions<ToValueType, TFrom>::convert(from);
    if (maybeValue) {
      ToValueType value = *maybeValue;
      return TTo(value);
    }
 
    return std::nullopt;
  }
};
 
template <typename TTo, typename TFrom>
struct MetadataConversions<
    TTo,
    TFrom,
    std::enable_if_t<
        CesiumGltf::IsMetadataVecN<TTo>::value &&
        CesiumGltf::IsMetadataVecN<TFrom>::value &&
        !std::is_same_v<TTo, TFrom>>> {
  static std::optional<TTo> convert(TFrom from) {
    TTo result = TTo(0);
 
    constexpr glm::length_t validLength =
        glm::min(TTo::length(), TFrom::length());
 
    using ToValueType = typename TTo::value_type;
    using FromValueType = typename TFrom::value_type;
 
    for (glm::length_t i = 0; i < validLength; i++) {
      auto maybeValue =
          MetadataConversions<ToValueType, FromValueType>::convert(from[i]);
      if (!maybeValue) {
        return std::nullopt;
      }
 
      result[i] = *maybeValue;
    }
 
    return result;
  }
};
#pragma endregion
 
#pragma region Conversions to glm::matN
template <typename TTo>
struct MetadataConversions<
    TTo,
    bool,
    std::enable_if_t<IsMetadataMatN<TTo>::value>> {
  static std::optional<TTo> convert(bool from) {
    return from ? TTo(1) : TTo(0);
  }
};
 
template <typename TTo, typename TFrom>
struct MetadataConversions<
    TTo,
    TFrom,
    std::enable_if_t<
        CesiumGltf::IsMetadataMatN<TTo>::value &&
        CesiumGltf::IsMetadataScalar<TFrom>::value>> {
  static std::optional<TTo> convert(TFrom from) {
    using ToValueType = typename TTo::value_type;
 
    std::optional<ToValueType> maybeValue =
        MetadataConversions<ToValueType, TFrom>::convert(from);
    if (!maybeValue) {
      return std::nullopt;
    }
 
    ToValueType value = *maybeValue;
    return TTo(value);
  }
};
 
template <typename TTo, typename TFrom>
struct MetadataConversions<
    TTo,
    TFrom,
    std::enable_if_t<
        CesiumGltf::IsMetadataMatN<TTo>::value &&
        CesiumGltf::IsMetadataMatN<TFrom>::value &&
        !std::is_same_v<TTo, TFrom>>> {
  static std::optional<TTo> convert(TFrom from) {
    TTo result = TTo(0);
 
    constexpr glm::length_t validLength =
        glm::min(TTo::length(), TFrom::length());
 
    using ToValueType = typename TTo::value_type;
    using FromValueType = typename TFrom::value_type;
 
    for (glm::length_t c = 0; c < validLength; c++) {
      for (glm::length_t r = 0; r < validLength; r++) {
        auto maybeValue =
            MetadataConversions<ToValueType, FromValueType>::convert(
                from[c][r]);
        if (!maybeValue) {
          return std::nullopt;
        }
 
        result[c][r] = *maybeValue;
      }
    }
 
    return result;
  }
};
#pragma endregion
 
} // namespace CesiumGltf