var ErrUnknownName =errors.New("unknown object member name")

var SkipFunc =errors.New("json: skip function")

funcGetOption¶

func GetOption[Tany](optsOptions, setter func(T)Options) (T,bool)

GetOption returns the value stored in opts with the provided setter,reporting whether the value is present.

Example usage:

v, ok := json.GetOption(opts, json.Deterministic)

Options are most commonly introspected to alter the JSON representation of[MarshalerTo.MarshalJSONTo] and [UnmarshalerFrom.UnmarshalJSONFrom] methods, andMarshalToFunc andUnmarshalFromFunc functions.In such cases, the presence bit should generally be ignored.

funcMarshal¶

func Marshal(inany, opts ...Options) (out []byte, errerror)

Marshal serializes a Go value as a []byte according to the providedmarshal and encode options (while ignoring unmarshal or decode options).It does not terminate the output with a newline.

Type-specific marshal functions and methods take precedenceover the default representation of a value.Functions or methods that operate on *T are only called when encodinga value of type T (by taking its address) or a non-nil value of *T.Marshal ensures that a value is always addressable(by boxing it on the heap if necessary) so thatthese functions and methods can be consistently called. For performance,it is recommended that Marshal be passed a non-nil pointer to the value.

The input value is encoded as JSON according the following rules:

• If any type-specific functions in aWithMarshalers option matchthe value type, then those functions are called to encode the value.If all applicable functions returnSkipFunc,then the value is encoded according to subsequent rules.

• If the value type implementsMarshalerTo,then the MarshalJSONTo method is called to encode the value.

• If the value type implementsMarshaler,then the MarshalJSON method is called to encode the value.

• If the value type implementsencoding.TextAppender,then the AppendText method is called to encode the value andsubsequently encode its result as a JSON string.

• If the value type implementsencoding.TextMarshaler,then the MarshalText method is called to encode the value andsubsequently encode its result as a JSON string.

• Otherwise, the value is encoded according to the value's typeas described in detail below.

Most Go types have a default JSON representation.Certain types support specialized formatting according toa format flag optionally specified in the Go struct tagfor the struct field that contains the current value(see the “JSON Representation of Go structs” section for more details).

The representation of each type is as follows:

• A Go boolean is encoded as a JSON boolean (e.g., true or false).It does not support any custom format flags.

• A Go string is encoded as a JSON string.It does not support any custom format flags.

• A Go []byte or [N]byte is encoded as a JSON string containingthe binary value encoded usingRFC 4648.If the format is "base64" or unspecified, then this usesRFC 4648, section 4.If the format is "base64url", then this usesRFC 4648, section 5.If the format is "base32", then this usesRFC 4648, section 6.If the format is "base32hex", then this usesRFC 4648, section 7.If the format is "base16" or "hex", then this usesRFC 4648, section 8.If the format is "array", then the bytes value is encoded as a JSON arraywhere each byte is recursively JSON-encoded as each JSON array element.

• A Go integer is encoded as a JSON number without fractions or exponents.IfStringifyNumbers is specified or encoding a JSON object name,then the JSON number is encoded within a JSON string.It does not support any custom format flags.

• A Go float is encoded as a JSON number.IfStringifyNumbers is specified or encoding a JSON object name,then the JSON number is encoded within a JSON string.If the format is "nonfinite", then NaN, +Inf, and -Inf are encoded asthe JSON strings "NaN", "Infinity", and "-Infinity", respectively.Otherwise, the presence of non-finite numbers results in aSemanticError.

• A Go map is encoded as a JSON object, where each Go map key and valueis recursively encoded as a name and value pair in the JSON object.The Go map key must encode as a JSON string, otherwise this resultsin aSemanticError. The Go map is traversed in a non-deterministic order.For deterministic encoding, consider using theDeterministic option.If the format is "emitnull", then a nil map is encoded as a JSON null.If the format is "emitempty", then a nil map is encoded as an empty JSON object,regardless of whetherFormatNilMapAsNull is specified.Otherwise by default, a nil map is encoded as an empty JSON object.

