evaluator_value.h

#ifndef SOURCEMETA_BLAZE_EVALUATOR_VALUE_H
#define SOURCEMETA_BLAZE_EVALUATOR_VALUE_H
 
#include <sourcemeta/core/json.h>
#include <sourcemeta/core/jsonpointer.h>
#include <sourcemeta/core/regex.h>
 
#include <cstdint>       // std::uint8_t
#include <optional>      // std::optional
#include <string>        // std::string
#include <tuple>         // std::tuple
#include <unordered_set> // std::unordered_set
#include <utility>       // std::pair
#include <vector>        // std::vector
 
namespace sourcemeta::blaze {

struct ValueNone {
  [[nodiscard]] auto to_json() const -> sourcemeta::core::JSON {
    return sourcemeta::core::JSON{nullptr};
  }
 
  static auto from_json(const sourcemeta::core::JSON &)
      -> std::optional<ValueNone> {
    return ValueNone{};
  }
};

using ValueJSON = sourcemeta::core::JSON;

using ValueSet =
    std::unordered_set<sourcemeta::core::JSON,
                       sourcemeta::core::HashJSON<sourcemeta::core::JSON>>;

using ValueString = sourcemeta::core::JSON::String;

using ValueProperty =
    std::pair<ValueString, sourcemeta::core::JSON::Object::hash_type>;

using ValueStrings = std::vector<ValueString>;

using ValueStringSet = sourcemeta::core::JSONPropertySet;

using ValueTypes = sourcemeta::core::JSON::TypeSet;

using ValueType = sourcemeta::core::JSON::Type;

// NOLINTNEXTLINE(bugprone-exception-escape)
struct ValueRegex {
  using second_type = ValueString;
  using first_type = sourcemeta::core::Regex;
  first_type first;
  second_type second;
 
  [[nodiscard]] auto to_json() const -> sourcemeta::core::JSON {
    return sourcemeta::core::to_json(this->second);
  }
 
  static auto from_json(const sourcemeta::core::JSON &value)
      -> std::optional<ValueRegex> {
    if (!value.is_string()) {
      return std::nullopt;
    }
 
    auto string{value.to_string()};
    auto regex{sourcemeta::core::to_regex(string)};
    if (!regex.has_value()) {
      return std::nullopt;
    }
 
    // NOLINTNEXTLINE(modernize-use-designated-initializers)
    return ValueRegex{std::move(regex).value(), std::move(string)};
  }
};

using ValueUnsignedInteger = std::size_t;

using ValueRange = std::tuple<std::size_t, std::optional<std::size_t>, bool>;

using ValueBoolean = bool;

enum class ValueStringType : std::uint8_t {
  URI,
  URIReference,
  URITemplate,
  IRI,
  IRIReference,
  Email,
  IDNEmail,
  IPv4,
  IPv6,
  Hostname,
  IDNHostname,
  DateTime,
  Date,
  Time,
  PartialTime,
  Duration,
  JSONPointer,
  RelativeJSONPointer,
  UUID,
  Regex,
  Color,
  Base64
};

using ValueStringMap = sourcemeta::core::JSONObject<
    ValueString, ValueStrings, sourcemeta::core::PropertyHashJSON<ValueString>>;

using ValuePropertyFilter =
    std::tuple<ValueStringSet, ValueStrings, std::vector<ValueRegex>>;

using ValueIndexPair = std::pair<std::size_t, std::size_t>;

using ValuePointer = sourcemeta::core::Pointer;

using ValueNamedIndex = std::tuple<sourcemeta::core::JSON::Object::hash_type,
                                   ValueUnsignedInteger, ValueString>;

using ValueNamedIndexes =
    std::pair<std::vector<ValueNamedIndex>, std::vector<ValueIndexPair>>;

using ValueTypedProperties = std::pair<ValueType, ValueStringSet>;

using ValueStringHashes =
    std::pair<std::vector<std::pair<ValueStringSet::hash_type, ValueString>>,
              std::vector<ValueIndexPair>>;

using ValueTypedHashes = std::pair<ValueType, ValueStringHashes>;

using ValueIntegerBounds = std::pair<std::int64_t, std::int64_t>;

using ValueIntegerBoundsWithSize = std::pair<ValueIntegerBounds, ValueRange>;

using ValueTypesWithSize = std::pair<ValueTypes, ValueRange>;

using ValueObjectProperties = std::vector<
    std::tuple<ValueString, sourcemeta::core::JSON::Object::hash_type, bool>>;

enum class ValueNumberType : std::uint8_t { Float, Double };

using Value =
    std::variant<ValueNone, ValueJSON, ValueSet, ValueString, ValueProperty,
                 ValueStrings, ValueStringSet, ValueTypes, ValueType,
                 ValueRegex, ValueUnsignedInteger, ValueRange, ValueBoolean,
                 ValueNamedIndexes, ValueStringType, ValueStringMap,
                 ValuePropertyFilter, ValueIndexPair, ValuePointer,
                 ValueTypedProperties, ValueStringHashes, ValueTypedHashes,
                 ValueIntegerBounds, ValueIntegerBoundsWithSize,
                 ValueObjectProperties, ValueNumberType, ValueTypesWithSize>;
 
} // namespace sourcemeta::blaze
 
#endif