output_jsonld.h

#ifndef SOURCEMETA_BLAZE_OUTPUT_JSONLD_H_
#define SOURCEMETA_BLAZE_OUTPUT_JSONLD_H_
 
#ifndef SOURCEMETA_BLAZE_OUTPUT_EXPORT
#include <sourcemeta/blaze/output_export.h>
#endif
 
#include <sourcemeta/core/json.h>
#include <sourcemeta/core/jsonpointer.h>
 
#include <sourcemeta/blaze/evaluator.h>
#include <sourcemeta/blaze/output_simple.h>
 
#include <array>    // std::array
#include <cstdint>  // std::uint8_t
#include <optional> // std::optional
#include <string>   // std::string
#include <variant>  // std::variant
#include <vector>   // std::vector
 
namespace sourcemeta::blaze {

inline constexpr std::array<sourcemeta::core::JSON::StringView, 13>
    JSONLD_KEYWORDS{{"x-jsonld-id", "x-jsonld-type", "x-jsonld-reverse",
                     "x-jsonld-datatype", "x-jsonld-language",
                     "x-jsonld-direction", "x-jsonld-json", "x-jsonld-graph",
                     "x-jsonld-container", "x-jsonld-self", "x-jsonld-override",
                     "x-jsonld-value", "x-jsonld-constants"}};

enum class JSONLDFacet : std::uint8_t {
  Type,
  Predicate,
  Datatype,
  Language,
  Direction,
  Graph,
  JSON,
  Container,
  Self,
  Override,
  ValuePredicate,
  Constants
};

struct JSONLDResolutionError {
  sourcemeta::core::Pointer instance_location;
  JSONLDFacet facet;
  std::string message;
  std::string schema_location;
  std::optional<std::string> conflicting_schema_location;
  std::optional<std::string> inert_override_location;
};

using JSONLDInvalid = std::vector<SimpleOutput::Entry>;

using JSONLDOutcome =
    std::variant<sourcemeta::core::JSON, JSONLDInvalid, JSONLDResolutionError>;

auto SOURCEMETA_BLAZE_OUTPUT_EXPORT
jsonld(Evaluator &evaluator, const Template &schema,
       const sourcemeta::core::JSON &instance) -> JSONLDOutcome;
 
} // namespace sourcemeta::blaze
 
#endif