• A Go struct is encoded as a JSON object.See the “JSON Representation of Go structs” sectionin the package-level documentation for more details.

• A Go slice is encoded as a JSON array, where each Go slice elementis recursively JSON-encoded as the elements of the JSON array.If the format is "emitnull", then a nil slice is encoded as a JSON null.If the format is "emitempty", then a nil slice is encoded as an empty JSON array,regardless of whetherFormatNilSliceAsNull is specified.Otherwise by default, a nil slice is encoded as an empty JSON array.

• A Go array is encoded as a JSON array, where each Go array elementis recursively JSON-encoded as the elements of the JSON array.The JSON array length is always identical to the Go array length.It does not support any custom format flags.

• A Go pointer is encoded as a JSON null if nil, otherwise it isthe recursively JSON-encoded representation of the underlying value.Format flags are forwarded to the encoding of the underlying value.

• A Go interface is encoded as a JSON null if nil, otherwise it isthe recursively JSON-encoded representation of the underlying value.It does not support any custom format flags.

• A Gotime.Time is encoded as a JSON string containing the timestampformatted inRFC 3339 with nanosecond precision.If the format matches one of the format constants declaredin the time package (e.g., RFC1123), then that format is used.If the format is "unix", "unixmilli", "unixmicro", or "unixnano",then the timestamp is encoded as a possibly fractional JSON numberof the number of seconds (or milliseconds, microseconds, or nanoseconds)since the Unix epoch, which is January 1st, 1970 at 00:00:00 UTC.To avoid a fractional component, round the timestamp to the relevant unit.Otherwise, the format is used as-is withtime.Time.Format if non-empty.

• A Gotime.Duration currently has no default representation andrequires an explicit format to be specified.If the format is "sec", "milli", "micro", or "nano",then the duration is encoded as a possibly fractional JSON numberof the number of seconds (or milliseconds, microseconds, or nanoseconds).To avoid a fractional component, round the duration to the relevant unit.If the format is "units", it is encoded as a JSON string formatted usingtime.Duration.String (e.g., "1h30m" for 1 hour 30 minutes).If the format is "iso8601", it is encoded as a JSON string using theISO 8601 standard for durations (e.g., "PT1H30M" for 1 hour 30 minutes)using only accurate units of hours, minutes, and seconds.

• All other Go types (e.g., complex numbers, channels, and functions)have no default representation and result in aSemanticError.

JSON cannot represent cyclic data structures and Marshal does not handle them.Passing cyclic structures will result in an error.

funcMarshalEncode¶

func MarshalEncode(out *jsontext.Encoder, inany, opts ...Options) (errerror)

MarshalEncode serializes a Go value into anjsontext.Encoder according tothe provided marshal options (while ignoring unmarshal, encode, or decode options).Any marshal-relevant options already specified on thejsontext.Encodertake lower precedence than the set of options provided by the caller.UnlikeMarshal andMarshalWrite, encode options are ignored becausethey must have already been specified on the providedjsontext.Encoder.

SeeMarshal for details about the conversion of a Go value into JSON.

funcMarshalWrite¶

func MarshalWrite(outio.Writer, inany, opts ...Options) (errerror)

MarshalWrite serializes a Go value into anio.Writer according to the providedmarshal and encode options (while ignoring unmarshal or decode options).It does not terminate the output with a newline.SeeMarshal for details about the conversion of a Go value into JSON.

funcUnmarshal¶

func Unmarshal(in []byte, outany, opts ...Options) (errerror)

Unmarshal decodes a []byte input into a Go value according to the providedunmarshal and decode options (while ignoring marshal or encode options).The input must be a single JSON value with optional whitespace interspersed.The output must be a non-nil pointer.

Type-specific unmarshal functions and methods take precedenceover the default representation of a value.Functions or methods that operate on *T are only called when decodinga value of type T (by taking its address) or a non-nil value of *T.Unmarshal ensures that a value is always addressable(by boxing it on the heap if necessary) so thatthese functions and methods can be consistently called.

The input is decoded into the output according the following rules:

