output_simple.h

#ifndef SOURCEMETA_BLAZE_OUTPUT_SIMPLE_H_
#define SOURCEMETA_BLAZE_OUTPUT_SIMPLE_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/core/jsonschema.h>
 
#include <sourcemeta/blaze/evaluator.h>
 
#include <cstddef>    // std::size_t
#include <cstdint>    // std::uint8_t
#include <functional> // std::reference_wrapper
// TODO(C++23): Consider std::flat_map/std::flat_set when available in libc++
#include <string>  // std::string
#include <utility> // std::move
#include <vector>  // std::vector
 
namespace sourcemeta::blaze {

class SOURCEMETA_BLAZE_OUTPUT_EXPORT SimpleOutput {
public:
  SimpleOutput(const Template &schema_template,
               const sourcemeta::core::JSON &instance,
               sourcemeta::core::WeakPointer base =
                   sourcemeta::core::EMPTY_WEAK_POINTER);
 
  // Prevent accidental copies
  SimpleOutput(const SimpleOutput &) = delete;
  auto operator=(const SimpleOutput &) -> SimpleOutput & = delete;
 
  struct Entry {
    std::string message;
    sourcemeta::core::WeakPointer instance_location;
    sourcemeta::core::WeakPointer evaluate_path;
    std::reference_wrapper<const std::string> schema_location;
  };

  struct AnnotationEntry {
    sourcemeta::core::WeakPointer instance_location;
    sourcemeta::core::WeakPointer evaluate_path;
    std::reference_wrapper<const std::string> schema_location;
    sourcemeta::core::JSON value;
    bool is_wrapped;
  };
 
  auto operator()(const EvaluationType type, const bool result,
                  const Instruction &step,
                  const InstructionExtra &step_metadata,
                  const sourcemeta::core::WeakPointer &evaluate_path,
                  const sourcemeta::core::WeakPointer &instance_location,
                  const sourcemeta::core::JSON &annotation) -> void;
 
  using container_type = std::vector<Entry>;
  using const_iterator = container_type::const_iterator;
  [[nodiscard]] auto begin() const -> const_iterator;
  [[nodiscard]] auto end() const -> const_iterator;
  [[nodiscard]] auto cbegin() const -> const_iterator;
  [[nodiscard]] auto cend() const -> const_iterator;

  [[nodiscard]] auto release() && -> container_type {
    auto result{std::move(this->output_)};
    // A moved-from container is left in a valid but unspecified state, so
    // clear it to honor the documented empty postcondition portably
    this->output_.clear();
    return result;
  }

  [[nodiscard]] auto annotations() const -> const auto & {
    return this->annotations_;
  }
 
private:
// Exporting symbols that depends on the standard C++ library is considered
// safe.
// https://learn.microsoft.com/en-us/cpp/error-messages/compiler-warnings/compiler-warning-level-2-c4275?view=msvc-170&redirectedfrom=MSDN
#if defined(_MSC_VER)
#pragma warning(disable : 4251)
#endif
  enum class MaskKind : std::uint8_t { None, Disjunction, Element, Subschema };

  static auto mask_kind(const Instruction &step) noexcept -> MaskKind;

  auto destination(const sourcemeta::core::WeakPointer &evaluate_path)
      -> container_type *;

  struct MaskEntry {
    sourcemeta::core::WeakPointer evaluate_path;
    sourcemeta::core::WeakPointer instance_location;
    MaskKind kind;
    std::size_t annotations_mark;
    std::vector<Entry> buffered_traces;
  };
 
  const Template &schema_template_;
  const sourcemeta::core::JSON &instance_;
  const sourcemeta::core::WeakPointer base_;
  container_type output_;
  std::vector<MaskEntry> mask_;
  std::vector<AnnotationEntry> annotations_;
#if defined(_MSC_VER)
#pragma warning(default : 4251)
#endif
}; // namespace sourcemeta::blaze
 
} // namespace sourcemeta::blaze
 
#endif