jd

type Diff []DiffElement

type DiffElement struct {

	// 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 []JsonNode

	// OldValues 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).
	OldValues []JsonNode

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

type JsonNode interface {

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

	// Yaml renders a JsonNode as a YAML string in block format.
	Yaml(renderOptions ...Metadata) 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, metadata ...Metadata) 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, metadata ...Metadata) 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 interface {
	// contains filtered or unexported methods
}

type RenderOption interface {

	// RenderOptions are included in the closed Metadata set for
	// backward compatability. Previously Json and Yaml methods
	// accepted Metadata instead of RenderOptions. Passing
	// Metadata to Json and Yaml methods did nothing but it remains
	// an option to not break any existing code.
	Metadata
	// contains filtered or unexported methods
}