• If any type-specific functions in aWithUnmarshalers option matchthe value type, then those functions are called to decode the JSONvalue. If all applicable functions returnSkipFunc,then the input is decoded according to subsequent rules.

• If the value type implementsUnmarshalerFrom,then the UnmarshalJSONFrom method is called to decode the JSON value.

• If the value type implementsUnmarshaler,then the UnmarshalJSON method is called to decode the JSON value.

• If the value type implementsencoding.TextUnmarshaler,then the input is decoded as a JSON string andthe UnmarshalText method is called with the decoded string value.This fails with aSemanticError if the input is not a JSON string.

• Otherwise, the JSON value is decoded according to the value's typeas described in detail below.

Most Go types have a default JSON representation.Certain types support specialized formatting according toa format flag optionally specified in the Go struct tagfor the struct field that contains the current value(see the “JSON Representation of Go structs” section for more details).A JSON null may be decoded into every supported Go value whereit is equivalent to storing the zero value of the Go value.If the input JSON kind is not handled by the current Go value type,then this fails with aSemanticError. Unless otherwise specified,the decoded value replaces any pre-existing value.

The representation of each type is as follows:

• A Go boolean is decoded from a JSON boolean (e.g., true or false).It does not support any custom format flags.

• A Go string is decoded from a JSON string.It does not support any custom format flags.

• A Go []byte or [N]byte is decoded from a JSON stringcontaining the binary value encoded usingRFC 4648.If the format is "base64" or unspecified, then this usesRFC 4648, section 4.If the format is "base64url", then this usesRFC 4648, section 5.If the format is "base32", then this usesRFC 4648, section 6.If the format is "base32hex", then this usesRFC 4648, section 7.If the format is "base16" or "hex", then this usesRFC 4648, section 8.If the format is "array", then the Go slice or array is decoded from aJSON array where each JSON element is recursively decoded for each byte.When decoding into a non-nil []byte, the slice length is reset to zeroand the decoded input is appended to it.When decoding into a [N]byte, the input must decode to exactly N bytes,otherwise it fails with aSemanticError.

• A Go integer is decoded from a JSON number.It must be decoded from a JSON string containing a JSON numberifStringifyNumbers is specified or decoding a JSON object name.It fails with aSemanticError if the JSON numberhas a fractional or exponent component.It also fails if it overflows the representation of the Go integer type.It does not support any custom format flags.

• A Go float is decoded from a JSON number.It must be decoded from a JSON string containing a JSON numberifStringifyNumbers is specified or decoding a JSON object name.It fails if it overflows the representation of the Go float type.If the format is "nonfinite", then the JSON strings"NaN", "Infinity", and "-Infinity" are decoded as NaN, +Inf, and -Inf.Otherwise, the presence of such strings results in aSemanticError.

• A Go map is decoded from a JSON object,where each JSON object name and value pair is recursively decodedas the Go map key and value. Maps are not cleared.If the Go map is nil, then a new map is allocated to decode into.If the decoded key matches an existing Go map entry, the entry valueis reused by decoding the JSON object value into it.The formats "emitnull" and "emitempty" have no effect when decoding.

• A Go struct is decoded from a JSON object.See the “JSON Representation of Go structs” sectionin the package-level documentation for more details.

• A Go slice is decoded from a JSON array, where each JSON elementis recursively decoded and appended to the Go slice.Before appending into a Go slice, a new slice is allocated if it is nil,otherwise the slice length is reset to zero.The formats "emitnull" and "emitempty" have no effect when decoding.

• A Go array is decoded from a JSON array, where each JSON array elementis recursively decoded as each corresponding Go array element.Each Go array element is zeroed before decoding into it.It fails with aSemanticError if the JSON array does not containthe exact same number of elements as the Go array.It does not support any custom format flags.

• A Go pointer is decoded based on the JSON kind and underlying Go type.If the input is a JSON null, then this stores a nil pointer.Otherwise, it allocates a new underlying value if the pointer is nil,and recursively JSON decodes into the underlying value.Format flags are forwarded to the decoding of the underlying type.

