jsonpath.h

#ifndef SOURCEMETA_CORE_JSONPATH_H_
#define SOURCEMETA_CORE_JSONPATH_H_
 
#ifndef SOURCEMETA_CORE_JSONPATH_EXPORT
#include <sourcemeta/core/jsonpath_export.h>
#endif
 
// NOLINTBEGIN(misc-include-cleaner)
#include <sourcemeta/core/jsonpath_error.h>
// NOLINTEND(misc-include-cleaner)
 
#include <sourcemeta/core/json.h>
#include <sourcemeta/core/jsonpointer.h>
#include <sourcemeta/core/regex.h>
 
#include <cstdint>    // std::int64_t, std::uint8_t
#include <functional> // std::function
#include <optional>   // std::optional
#include <variant>    // std::variant
#include <vector>     // std::vector

 
namespace sourcemeta::core {
 
// 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(push)
#pragma warning(disable : 4251)
#endif

class SOURCEMETA_CORE_JSONPATH_EXPORT JSONPath {
public:
  using Callback =
      std::function<void(const JSON &value, const WeakPointer &location)>;

  struct SelectorName {
    JSON::String name;
    JSON::Object::hash_type hash;
  };

  struct SelectorWildcard {};

  struct SelectorIndex {
    std::int64_t index;
  };

  struct SelectorSlice {
    std::optional<std::int64_t> start;
    std::optional<std::int64_t> end;
    std::int64_t step;
  };

  enum class FilterFunctionName : std::uint8_t {
    Length,
    Count,
    Match,
    Search,
    Value
  };

  enum class FilterComparisonOperator : std::uint8_t {
    Equal,
    NotEqual,
    Less,
    LessEqual,
    Greater,
    GreaterEqual
  };
 
#if !defined(DOXYGEN)
  // Required by the recursive grammar and defined further below
  struct Segment;
#endif

  struct FilterQuery {
    bool relative;
    std::vector<Segment> segments;
    bool singular;
  };
 
#if !defined(DOXYGEN)
  // Required by the recursive grammar and defined further below
  struct FilterOperand;
#endif

  struct FilterFunctionCall {
    FilterFunctionName function;
    std::vector<FilterOperand> arguments;
    std::optional<Regex> compiled;
  };

  struct FilterOperand {
    std::variant<JSON, FilterQuery, FilterFunctionCall> value;
  };

  struct FilterComparison {
    FilterOperand left;
    FilterComparisonOperator operation;
    FilterOperand right;
  };

  struct FilterTest {
    bool negated;
    std::variant<FilterQuery, FilterFunctionCall> subject;
  };
 
#if !defined(DOXYGEN)
  // Required by the recursive grammar and defined further below
  struct FilterExpression;
#endif

  struct FilterConjunction {
    std::vector<FilterExpression> children;
  };

  struct FilterDisjunction {
    std::vector<FilterExpression> children;
  };

  struct FilterNegation {
    std::vector<FilterExpression> children;
  };
 
#if !defined(DOXYGEN)
  // For fast internal dispatching. It must stay in sync with the expression
  // variant below
  enum class FilterExpressionKind : std::uint8_t {
    Comparison = 0,
    Test,
    Conjunction,
    Disjunction,
    Negation
  };
#endif

  struct FilterExpression {
    std::variant<FilterComparison, FilterTest, FilterConjunction,
                 FilterDisjunction, FilterNegation>
        value;
  };

  struct SelectorFilter {
    FilterExpression expression;
  };

  using Selector = std::variant<SelectorName, SelectorWildcard, SelectorIndex,
                                SelectorSlice, SelectorFilter>;
 
#if !defined(DOXYGEN)
  // For fast internal dispatching. It must stay in sync with the variant above
  enum class SelectorKind : std::uint8_t {
    Name = 0,
    Wildcard,
    Index,
    Slice,
    Filter
  };
#endif

  enum class SegmentKind : std::uint8_t {
    SingleName,
    SingleIndex,
    General
  };

  struct Segment {
    bool descendant;
    SegmentKind kind;
    std::vector<Selector> selectors;
  };

  struct Query {
    std::vector<Segment> segments;
  };

  explicit JSONPath(const JSON::StringView expression);

  auto evaluate(const JSON &document, const Callback &callback) const -> void;

  [[nodiscard]] static auto normalize(const WeakPointer &location)
      -> JSON::String;

  [[nodiscard]] auto to_json() const -> JSON;

  [[nodiscard]] static auto from_json(const JSON &value)
      -> std::optional<JSONPath>;
 
private:
  JSON::String expression_;
  Query query_;
};
 
#if defined(_MSC_VER)
#pragma warning(pop)
#endif
 
} // namespace sourcemeta::core
 
#endif