| 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581 |
- // Copyright 2020 The Go Authors. All rights reserved.
- // Use of this source code is governed by a BSD-style
- // license that can be found in the LICENSE file.
- package json
- import (
- "bytes"
- "io"
- "reflect"
- "slices"
- "strings"
- "sync"
- "github.com/go-json-experiment/json/internal"
- "github.com/go-json-experiment/json/internal/jsonflags"
- "github.com/go-json-experiment/json/internal/jsonopts"
- "github.com/go-json-experiment/json/jsontext"
- )
- // export exposes internal functionality of the "jsontext" package.
- var export = jsontext.Internal.Export(&internal.AllowInternalUse)
- // mayReuseOpt reuses coderOpts if joining opts with the coderOpts
- // would produce the equivalent set of options.
- func mayReuseOpt(coderOpts *jsonopts.Struct, opts []Options) *jsonopts.Struct {
- switch len(opts) {
- // In the common case, the caller plumbs down options from the caller's caller,
- // which is usually the [jsonopts.Struct] constructed by the top-level arshal call.
- case 1:
- o, _ := opts[0].(*jsonopts.Struct)
- if o == coderOpts {
- return coderOpts
- }
- // If the caller provides no options, then just reuse the coder's options,
- // which should only contain encoding/decoding related flags.
- case 0:
- // TODO: This is buggy if coderOpts ever contains non-coder options.
- return coderOpts
- }
- return nil
- }
- var structOptionsPool = &sync.Pool{New: func() any { return new(jsonopts.Struct) }}
- func getStructOptions() *jsonopts.Struct {
- return structOptionsPool.Get().(*jsonopts.Struct)
- }
- func putStructOptions(o *jsonopts.Struct) {
- *o = jsonopts.Struct{}
- structOptionsPool.Put(o)
- }
- // Marshal serializes a Go value as a []byte according to the provided
- // marshal 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 precedence
- // over the default representation of a value.
- // Functions or methods that operate on *T are only called when encoding
- // a 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 that
- // these 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 a [WithMarshalers] option match
- // the value type, then those functions are called to encode the value.
- // If all applicable functions return [SkipFunc],
- // then the value is encoded according to subsequent rules.
- //
- // - If the value type implements [MarshalerTo],
- // then the MarshalJSONTo method is called to encode the value.
- //
- // - If the value type implements [Marshaler],
- // then the MarshalJSON method is called to encode the value.
- //
- // - If the value type implements [encoding.TextMarshaler],
- // then the MarshalText method is called to encode the value and
- // subsequently encode its result as a JSON string.
- //
- // - Otherwise, the value is encoded according to the value's type
- // as described in detail below.
- //
- // Most Go types have a default JSON representation.
- // Certain types support specialized formatting according to
- // a format flag optionally specified in the Go struct tag
- // for 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 containing
- // the binary value encoded using RFC 4648.
- // If the format is "base64" or unspecified, then this uses RFC 4648, section 4.
- // If the format is "base64url", then this uses RFC 4648, section 5.
- // If the format is "base32", then this uses RFC 4648, section 6.
- // If the format is "base32hex", then this uses RFC 4648, section 7.
- // If the format is "base16" or "hex", then this uses RFC 4648, section 8.
- // If the format is "array", then the bytes value is encoded as a JSON array
- // where each byte is recursively JSON-encoded as each JSON array element.
- //
- // - A Go integer is encoded as a JSON number without fractions or exponents.
- // If [StringifyNumbers] 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.
- // If [StringifyNumbers] 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 as
- // the JSON strings "NaN", "Infinity", and "-Infinity", respectively.
- // Otherwise, the presence of non-finite numbers results in a [SemanticError].
- //
- // - A Go map is encoded as a JSON object, where each Go map key and value
- // is recursively encoded as a name and value pair in the JSON object.
- // The Go map key must encode as a JSON string, otherwise this results
- // in a [SemanticError]. The Go map is traversed in a non-deterministic order.
- // For deterministic encoding, consider using the [Deterministic] 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 whether [FormatNilMapAsNull] 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” section
- // in the package-level documentation for more details.
- //
- // - A Go slice is encoded as a JSON array, where each Go slice element
- // is 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 whether [FormatNilSliceAsNull] 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 element
- // is 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 is
- // the 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 is
- // the recursively JSON-encoded representation of the underlying value.
- // It does not support any custom format flags.
- //
- // - A Go [time.Time] is encoded as a JSON string containing the timestamp
- // formatted in RFC 3339 with nanosecond precision.
- // If the format matches one of the format constants declared
- // in 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 JSON number of 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 with [time.Time.Format] if non-empty.
- //
- // - A Go [time.Duration] is encoded as a JSON string containing the duration
- // formatted according to [time.Duration.String].
- // If the format is "sec", "milli", "micro", or "nano",
- // then the duration is encoded as a JSON number of the number of seconds
- // (or milliseconds, microseconds, or nanoseconds) in the duration.
- // If the format is "base60", it is encoded as a JSON string
- // using the "H:MM:SS.SSSSSSSSS" representation.
- // If the format is "units", it uses [time.Duration.String].
- //
- // - All other Go types (e.g., complex numbers, channels, and functions)
- // have no default representation and result in a [SemanticError].
- //
- // JSON cannot represent cyclic data structures and Marshal does not handle them.
- // Passing cyclic structures will result in an error.
- func Marshal(in any, opts ...Options) (out []byte, err error) {
- enc := export.GetBufferedEncoder(opts...)
- defer export.PutBufferedEncoder(enc)
- xe := export.Encoder(enc)
- xe.Flags.Set(jsonflags.OmitTopLevelNewline | 1)
- err = marshalEncode(enc, in, &xe.Struct)
- if err != nil && xe.Flags.Get(jsonflags.ReportErrorsWithLegacySemantics) {
- return nil, internal.TransformMarshalError(in, err)
- }
- return bytes.Clone(xe.Buf), err
- }
- // MarshalWrite serializes a Go value into an [io.Writer] according to the provided
- // marshal and encode options (while ignoring unmarshal or decode options).
- // It does not terminate the output with a newline.
- // See [Marshal] for details about the conversion of a Go value into JSON.
- func MarshalWrite(out io.Writer, in any, opts ...Options) (err error) {
- enc := export.GetStreamingEncoder(out, opts...)
- defer export.PutStreamingEncoder(enc)
- xe := export.Encoder(enc)
- xe.Flags.Set(jsonflags.OmitTopLevelNewline | 1)
- err = marshalEncode(enc, in, &xe.Struct)
- if err != nil && xe.Flags.Get(jsonflags.ReportErrorsWithLegacySemantics) {
- return internal.TransformMarshalError(in, err)
- }
- return err
- }
- // MarshalEncode serializes a Go value into an [jsontext.Encoder] according to
- // the provided marshal options (while ignoring unmarshal, encode, or decode options).
- // Unlike [Marshal] and [MarshalWrite], encode options are ignored because
- // they must have already been specified on the provided [jsontext.Encoder].
- // See [Marshal] for details about the conversion of a Go value into JSON.
- func MarshalEncode(out *jsontext.Encoder, in any, opts ...Options) (err error) {
- xe := export.Encoder(out)
- mo := mayReuseOpt(&xe.Struct, opts)
- if mo == nil {
- mo = getStructOptions()
- defer putStructOptions(mo)
- mo.Join(opts...)
- mo.CopyCoderOptions(&xe.Struct)
- }
- err = marshalEncode(out, in, mo)
- if err != nil && mo.Flags.Get(jsonflags.ReportErrorsWithLegacySemantics) {
- return internal.TransformMarshalError(in, err)
- }
- return err
- }
- func marshalEncode(out *jsontext.Encoder, in any, mo *jsonopts.Struct) (err error) {
- v := reflect.ValueOf(in)
- if !v.IsValid() || (v.Kind() == reflect.Pointer && v.IsNil()) {
- return out.WriteToken(jsontext.Null)
- }
- // Shallow copy non-pointer values to obtain an addressable value.
- // It is beneficial to performance to always pass pointers to avoid this.
- forceAddr := v.Kind() != reflect.Pointer
- if forceAddr {
- v2 := reflect.New(v.Type())
- v2.Elem().Set(v)
- v = v2
- }
- va := addressableValue{v.Elem(), forceAddr} // dereferenced pointer is always addressable
- t := va.Type()
- // Lookup and call the marshal function for this type.
- marshal := lookupArshaler(t).marshal
- if mo.Marshalers != nil {
- marshal, _ = mo.Marshalers.(*Marshalers).lookup(marshal, t)
- }
- if err := marshal(out, va, mo); err != nil {
- if !mo.Flags.Get(jsonflags.AllowDuplicateNames) {
- export.Encoder(out).Tokens.InvalidateDisabledNamespaces()
- }
- return err
- }
- return nil
- }
- // Unmarshal decodes a []byte input into a Go value according to the provided
- // unmarshal 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 precedence
- // over the default representation of a value.
- // Functions or methods that operate on *T are only called when decoding
- // a 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 that
- // these functions and methods can be consistently called.
- //
- // The input is decoded into the output according the following rules:
- //
- // - If any type-specific functions in a [WithUnmarshalers] option match
- // the value type, then those functions are called to decode the JSON
- // value. If all applicable functions return [SkipFunc],
- // then the input is decoded according to subsequent rules.
- //
- // - If the value type implements [UnmarshalerFrom],
- // then the UnmarshalJSONFrom method is called to decode the JSON value.
- //
- // - If the value type implements [Unmarshaler],
- // then the UnmarshalJSON method is called to decode the JSON value.
- //
- // - If the value type implements [encoding.TextUnmarshaler],
- // then the input is decoded as a JSON string and
- // the UnmarshalText method is called with the decoded string value.
- // This fails with a [SemanticError] if the input is not a JSON string.
- //
- // - Otherwise, the JSON value is decoded according to the value's type
- // as described in detail below.
- //
- // Most Go types have a default JSON representation.
- // Certain types support specialized formatting according to
- // a format flag optionally specified in the Go struct tag
- // for 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 where
- // it 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 a [SemanticError]. 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 string
- // containing the binary value encoded using RFC 4648.
- // If the format is "base64" or unspecified, then this uses RFC 4648, section 4.
- // If the format is "base64url", then this uses RFC 4648, section 5.
- // If the format is "base32", then this uses RFC 4648, section 6.
- // If the format is "base32hex", then this uses RFC 4648, section 7.
- // If the format is "base16" or "hex", then this uses RFC 4648, section 8.
- // If the format is "array", then the Go slice or array is decoded from a
- // JSON array where each JSON element is recursively decoded for each byte.
- // When decoding into a non-nil []byte, the slice length is reset to zero
- // and 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 a [SemanticError].
- //
- // - A Go integer is decoded from a JSON number.
- // It must be decoded from a JSON string containing a JSON number
- // if [StringifyNumbers] is specified or decoding a JSON object name.
- // It fails with a [SemanticError] if the JSON number
- // has 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 number
- // if [StringifyNumbers] 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 a [SemanticError].
- //
- // - A Go map is decoded from a JSON object,
- // where each JSON object name and value pair is recursively decoded
- // as 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 value
- // is 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” section
- // in the package-level documentation for more details.
- //
- // - A Go slice is decoded from a JSON array, where each JSON element
- // is 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 element
- // is recursively decoded as each corresponding Go array element.
- // Each Go array element is zeroed before decoding into it.
- // It fails with a [SemanticError] if the JSON array does not contain
- // the 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 initialized
- // with a zero Go bool, string, float64, map[string]any, or []any if the
- // input is a JSON boolean, string, number, object, or array, respectively.
- // If the interface value is still nil, then this fails with a [SemanticError]
- // since decoding could not determine an appropriate Go type to decode into.
- // For example, unmarshaling into a nil io.Reader fails since
- // there is no concrete type to populate the interface value with.
- // Otherwise an underlying value exists and it recursively decodes
- // the JSON input into it. It does not support any custom format flags.
- //
- // - A Go [time.Time] is decoded from a JSON string containing the time
- // formatted in RFC 3339 with nanosecond precision.
- // If the format matches one of the format constants declared in
- // the 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 a JSON number of 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 with [time.Time.Parse] if non-empty.
- //
- // - A Go [time.Duration] is decoded from a JSON string by
- // passing the decoded string to [time.ParseDuration].
- // If the format is "sec", "milli", "micro", or "nano",
- // then the duration is decoded from a JSON number of the number of seconds
- // (or milliseconds, microseconds, or nanoseconds) in the duration.
- // If the format is "base60", it is decoded from a JSON string
- // using the "H:MM:SS.SSSSSSSSS" representation.
- // If the format is "units", it uses [time.ParseDuration].
- //
- // - All other Go types (e.g., complex numbers, channels, and functions)
- // have no default representation and result in a [SemanticError].
- //
- // In general, unmarshaling follows merge semantics (similar to RFC 7396)
- // where the decoded Go value replaces the destination value
- // for any JSON kind other than an object.
- // For JSON objects, the input object is merged into the destination value
- // where matching object members recursively apply merge semantics.
- func Unmarshal(in []byte, out any, opts ...Options) (err error) {
- dec := export.GetBufferedDecoder(in, opts...)
- defer export.PutBufferedDecoder(dec)
- xd := export.Decoder(dec)
- err = unmarshalFull(dec, out, &xd.Struct)
- if err != nil && xd.Flags.Get(jsonflags.ReportErrorsWithLegacySemantics) {
- return internal.TransformUnmarshalError(out, err)
- }
- return err
- }
- // UnmarshalRead deserializes a Go value from an [io.Reader] according to the
- // provided 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 of [io.Reader] until [io.EOF] is encountered,
- // without reporting an error for EOF. The output must be a non-nil pointer.
- // See [Unmarshal] for details about the conversion of JSON into a Go value.
- func UnmarshalRead(in io.Reader, out any, opts ...Options) (err error) {
- dec := export.GetStreamingDecoder(in, opts...)
- defer export.PutStreamingDecoder(dec)
- xd := export.Decoder(dec)
- err = unmarshalFull(dec, out, &xd.Struct)
- if err != nil && xd.Flags.Get(jsonflags.ReportErrorsWithLegacySemantics) {
- return internal.TransformUnmarshalError(out, err)
- }
- return err
- }
- func unmarshalFull(in *jsontext.Decoder, out any, uo *jsonopts.Struct) error {
- switch err := unmarshalDecode(in, out, uo); err {
- case nil:
- return export.Decoder(in).CheckEOF()
- case io.EOF:
- return io.ErrUnexpectedEOF
- default:
- return err
- }
- }
- // UnmarshalDecode deserializes a Go value from a [jsontext.Decoder] according to
- // the provided unmarshal options (while ignoring marshal, encode, or decode options).
- // Unlike [Unmarshal] and [UnmarshalRead], decode options are ignored because
- // they must have already been specified on the provided [jsontext.Decoder].
- // The input may be a stream of one or more JSON values,
- // where this only unmarshals the next JSON value in the stream.
- // The output must be a non-nil pointer.
- // See [Unmarshal] for details about the conversion of JSON into a Go value.
- func UnmarshalDecode(in *jsontext.Decoder, out any, opts ...Options) (err error) {
- xd := export.Decoder(in)
- uo := mayReuseOpt(&xd.Struct, opts)
- if uo == nil {
- uo = getStructOptions()
- defer putStructOptions(uo)
- uo.Join(opts...)
- uo.CopyCoderOptions(&xd.Struct)
- }
- err = unmarshalDecode(in, out, uo)
- if err != nil && uo.Flags.Get(jsonflags.ReportErrorsWithLegacySemantics) {
- return internal.TransformUnmarshalError(out, err)
- }
- return err
- }
- func unmarshalDecode(in *jsontext.Decoder, out any, uo *jsonopts.Struct) (err error) {
- v := reflect.ValueOf(out)
- if v.Kind() != reflect.Pointer || v.IsNil() {
- return &SemanticError{action: "unmarshal", GoType: reflect.TypeOf(out), Err: internal.ErrNonNilReference}
- }
- va := addressableValue{v.Elem(), false} // dereferenced pointer is always addressable
- t := va.Type()
- // In legacy semantics, the entirety of the next JSON value
- // was validated before attempting to unmarshal it.
- if uo.Flags.Get(jsonflags.ReportErrorsWithLegacySemantics) {
- if err := export.Decoder(in).CheckNextValue(); err != nil {
- return err
- }
- }
- // Lookup and call the unmarshal function for this type.
- unmarshal := lookupArshaler(t).unmarshal
- if uo.Unmarshalers != nil {
- unmarshal, _ = uo.Unmarshalers.(*Unmarshalers).lookup(unmarshal, t)
- }
- if err := unmarshal(in, va, uo); err != nil {
- if !uo.Flags.Get(jsonflags.AllowDuplicateNames) {
- export.Decoder(in).Tokens.InvalidateDisabledNamespaces()
- }
- return err
- }
- return nil
- }
- // addressableValue is a reflect.Value that is guaranteed to be addressable
- // such that calling the Addr and Set methods do not panic.
- //
- // There is no compile magic that enforces this property,
- // but rather the need to construct this type makes it easier to examine each
- // construction site to ensure that this property is upheld.
- type addressableValue struct {
- reflect.Value
- // forcedAddr reports whether this value is addressable
- // only through the use of [newAddressableValue].
- // This is only used for [jsonflags.CallMethodsWithLegacySemantics].
- forcedAddr bool
- }
- // newAddressableValue constructs a new addressable value of type t.
- func newAddressableValue(t reflect.Type) addressableValue {
- return addressableValue{reflect.New(t).Elem(), true}
- }
- // All marshal and unmarshal behavior is implemented using these signatures.
- // The *jsonopts.Struct argument is guaranteed to identical to or at least
- // a strict super-set of the options in Encoder.Struct or Decoder.Struct.
- // It is identical for Marshal, Unmarshal, MarshalWrite, and UnmarshalRead.
- // It is a super-set for MarshalEncode and UnmarshalDecode.
- type (
- marshaler = func(*jsontext.Encoder, addressableValue, *jsonopts.Struct) error
- unmarshaler = func(*jsontext.Decoder, addressableValue, *jsonopts.Struct) error
- )
- type arshaler struct {
- marshal marshaler
- unmarshal unmarshaler
- nonDefault bool
- }
- var lookupArshalerCache sync.Map // map[reflect.Type]*arshaler
- func lookupArshaler(t reflect.Type) *arshaler {
- if v, ok := lookupArshalerCache.Load(t); ok {
- return v.(*arshaler)
- }
- fncs := makeDefaultArshaler(t)
- fncs = makeMethodArshaler(fncs, t)
- fncs = makeTimeArshaler(fncs, t)
- // Use the last stored so that duplicate arshalers can be garbage collected.
- v, _ := lookupArshalerCache.LoadOrStore(t, fncs)
- return v.(*arshaler)
- }
- var stringsPools = &sync.Pool{New: func() any { return new(stringSlice) }}
- type stringSlice []string
- // getStrings returns a non-nil pointer to a slice with length n.
- func getStrings(n int) *stringSlice {
- s := stringsPools.Get().(*stringSlice)
- if cap(*s) < n {
- *s = make([]string, n)
- }
- *s = (*s)[:n]
- return s
- }
- func putStrings(s *stringSlice) {
- if cap(*s) > 1<<10 {
- *s = nil // avoid pinning arbitrarily large amounts of memory
- }
- stringsPools.Put(s)
- }
- func (ss *stringSlice) Sort() {
- slices.SortFunc(*ss, func(x, y string) int { return strings.Compare(x, y) })
- }
|