• A Go interface is decoded based on the JSON kind and underlying Go type.If the input is a JSON null, then this stores a nil interface value.Otherwise, a nil interface value of an empty interface type is initializedwith a zero Go bool, string, float64, map[string]any, or []any if theinput is a JSON boolean, string, number, object, or array, respectively.If the interface value is still nil, then this fails with aSemanticErrorsince decoding could not determine an appropriate Go type to decode into.For example, unmarshaling into a nil io.Reader fails sincethere is no concrete type to populate the interface value with.Otherwise an underlying value exists and it recursively decodesthe JSON input into it. It does not support any custom format flags.

• A Gotime.Time is decoded from a JSON string containing the timeformatted inRFC 3339 with nanosecond precision.If the format matches one of the format constants declared inthe time package (e.g., RFC1123), then that format is used for parsing.If the format is "unix", "unixmilli", "unixmicro", or "unixnano",then the timestamp is decoded from an optionally fractional JSON numberof the number of seconds (or milliseconds, microseconds, or nanoseconds)since the Unix epoch, which is January 1st, 1970 at 00:00:00 UTC.Otherwise, the format is used as-is withtime.Time.Parse if non-empty.

• A Gotime.Duration currently has no default representation andrequires an explicit format to be specified.If the format is "sec", "milli", "micro", or "nano",then the duration is decoded from an optionally fractional JSON numberof the number of seconds (or milliseconds, microseconds, or nanoseconds).If the format is "units", it is decoded from a JSON string parsed usingtime.ParseDuration (e.g., "1h30m" for 1 hour 30 minutes).If the format is "iso8601", it is decoded from a JSON string using theISO 8601 standard for durations (e.g., "PT1H30M" for 1 hour 30 minutes)accepting only accurate units of hours, minutes, or seconds.

• All other Go types (e.g., complex numbers, channels, and functions)have no default representation and result in aSemanticError.

In general, unmarshaling follows merge semantics (similar toRFC 7396)where the decoded Go value replaces the destination valuefor any JSON kind other than an object.For JSON objects, the input object is merged into the destination valuewhere matching object members recursively apply merge semantics.

funcUnmarshalDecode¶

func UnmarshalDecode(in *jsontext.Decoder, outany, opts ...Options) (errerror)

UnmarshalDecode deserializes a Go value from ajsontext.Decoder according tothe provided unmarshal options (while ignoring marshal, encode, or decode options).Any unmarshal options already specified on thejsontext.Decodertake lower precedence than the set of options provided by the caller.UnlikeUnmarshal andUnmarshalRead, decode options are ignored becausethey must have already been specified on the providedjsontext.Decoder.

The input may be a stream of zero or more JSON values,where this only unmarshals the next JSON value in the stream.If there are no more top-level JSON values, it reportsio.EOF.The output must be a non-nil pointer.SeeUnmarshal for details about the conversion of JSON into a Go value.

funcUnmarshalRead¶

func UnmarshalRead(inio.Reader, outany, opts ...Options) (errerror)

UnmarshalRead deserializes a Go value from anio.Reader according to theprovided unmarshal and decode options (while ignoring marshal or encode options).The input must be a single JSON value with optional whitespace interspersed.It consumes the entirety ofio.Reader untilio.EOF is encountered,without reporting an error for EOF. The output must be a non-nil pointer.SeeUnmarshal for details about the conversion of JSON into a Go value.

typeMarshaler¶

type Marshaler interface {MarshalJSON() ([]byte,error)}

Marshaler is implemented by types that can marshal themselves.It is recommended that types implementMarshalerTo unless the implementationis trying to avoid a hard dependency on the "jsontext" package.

It is recommended that implementations return a buffer that is safefor the caller to retain and potentially mutate.

If the returned error is aSemanticError, then unpopulated fieldsof the error may be populated byjson with additional context.Errors of other types are wrapped within aSemanticError.

typeMarshalerTo¶

type MarshalerTo interface {MarshalJSONTo(*jsontext.Encoder)error}

MarshalerTo is implemented by types that can marshal themselves.It is recommended that types implement MarshalerTo instead ofMarshalersince this is both more performant and flexible.If a type implements both Marshaler and MarshalerTo,then MarshalerTo takes precedence. In such a case, both implementationsshould aim to have equivalent behavior for the default marshal options.

