yqlib

type CandidateNode struct {
	Kind  Kind
	Style Style

	Tag     string
	Value   string
	Anchor  string
	Alias   *CandidateNode
	Content []*CandidateNode

	HeadComment string
	LineComment string
	FootComment string

	Parent *CandidateNode // parent node
	Key    *CandidateNode // node key, if this is a value from a map (or index in an array)

	LeadingContent string

	Line   int
	Column int

	// when performing op against all nodes given, this will treat all the nodes as one
	// (e.g. top level cross document merge). This property does not propagate to child nodes.
	EvaluateTogether bool
	IsMapKey         bool
	// For formats like HCL and TOML: indicates that child entries should be emitted as separate blocks/tables
	// rather than consolidated into nested mappings (default behaviour)
	EncodeSeparate bool
	// contains filtered or unexported fields
}

type Context struct {
	MatchingNodes  *list.List
	Variables      map[string]*list.List
	DontAutoCreate bool
	// contains filtered or unexported fields
}

type CsvPreferences struct {
	Separator rune
	AutoParse bool
}

type DataTreeNavigator interface {
	// given the context and an expressionNode,
	// this will process the against the given expressionNode and return
	// a new context of matching candidates
	GetMatchingNodes(context Context, expressionNode *ExpressionNode) (Context, error)

	DeeplyAssign(context Context, path []interface{}, rhsNode *CandidateNode) error
}

type Decoder interface {
	Init(reader io.Reader) error
	Decode() (*CandidateNode, error)
}

type DecoderFactoryFunction func() Decoder

type Encoder interface {
	Encode(writer io.Writer, node *CandidateNode) error
	PrintDocumentSeparator(writer io.Writer) error
	PrintLeadingContent(writer io.Writer, content string) error
	CanHandleAliases() bool
}

type EncoderFactoryFunction func() Encoder

type Evaluator interface {
	EvaluateFiles(expression string, filenames []string, printer Printer, decoder Decoder) error

	// EvaluateNodes takes an expression and one or more yaml nodes, returning a list of matching candidate nodes
	EvaluateNodes(expression string, nodes ...*CandidateNode) (*list.List, error)

	// EvaluateCandidateNodes takes an expression and list of candidate nodes, returning a list of matching candidate nodes
	EvaluateCandidateNodes(expression string, inputCandidateNodes *list.List) (*list.List, error)
}

type ExpressionNode struct {
	Operation *Operation
	LHS       *ExpressionNode
	RHS       *ExpressionNode
	Parent    *ExpressionNode
}

type ExpressionParserInterface interface {
	ParseExpression(expression string) (*ExpressionNode, error)
}

type Format struct {
	FormalName     string
	Names          []string
	EncoderFactory EncoderFactoryFunction
	DecoderFactory DecoderFactoryFunction
}

type HclPreferences struct {
	ColorsEnabled bool
}

type INIPreferences struct {
	ColorsEnabled bool
}

type JsonPreferences struct {
	Indent        int
	ColorsEnabled bool
	UnwrapScalar  bool
}

type Kind uint32

type LuaPreferences struct {
	DocPrefix    string
	DocSuffix    string
	UnquotedKeys bool
	Globals      bool
}

type NodeInfo struct {
	Kind        string      `yaml:"kind"`
	Style       string      `yaml:"style,omitempty"`
	Anchor      string      `yaml:"anchor,omitempty"`
	Tag         string      `yaml:"tag,omitempty"`
	HeadComment string      `yaml:"headComment,omitempty"`
	LineComment string      `yaml:"lineComment,omitempty"`
	FootComment string      `yaml:"footComment,omitempty"`
	Value       string      `yaml:"value,omitempty"`
	Line        int         `yaml:"line,omitempty"`
	Column      int         `yaml:"column,omitempty"`
	Content     []*NodeInfo `yaml:"content,omitempty"`
}

type Operation struct {
	OperationType *operationType
	Value         interface{}
	StringValue   string
	CandidateNode *CandidateNode // used for Value Path elements
	Preferences   interface{}
	UpdateAssign  bool // used for assign ops, when true it means we evaluate the rhs given the lhs
}

type Printer interface {
	PrintResults(matchingNodes *list.List) error
	PrintedAnything() bool
	//e.g. when given a front-matter doc, like jekyll
	SetAppendix(reader io.Reader)
	SetNulSepOutput(nulSepOutput bool)
}

type PrinterWriter interface {
	GetWriter(node *CandidateNode) (*bufio.Writer, error)
}

type PropertiesPreferences struct {
	UnwrapScalar      bool
	KeyValueSeparator string
	UseArrayBrackets  bool
}

type SecurityPreferences struct {
	DisableEnvOps  bool
	DisableFileOps bool
}

type ShellVariablesPreferences struct {
	KeySeparator string
}

type StreamEvaluator interface {
	Evaluate(filename string, reader io.Reader, node *ExpressionNode, printer Printer, decoder Decoder) (uint, error)
	EvaluateFiles(expression string, filenames []string, printer Printer, decoder Decoder) error
	EvaluateNew(expression string, printer Printer) error
}

type StringEvaluator interface {
	Evaluate(expression string, input string, encoder Encoder, decoder Decoder) (string, error)
	EvaluateAll(expression string, input string, encoder Encoder, decoder Decoder) (string, error)
}

type Style uint32

type ValueVisitor func(*CandidateNode) error

type XmlPreferences struct {
	Indent          int
	AttributePrefix string
	ContentName     string
	StrictMode      bool
	KeepNamespace   bool
	UseRawToken     bool
	ProcInstPrefix  string
	DirectiveName   string
	SkipProcInst    bool
	SkipDirectives  bool
}

type YamlPreferences struct {
	Indent                      int
	ColorsEnabled               bool
	LeadingContentPreProcessing bool
	PrintDocSeparators          bool
	UnwrapScalar                bool
	EvaluateTogether            bool
	FixMergeAnchorToSpec        bool
}