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/blaze/foundation.h>
#include <sourcemeta/core/json.h>
#include <sourcemeta/core/jsonpointer.h>
 
#include <sourcemeta/blaze/evaluator.h>
 
#include <functional> // std::reference_wrapper
// TODO(C++23): Consider std::flat_map/std::flat_set when available in libc++
#include <map>     // std::map
#include <ostream> // std::ostream
#include <string>  // std::string
#include <tuple>   // std::tie
#include <utility> // std::pair
#include <vector>  // std::vector
 
namespace sourcemeta::blaze {
 
class SOURCEMETA_BLAZE_OUTPUT_EXPORT SimpleOutput {
public:
  SimpleOutput(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;
  };
 
  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 = typename std::vector<Entry>;
  using const_iterator = typename 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 annotations() const -> const auto & {
    return this->annotations_;
  }
 
  // NOLINTNEXTLINE(bugprone-exception-escape)
  struct Location {
    auto operator<(const Location &other) const noexcept -> bool {
      // Perform a lexicographical comparison
      return std::tie(this->instance_location, this->evaluate_path,
                      this->schema_location.get()) <
             std::tie(other.instance_location, other.evaluate_path,
                      other.schema_location.get());
    }
 
    // NOLINTBEGIN(cppcoreguidelines-avoid-const-or-ref-data-members)
    const sourcemeta::core::WeakPointer instance_location;
    const sourcemeta::core::WeakPointer evaluate_path;
    const std::reference_wrapper<const std::string> schema_location;
    // NOLINTEND(cppcoreguidelines-avoid-const-or-ref-data-members)
  };
 
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
  const sourcemeta::core::JSON &instance_;
  const sourcemeta::core::WeakPointer base_;
  container_type output;
  std::vector<
      std::pair<sourcemeta::core::WeakPointer, sourcemeta::core::WeakPointer>>
      mask;
  std::map<
      std::pair<sourcemeta::core::WeakPointer, sourcemeta::core::WeakPointer>,
      std::vector<Entry>>
      masked_traces;
  std::map<Location, std::vector<sourcemeta::core::JSON>> annotations_;
#if defined(_MSC_VER)
#pragma warning(default : 4251)
#endif
}; // namespace sourcemeta::blaze
 
} // namespace sourcemeta::blaze
 
#endif