The implementation must write only one JSON value to the Encoder andmust not retain the pointer tojsontext.Encoder.

If the returned error is aSemanticError, then unpopulated fieldsof the error may be populated byjson with additional context.Errors of other types are wrapped within aSemanticError,unless it is an IO error.

typeMarshalers¶

type Marshalers = typedMarshalers

Marshalers is a list of functions that may override the marshal behaviorof specific types. PopulateWithMarshalers to use it withMarshal,MarshalWrite, orMarshalEncode.A nil *Marshalers is equivalent to an empty list.There are no exported fields or methods on Marshalers.

func JoinMarshalers(ms ...*Marshalers) *Marshalers

m1 := JoinMarshalers(f1, f2)m2 := JoinMarshalers(f0, m1, f3)     // equivalent to m3m3 := JoinMarshalers(f0, f1, f2, f3) // equivalent to m2

func MarshalFunc[Tany](fn func(T) ([]byte,error)) *Marshalers

func MarshalToFunc[Tany](fn func(*jsontext.Encoder, T)error) *Marshalers

typeOptions¶

type Options =jsonopts.Options

Options configureMarshal,MarshalWrite,MarshalEncode,Unmarshal,UnmarshalRead, andUnmarshalDecode with specific features.Each function takes in a variadic list of options, where propertiesset in later options override the value of previously set properties.

The Options type is identical toencoding/json.Options andencoding/json/jsontext.Options. Options from the other packages canbe used interchangeably with functionality in this package.

Options represent either a singular option or a set of options.It can be functionally thought of as a Go map of option properties(even though the underlying implementation avoids Go maps for performance).

The constructors (e.g.,Deterministic) return a singular option value:

opt := Deterministic(true)

which is analogous to creating a single entry map:

opt := Options{"Deterministic": true}

JoinOptions composes multiple options values to together:

out := JoinOptions(opts...)

which is analogous to making a new map and copying the options over:

out := make(Options)for _, m := range opts {for k, v := range m {out[k] = v}}

GetOption looks up the value of options parameter:

v, ok := GetOption(opts, Deterministic)

which is analogous to a Go map lookup:

v, ok := Options["Deterministic"]

There is a single Options type, which is used with both marshal and unmarshal.Some options affect both operations, while others only affect one operation:

• StringifyNumbers affects marshaling and unmarshaling
• Deterministic affects marshaling only
• FormatNilSliceAsNull affects marshaling only
• FormatNilMapAsNull affects marshaling only
• OmitZeroStructFields affects marshaling only
• MatchCaseInsensitiveNames affects marshaling and unmarshaling
• DiscardUnknownMembers affects marshaling only
• RejectUnknownMembers affects unmarshaling only
• WithMarshalers affects marshaling only
• WithUnmarshalers affects unmarshaling only

Options that do not affect a particular operation are ignored.

func DefaultOptionsV2()Options

func Deterministic(vbool)Options

func DiscardUnknownMembers(vbool)Options

func FormatNilMapAsNull(vbool)Options

func FormatNilSliceAsNull(vbool)Options

func JoinOptions(srcs ...Options)Options

func MatchCaseInsensitiveNames(vbool)Options

func OmitZeroStructFields(vbool)Options

func RejectUnknownMembers(vbool)Options

func StringifyNumbers(vbool)Options

func WithMarshalers(v *Marshalers)Options

