jd

type Diff []DiffElement

type DiffElement struct {

	// Metadata describes how this DiffElement should be
	// interpretted. It is also inherited by following
	// DiffElements until another Metadata is encountered.
	Metadata Metadata

	// Path elements can be strings to index Objects, numbers to
	// index Lists and objects to index Sets and Multisets. Path
	// elements can be preceeded by an Array of Metadata strings to
	// change how the structure is interpretted. Metadata in lower
	// case applies to the following path element. Metadata in upper
	// case applies to the rest of the path.
	//
	// For example:
	//   ["foo","bar"]               // indexes to 1 in {"foo":{"bar":1}}
	//   ["foo",0]                   // indexes to 1 in {"foo":[1]}
	//   ["foo",{}]                  // indexes a set under "foo" in {"foo":[1]}
	//   ["foo",["multiset"],{}]     // indexes a multiset under "foo" in {"foo":[1,1]}
	//   ["foo",{"id":"bar"},"baz"]  // indexes to 1 in {"foo":[{"id":"bar","baz":1}]}
	//   [["MERGE"],"foo","bar"]     // indexes to 1 in {"foo":{"bar":1}} with merge semantics
	Path Path

	// Before are the required context which should appear before
	// new and old values of a diff element. They are only used
	// for diffs in a list element.
	Before []JsonNode

	// Remove are removed from the JsonNode at the Path. Usually
	// only one old value is provided unless removing entries from
	// a Set or Multiset. When using merge semantics no old values
	// are provided (new values stomp old ones).
	Remove []JsonNode

	// Add are added to the JsonNode at the Path. Usually only one
	// new value is provided unless adding entries to a Set or
	// Multiset.
	Add []JsonNode

	// After are the required context which should appear after
	// new and old values of a diff element. They are only used
	// for diffs in a list element.
	After []JsonNode
}

type JsonNode interface {

	// Json renders a JsonNode as a JSON string.
	Json(renderOptions ...Option) string

	// Yaml renders a JsonNode as a YAML string in block format.
	Yaml(renderOptions ...Option) string

	// Equals returns true if the JsonNodes are equal according to
	// the provided Metadata. The default behavior (no Metadata) is
	// to compare the entire structure down to scalar values treating
	// Arrays as orders Lists. The SET and MULTISET Metadata will
	// treat Arrays as sets or multisets (bags) respectively. To deep
	// compare objects in an array irrespective of order, the SetKeys
	// function will construct Metadata to compare objects by a set
	// of keys. If two JsonNodes are equal, then Diff with the same
	// Metadata will produce an empty Diff. And vice versa.
	Equals(n JsonNode, options ...Option) bool

	// Diff produces a list of differences (Diff) between two
	// JsonNodes such that if the output Diff were applied to the
	// first JsonNode (Patch) then the two JsonNodes would be
	// Equal. The necessary Metadata is embeded in the Diff itself so
	// only the Diff is required to Patch a JsonNode.
	Diff(n JsonNode, options ...Option) Diff

	// Patch applies a Diff to a JsonNode. No Metadata is provided
	// because the original interpretation of the structure is
	// embedded in the Diff itself.
	Patch(d Diff) (JsonNode, error)
	// contains filtered or unexported methods
}

type Metadata struct {
	Merge bool
}

type Option interface {
	// contains filtered or unexported methods
}

type Path []PathElement

type PathElement interface {
	// contains filtered or unexported methods
}

type PathIndex int

type PathKey string

type PathMultiset struct{}

type PathMultisetKeys map[string]JsonNode

type PathSet struct{}

type PathSetKeys map[string]JsonNode