jsonpath

type ComparableEvaluator interface {
	// The returned value must be cloned first if it is consumed
	//
	// TODO: see if it wouldn't be better to clone it by default as the value is
	// perhaps always consumed.
	Evaluate(ctx *RunContext, value iterator.Value) iterator.Value
}

type ComparisonEvaluator struct {
	// contains filtered or unexported fields
}

type ComparisonFlags uint8

type CompileQueryOption func(*compiler)

type Decision uint8

type DefaultSelectorRunner struct{}

type DefaultSingularSelectorRunner struct{}

type FilterSelectorRunner struct {
	DefaultSelectorRunner
	// contains filtered or unexported fields
}

type FunctionArgumentRunner interface {
	ComparableEvaluator
	LogicalEvaluator
	NodesResultEvaluator
}

type FunctionDef struct {
	Name       string
	InputTypes []Type
	OutputType Type
	Run        func([]any) any
}

type FunctionRegistry interface {
	GetFunctionDef(name string) *FunctionDef
	AddFunctionDef(def FunctionDef) error
}

type FunctionRunner struct {
	*FunctionDef
	// contains filtered or unexported fields
}

type IndexSelectorRunner struct {
	DefaultSelectorRunner
	// contains filtered or unexported fields
}

type IndexSingularSelectorRunner struct {
	DefaultSingularSelectorRunner
	// contains filtered or unexported fields
}

type InnerQueryRunner struct {
	// contains filtered or unexported fields
}

type InnerSingularQueryRunner struct {
	// contains filtered or unexported fields
}

type LiteralEvaluator struct {
	// contains filtered or unexported fields
}

type LogicalAndEvaluator struct {
	Arguments []LogicalEvaluator
}

type LogicalArgumentRunner struct {
	LogicalEvaluator
}

type LogicalEvaluator interface {

	// EvaluateTruth returns true if the value fulfils the condition.
	// It should keep value untouched.
	EvaluateTruth(ctx *RunContext, value iterator.Value) bool
}

type LogicalNotEvaluator struct {
	Argument LogicalEvaluator
}

type LogicalOrEvaluator struct {
	Arguments []LogicalEvaluator
}

type MainQueryRunner struct {
	// contains filtered or unexported fields
}

type NameSelectorRunner struct {
	DefaultSelectorRunner
	// contains filtered or unexported fields
}

type NameSingularSelectorRunner struct {
	DefaultSingularSelectorRunner
	// contains filtered or unexported fields
}

type NodesArgumentRunner struct {
	QueryEvaluator
}

type NodesResult interface {
	ForEachNode(func(iterator.Value) bool)
}

type NodesResultEvaluator interface {
	EvaluateNodesResult(ctx *RunContext, value iterator.Value) NodesResult
}

type QueryEvaluator struct {
	ValueMapper
}

type QueryRunner struct {
	// contains filtered or unexported fields
}

type ReverseSliceSelectorRunner struct {
	DefaultSelectorRunner
	// contains filtered or unexported fields
}

type RunContext struct {
	// contains filtered or unexported fields
}

type SegmentRunner struct {
	// contains filtered or unexported fields
}

type SelectorRunner interface {

	// Lookahead returns the number of extra number of array items we need to
	// know about in order to make a decision about a negative index selector.
	// If the returned number is 0 then it means there is no need to look ahead
	// at all.
	//
	// For example in the query $[-4:], the lookahead is 4.  This is because if
	// we know that there are at least 4 more items in the array after the
	// current one, it won't be selected.
	//
	// Knowing the lookahead value allows executing such queries in a streaming
	// manner, without loading the whole array into memory, just a slice of size
	// lookahead.
	Lookahead() int64

	// SelectsFromKey makes a Decision on whether the current object item is
	// selected based on its key.  If no decision can be made then it should
	// return DontKnow.
	SelectsFromKey(key string) Decision

	// SelectsFromKey makes a Decision on whether the current array item is
	// selected based on its index or negative index.  If no decision can be
	// made then it should return DontKnow.
	//
	// The value negIndex is negative and is meant to represent the index from
	// the end of the array, starting at -1.
	//
	// The negative index (negIndex) is not necessarily correct but the
	// following can be assumed, given that N is the value returned by
	// Lookahead() and I is the real negative index:
	//   - if negIndex >= -N then negIndex == I
	//   - if negIndex < -N then I < -N
	SelectsFromIndex(index, negIndex int64) Decision

	// Selects decides whether the current item in an object or array should be
	// selected, based on its value.  It is only called if either SelectsFromKey
	// or SelectsFromIndex returned DontKnow and it makes the final decision.
	//
	// Selects should promise not to advance Value, so it must clone it first if
	// it wants to look inside.
	SelectsFromValue(ctx *RunContext, value iterator.Value) bool

	// ReversesSelection returns true if the selector should output the values
	// it selects in reverse order. This is taylor-made for slice selectors with
	// a negative step.
	ReversesSelection() bool
}

type SingularQueryRunner struct {
	// contains filtered or unexported fields
}

type SingularSelectorRunner interface {
	SelectFromObject(*iterator.Object) iterator.Value
	SelectFromArray(*iterator.Array) iterator.Value
}

type SliceSelectorRunner struct {
	DefaultSelectorRunner
	// contains filtered or unexported fields
}

type Type uint8

type ValueArgumentRunner struct {
	ComparableEvaluator
}

type ValueMapper interface {
	MapValue(ctx *RunContext, value iterator.Value, next valueProcessor) bool
}

type WildcardSelectorRunner struct {
	DefaultSelectorRunner
}