package mainimport ("fmt""log""os""strconv""github.com/go-json-experiment/json""github.com/go-json-experiment/json/jsontext")func main() {// Response to serialize with some Go errors encountered.response := []struct {Result string `json:",omitzero"`Error  error  `json:",omitzero"`}{{Result: "Oranges are a good source of Vitamin C."},{Error: &strconv.NumError{Func: "ParseUint", Num: "-1234", Err: strconv.ErrSyntax}},{Error: &os.PathError{Op: "ReadFile", Path: "/path/to/secret/file", Err: os.ErrPermission}},}b, err := json.Marshal(&response,// Intercept every attempt to marshal an error type.json.WithMarshalers(json.JoinMarshalers(// Suppose we consider strconv.NumError to be a safe to serialize:// this type-specific marshal function intercepts this type// and encodes the error message as a JSON string.json.MarshalToFunc(func(enc *jsontext.Encoder, err *strconv.NumError) error {return enc.WriteToken(jsontext.String(err.Error()))}),// Error messages may contain sensitive information that may not// be appropriate to serialize. For all errors not handled above,// report some generic error message.json.MarshalFunc(func(error) ([]byte, error) {return []byte(`"internal server error"`), nil}),)),jsontext.Multiline(true)) // expand for readabilityif err != nil {log.Fatal(err)}fmt.Println(string(b))}

Output:[{"Result": "Oranges are a good source of Vitamin C."},{"Error": "strconv.ParseUint: parsing \"-1234\": invalid syntax"},{"Error": "internal server error"}]

func WithUnmarshalers(v *Unmarshalers)Options

package mainimport ("fmt""log""reflect""github.com/go-json-experiment/json""github.com/go-json-experiment/json/jsontext")func main() {// Input with JSON numbers beyond the representation of a float64.const input = `[false, 1e-1000, 3.141592653589793238462643383279, 1e+1000, true]`var value anyerr := json.Unmarshal([]byte(input), &value,// Intercept every attempt to unmarshal into the any type.json.WithUnmarshalers(json.UnmarshalFromFunc(func(dec *jsontext.Decoder, val *any) error {// If the next value to be decoded is a JSON number,// then provide a concrete Go type to unmarshal into.if dec.PeekKind() == '0' {*val = jsontext.Value(nil)}// Return SkipFunc to fallback on default unmarshal behavior.return json.SkipFunc}),))if err != nil {log.Fatal(err)}fmt.Println(value)// Sanity check.want := []any{false, jsontext.Value("1e-1000"), jsontext.Value("3.141592653589793238462643383279"), jsontext.Value("1e+1000"), true}if !reflect.DeepEqual(value, want) {log.Fatalf("value mismatch:\ngot  %v\nwant %v", value, want)}}

Output:[false 1e-1000 3.141592653589793238462643383279 1e+1000 true]

package mainimport ("bytes""fmt""log""net/netip""strings""github.com/go-json-experiment/json""github.com/go-json-experiment/json/jsontext")func main() {// Hypothetical configuration file.const input = `[{"Source": "192.168.0.100:1234", "Destination": "192.168.0.1:80"},{"Source": "192.168.0.251:4004"},{"Source": "192.168.0.165:8080", "Destination": "0.0.0.0:80"}]`type Tunnel struct {Source      netip.AddrPortDestination netip.AddrPort// ByteOffset is populated during unmarshal with the byte offset// within the JSON input of the JSON object for this Go struct.ByteOffset int64 `json:"-"` // metadata to be ignored for JSON serialization}var tunnels []Tunnelerr := json.Unmarshal([]byte(input), &tunnels,// Intercept every attempt to unmarshal into the Tunnel type.json.WithUnmarshalers(json.UnmarshalFromFunc(func(dec *jsontext.Decoder, tunnel *Tunnel) error {// Decoder.InputOffset reports the offset after the last token,// but we want to record the offset before the next token.//// Call Decoder.PeekKind to buffer enough to reach the next token.// Add the number of leading whitespace, commas, and colons// to locate the start of the next token.dec.PeekKind()unread := dec.UnreadBuffer()n := len(unread) - len(bytes.TrimLeft(unread, " \n\r\t,:"))tunnel.ByteOffset = dec.InputOffset() + int64(n)// Return SkipFunc to fallback on default unmarshal behavior.return json.SkipFunc}),))if err != nil {log.Fatal(err)}// lineColumn converts a byte offset into a one-indexed line and column.// The offset must be within the bounds of the input.lineColumn := func(input string, offset int) (line, column int) {line = 1 + strings.Count(input[:offset], "\n")column = 1 + offset - (strings.LastIndex(input[:offset], "\n") + len("\n"))return line, column}// Verify that the configuration file is valid.for _, tunnel := range tunnels {if !tunnel.Source.IsValid() || !tunnel.Destination.IsValid() {line, column := lineColumn(input, int(tunnel.ByteOffset))fmt.Printf("%d:%d: source and destination must both be specified", line, column)}}}

Output:3:3: source and destination must both be specified

typeSemanticError¶

type SemanticError struct {// ByteOffset indicates that an error occurred after this byte offset.ByteOffsetint64// JSONPointer indicates that an error occurred within this JSON value// as indicated using the JSON Pointer notation (seeRFC 6901).JSONPointerjsontext.Pointer// JSONKind is the JSON kind that could not be handled.JSONKindjsontext.Kind// may be zero if unknown// JSONValue is the JSON number or string that could not be unmarshaled.// It is not populated during marshaling.JSONValuejsontext.Value// may be nil if irrelevant or unknown// GoType is the Go type that could not be handled.GoTypereflect.Type// may be nil if unknown// Err is the underlying error.Errerror// may be nil// contains filtered or unexported fields}

SemanticError describes an error determining the meaningof JSON data as Go data or vice-versa.

If aMarshaler,MarshalerTo,Unmarshaler, orUnmarshalerFrom methodreturns a SemanticError when called by thejson package,then the ByteOffset, JSONPointer, and GoType fields are automaticallypopulated by the calling context if they are the zero value.

The contents of this error as produced by this package may change over time.

func (e *SemanticError) Error()string

func (e *SemanticError) Unwrap()error

typeUnmarshaler¶

type Unmarshaler interface {UnmarshalJSON([]byte)error}

Unmarshaler is implemented by types that can unmarshal themselves.It is recommended that types implementUnmarshalerFrom unless the implementationis trying to avoid a hard dependency on the "jsontext" package.

The input can be assumed to be a valid encoding of a JSON valueif called from unmarshal functionality in this package.UnmarshalJSON must copy the JSON data if it is retained after returning.It is recommended that UnmarshalJSON implement merge semantics whenunmarshaling into a pre-populated value.

Implementations must not retain or mutate the input []byte.

If the returned error is aSemanticError, then unpopulated fieldsof the error may be populated byjson with additional context.Errors of other types are wrapped within aSemanticError.

typeUnmarshalerFrom¶

type UnmarshalerFrom interface {UnmarshalJSONFrom(*jsontext.Decoder)error}

UnmarshalerFrom is implemented by types that can unmarshal themselves.It is recommended that types implement UnmarshalerFrom instead ofUnmarshalersince this is both more performant and flexible.If a type implements both Unmarshaler and UnmarshalerFrom,then UnmarshalerFrom takes precedence. In such a case, both implementationsshould aim to have equivalent behavior for the default unmarshal options.

The implementation must read only one JSON value from the Decoder.It is recommended that UnmarshalJSONFrom implement merge semantics whenunmarshaling into a pre-populated value.

Implementations must not retain the pointer tojsontext.Decoder.

If the returned error is aSemanticError, then unpopulated fieldsof the error may be populated byjson with additional context.Errors of other types are wrapped within aSemanticError,unless it is ajsontext.SyntacticError or an IO error.

typeUnmarshalers¶

type Unmarshalers = typedUnmarshalers

Unmarshalers is a list of functions that may override the unmarshal behaviorof specific types. PopulateWithUnmarshalers to use it withUnmarshal,UnmarshalRead, orUnmarshalDecode.A nil *Unmarshalers is equivalent to an empty list.There are no exported fields or methods on Unmarshalers.

func JoinUnmarshalers(us ...*Unmarshalers) *Unmarshalers

u1 := JoinUnmarshalers(f1, f2)u2 := JoinUnmarshalers(f0, u1, f3)     // equivalent to u3u3 := JoinUnmarshalers(f0, f1, f2, f3) // equivalent to u2

func UnmarshalFromFunc[Tany](fn func(*jsontext.Decoder, T)error) *Unmarshalers

func UnmarshalFunc[Tany](fn func([]byte, T)error) *Unmarshalers