diff --git a/go.mod b/go.mod
index 2ca32f5f..14cd7f7f 100644
--- a/go.mod
+++ b/go.mod
@@ -1,23 +1,23 @@
module github.com/datarhei/core/v16
-go 1.23.0
+go 1.24.0
toolchain go1.24.2
require (
- github.com/99designs/gqlgen v0.17.76
+ github.com/99designs/gqlgen v0.17.84
github.com/Masterminds/semver/v3 v3.4.0
github.com/adhocore/gronx v1.19.6
github.com/andybalholm/brotli v1.2.0
github.com/atrox/haikunatorgo/v2 v2.0.1
- github.com/caddyserver/certmagic v0.23.0
+ github.com/caddyserver/certmagic v0.25.0
github.com/datarhei/gosrt v0.9.0
github.com/datarhei/joy4 v0.0.0-20250818192923-6dc77ee81363
github.com/dolthub/swiss v0.2.1
github.com/fujiwara/shapeio v1.0.0
- github.com/go-playground/validator/v10 v10.27.0
+ github.com/go-playground/validator/v10 v10.28.0
github.com/gobwas/glob v0.2.3
- github.com/golang-jwt/jwt/v5 v5.2.2
+ github.com/golang-jwt/jwt/v5 v5.3.0
github.com/google/gops v0.3.28
github.com/google/uuid v1.6.0
github.com/hashicorp/go-hclog v1.6.3
@@ -25,28 +25,28 @@ require (
github.com/hashicorp/raft-boltdb/v2 v2.3.1
github.com/invopop/jsonschema v0.4.0
github.com/joho/godotenv v1.5.1
- github.com/klauspost/compress v1.18.0
- github.com/klauspost/cpuid/v2 v2.2.11
+ github.com/klauspost/compress v1.18.2
+ github.com/klauspost/cpuid/v2 v2.3.0
github.com/labstack/echo/v4 v4.13.4
- github.com/lestrrat-go/strftime v1.1.0
+ github.com/lestrrat-go/strftime v1.1.1
github.com/lithammer/shortuuid/v4 v4.2.0
github.com/mattn/go-isatty v0.0.20
- github.com/minio/minio-go/v7 v7.0.94
- github.com/prometheus/client_golang v1.22.0
+ github.com/minio/minio-go/v7 v7.0.97
+ github.com/prometheus/client_golang v1.23.2
github.com/puzpuzpuz/xsync/v3 v3.5.1
github.com/sergi/go-diff v1.3.1
github.com/shirou/gopsutil/v3 v3.24.5
- github.com/stretchr/testify v1.10.0
+ github.com/stretchr/testify v1.11.1
github.com/swaggo/echo-swagger v1.4.1
- github.com/swaggo/swag v1.16.4
- github.com/tklauser/go-sysconf v0.3.15
- github.com/vektah/gqlparser/v2 v2.5.30
+ github.com/swaggo/swag v1.16.6
+ github.com/tklauser/go-sysconf v0.3.16
+ github.com/vektah/gqlparser/v2 v2.5.31
github.com/xeipuuv/gojsonschema v1.2.0
- go.etcd.io/bbolt v1.4.2
+ go.etcd.io/bbolt v1.4.3
go.uber.org/automaxprocs v1.6.0
- go.uber.org/zap v1.27.0
- golang.org/x/crypto v0.39.0
- golang.org/x/mod v0.25.0
+ go.uber.org/zap v1.27.1
+ golang.org/x/crypto v0.45.0
+ golang.org/x/mod v0.30.0
)
require (
@@ -58,72 +58,76 @@ require (
github.com/boltdb/bolt v1.3.1 // indirect
github.com/caddyserver/zerossl v0.1.3 // indirect
github.com/cespare/xxhash/v2 v2.3.0 // indirect
- github.com/cpuguy83/go-md2man/v2 v2.0.7 // indirect
github.com/davecgh/go-spew v1.1.1 // indirect
github.com/dolthub/maphash v0.1.0 // indirect
github.com/dustin/go-humanize v1.0.1 // indirect
github.com/fatih/color v1.18.0 // indirect
- github.com/gabriel-vasile/mimetype v1.4.9 // indirect
+ github.com/gabriel-vasile/mimetype v1.4.11 // indirect
github.com/ghodss/yaml v1.0.0 // indirect
github.com/go-ini/ini v1.67.0 // indirect
github.com/go-ole/go-ole v1.3.0 // indirect
- github.com/go-openapi/jsonpointer v0.21.1 // indirect
- github.com/go-openapi/jsonreference v0.21.0 // indirect
- github.com/go-openapi/spec v0.21.0 // indirect
- github.com/go-openapi/swag v0.23.1 // indirect
+ github.com/go-openapi/jsonpointer v0.22.3 // indirect
+ github.com/go-openapi/jsonreference v0.21.3 // indirect
+ github.com/go-openapi/spec v0.22.1 // indirect
+ github.com/go-openapi/swag/conv v0.25.4 // indirect
+ github.com/go-openapi/swag/jsonname v0.25.4 // indirect
+ github.com/go-openapi/swag/jsonutils v0.25.4 // indirect
+ github.com/go-openapi/swag/loading v0.25.4 // indirect
+ github.com/go-openapi/swag/stringutils v0.25.4 // indirect
+ github.com/go-openapi/swag/typeutils v0.25.4 // indirect
+ github.com/go-openapi/swag/yamlutils v0.25.4 // indirect
github.com/go-playground/locales v0.14.1 // indirect
github.com/go-playground/universal-translator v0.18.1 // indirect
- github.com/go-viper/mapstructure/v2 v2.3.0 // indirect
- github.com/goccy/go-json v0.10.5 // indirect
+ github.com/go-viper/mapstructure/v2 v2.4.0 // indirect
+ github.com/goccy/go-yaml v1.18.0 // indirect
github.com/gorilla/websocket v1.5.3 // indirect
github.com/hashicorp/go-immutable-radix v1.3.1 // indirect
github.com/hashicorp/go-metrics v0.5.4 // indirect
- github.com/hashicorp/go-msgpack/v2 v2.1.3 // indirect
+ github.com/hashicorp/go-msgpack/v2 v2.1.5 // indirect
github.com/hashicorp/golang-lru v1.0.2 // indirect
github.com/hashicorp/golang-lru/v2 v2.0.7 // indirect
github.com/iancoleman/orderedmap v0.2.0 // indirect
- github.com/josharian/intern v1.0.0 // indirect
+ github.com/klauspost/crc32 v1.3.0 // indirect
github.com/labstack/gommon v0.4.2 // indirect
github.com/leodido/go-urn v1.4.0 // indirect
- github.com/libdns/libdns v1.1.0 // indirect
- github.com/lufia/plan9stats v0.0.0-20250317134145-8bc96cf8fc35 // indirect
- github.com/mailru/easyjson v0.9.0 // indirect
+ github.com/libdns/libdns v1.1.1 // indirect
+ github.com/lufia/plan9stats v0.0.0-20251013123823-9fd1530e3ec3 // indirect
github.com/mattn/go-colorable v0.1.14 // indirect
- github.com/mholt/acmez/v3 v3.1.2 // indirect
- github.com/miekg/dns v1.1.66 // indirect
- github.com/minio/crc64nvme v1.0.2 // indirect
+ github.com/mholt/acmez/v3 v3.1.4 // indirect
+ github.com/miekg/dns v1.1.68 // indirect
+ github.com/minio/crc64nvme v1.1.1 // indirect
github.com/minio/md5-simd v1.1.2 // indirect
github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 // indirect
github.com/philhofer/fwd v1.2.0 // indirect
github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // indirect
github.com/power-devops/perfstat v0.0.0-20240221224432-82ca36839d55 // indirect
github.com/prometheus/client_model v0.6.2 // indirect
- github.com/prometheus/common v0.65.0 // indirect
- github.com/prometheus/procfs v0.17.0 // indirect
+ github.com/prometheus/common v0.67.4 // indirect
+ github.com/prometheus/procfs v0.19.2 // indirect
github.com/rs/xid v1.6.0 // indirect
- github.com/russross/blackfriday/v2 v2.1.0 // indirect
- github.com/shoenig/go-m1cpu v0.1.6 // indirect
+ github.com/shoenig/go-m1cpu v0.1.7 // indirect
github.com/sosodev/duration v1.3.1 // indirect
github.com/swaggo/files/v2 v2.0.2 // indirect
- github.com/tinylib/msgp v1.3.0 // indirect
- github.com/tklauser/numcpus v0.10.0 // indirect
- github.com/urfave/cli/v2 v2.27.7 // indirect
+ github.com/tinylib/msgp v1.5.0 // indirect
+ github.com/tklauser/numcpus v0.11.0 // indirect
+ github.com/urfave/cli/v3 v3.6.1 // indirect
github.com/valyala/bytebufferpool v1.0.0 // indirect
github.com/valyala/fasttemplate v1.2.2 // indirect
github.com/xeipuuv/gojsonpointer v0.0.0-20190905194746-02993c407bfb // indirect
github.com/xeipuuv/gojsonreference v0.0.0-20180127040603-bd5ef7bd5415 // indirect
- github.com/xrash/smetrics v0.0.0-20240521201337-686a1a2994c1 // indirect
github.com/yusufpapurcu/wmi v1.2.4 // indirect
github.com/zeebo/blake3 v0.2.4 // indirect
go.uber.org/multierr v1.11.0 // indirect
go.uber.org/zap/exp v0.3.0 // indirect
- golang.org/x/net v0.41.0 // indirect
- golang.org/x/sync v0.15.0 // indirect
- golang.org/x/sys v0.33.0 // indirect
- golang.org/x/text v0.26.0 // indirect
- golang.org/x/time v0.12.0 // indirect
- golang.org/x/tools v0.34.0 // indirect
- google.golang.org/protobuf v1.36.6 // indirect
+ go.yaml.in/yaml/v2 v2.4.3 // indirect
+ go.yaml.in/yaml/v3 v3.0.4 // indirect
+ golang.org/x/net v0.47.0 // indirect
+ golang.org/x/sync v0.18.0 // indirect
+ golang.org/x/sys v0.38.0 // indirect
+ golang.org/x/text v0.31.0 // indirect
+ golang.org/x/time v0.14.0 // indirect
+ golang.org/x/tools v0.39.0 // indirect
+ google.golang.org/protobuf v1.36.10 // indirect
gopkg.in/yaml.v2 v2.4.0 // indirect
gopkg.in/yaml.v3 v3.0.1 // indirect
)
diff --git a/go.sum b/go.sum
index a213112d..0dccd745 100644
--- a/go.sum
+++ b/go.sum
@@ -1,13 +1,13 @@
cloud.google.com/go v0.34.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
-github.com/99designs/gqlgen v0.17.76 h1:YsJBcfACWmXWU2t1yCjoGdOmqcTfOFpjbLAE443fmYI=
-github.com/99designs/gqlgen v0.17.76/go.mod h1:miiU+PkAnTIDKMQ1BseUOIVeQHoiwYDZGCswoxl7xec=
+github.com/99designs/gqlgen v0.17.84 h1:iVMdiStgUVx/BFkMb0J5GAXlqfqtQ7bqMCYK6v52kQ0=
+github.com/99designs/gqlgen v0.17.84/go.mod h1:qjoUqzTeiejdo+bwUg8unqSpeYG42XrcrQboGIezmFA=
github.com/DataDog/datadog-go v3.2.0+incompatible/go.mod h1:LButxg5PwREeZtORoXG3tL4fMGNddJ+vMq1mwgfaqoQ=
github.com/KyleBanks/depth v1.2.1 h1:5h8fQADFrWtarTdtDudMmGsC7GPbOAu6RVB3ffsVFHc=
github.com/KyleBanks/depth v1.2.1/go.mod h1:jzSb9d0L43HxTQfT+oSA1EEp2q+ne2uh6XgeJcm8brE=
github.com/Masterminds/semver/v3 v3.4.0 h1:Zog+i5UMtVoCU8oKka5P7i9q9HgrJeGzI9SA1Xbatp0=
github.com/Masterminds/semver/v3 v3.4.0/go.mod h1:4V+yj/TJE1HU9XfppCwVMZq3I84lprf4nC11bSS5beM=
-github.com/PuerkitoBio/goquery v1.10.3 h1:pFYcNSqHxBD06Fpj/KsbStFRsgRATgnf3LeXiUkhzPo=
-github.com/PuerkitoBio/goquery v1.10.3/go.mod h1:tMUX0zDMHXYlAQk6p35XxQMqMweEKB7iK7iLNd4RH4Y=
+github.com/PuerkitoBio/goquery v1.11.0 h1:jZ7pwMQXIITcUXNH83LLk+txlaEy6NVOfTuP43xxfqw=
+github.com/PuerkitoBio/goquery v1.11.0/go.mod h1:wQHgxUOU3JGuj3oD/QFfxUdlzW6xPHfqyHre6VMY4DQ=
github.com/adhocore/gronx v1.19.6 h1:5KNVcoR9ACgL9HhEqCm5QXsab/gI4QDIybTAWcXDKDc=
github.com/adhocore/gronx v1.19.6/go.mod h1:7oUY1WAU8rEJWmAxXR2DN0JaO4gi9khSgKjiRypqteg=
github.com/agnivade/levenshtein v1.2.1 h1:EHBY3UOn1gwdy/VbFwgo4cxecRznFk7fKWN1KOX7eoM=
@@ -37,8 +37,8 @@ github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM=
github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw=
github.com/boltdb/bolt v1.3.1 h1:JQmyP4ZBrce+ZQu0dY660FMfatumYDLun9hBCUVIkF4=
github.com/boltdb/bolt v1.3.1/go.mod h1:clJnj/oiGkjum5o1McbSZDSLxVThjynRyGBgiAx27Ps=
-github.com/caddyserver/certmagic v0.23.0 h1:CfpZ/50jMfG4+1J/u2LV6piJq4HOfO6ppOnOf7DkFEU=
-github.com/caddyserver/certmagic v0.23.0/go.mod h1:9mEZIWqqWoI+Gf+4Trh04MOVPD0tGSxtqsxg87hAIH4=
+github.com/caddyserver/certmagic v0.25.0 h1:VMleO/XA48gEWes5l+Fh6tRWo9bHkhwAEhx63i+F5ic=
+github.com/caddyserver/certmagic v0.25.0/go.mod h1:m9yB7Mud24OQbPHOiipAoyKPn9pKHhpSJxXR1jydBxA=
github.com/caddyserver/zerossl v0.1.3 h1:onS+pxp3M8HnHpN5MMbOMyNjmTheJyWRaZYwn+YTAyA=
github.com/caddyserver/zerossl v0.1.3/go.mod h1:CxA0acn7oEGO6//4rtrRjYgEoa4MFw/XofZnrYwGqG4=
github.com/cespare/xxhash/v2 v2.1.1/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
@@ -46,12 +46,8 @@ github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UF
github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
github.com/circonus-labs/circonus-gometrics v2.3.1+incompatible/go.mod h1:nmEj6Dob7S7YxXgwXpfOuvO54S+tGdZdw9fuRZt25Ag=
github.com/circonus-labs/circonusllhist v0.1.3/go.mod h1:kMXHVDlOchFAehlya5ePtbp5jckzBHf4XRpQvBOLI+I=
-github.com/cpuguy83/go-md2man/v2 v2.0.7 h1:zbFlGlXEAKlwXpmvle3d8Oe3YnkKIK4xSRTd3sHPnBo=
-github.com/cpuguy83/go-md2man/v2 v2.0.7/go.mod h1:oOW0eioCTA6cOiMLiUPZOpcVxMig6NIQQ7OS05n1F4g=
github.com/datarhei/gosrt v0.9.0 h1:FW8A+F8tBiv7eIa57EBHjtTJKFX+OjvLogF/tFXoOiA=
github.com/datarhei/gosrt v0.9.0/go.mod h1:rqTRK8sDZdN2YBgp1EEICSV4297mQk0oglwvpXhaWdk=
-github.com/datarhei/joy4 v0.0.0-20250818192407-7b9c68697ad4 h1:coBWFnjU8DZpG4RHCCz2fQcdfuEVUfyeL7RHVXVflnM=
-github.com/datarhei/joy4 v0.0.0-20250818192407-7b9c68697ad4/go.mod h1:Jcw/6jZDQQmPx8A7INEkXmuEF7E9jjBbSTfVSLwmiQw=
github.com/datarhei/joy4 v0.0.0-20250818192923-6dc77ee81363 h1:tHC7HzHIgs4I+YTCs0IkIJjP1lmygtSBNr73DiNrY3I=
github.com/datarhei/joy4 v0.0.0-20250818192923-6dc77ee81363/go.mod h1:Jcw/6jZDQQmPx8A7INEkXmuEF7E9jjBbSTfVSLwmiQw=
github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
@@ -71,8 +67,8 @@ github.com/fatih/color v1.18.0 h1:S8gINlzdQ840/4pfAwic/ZE0djQEH3wM94VfqLTZcOM=
github.com/fatih/color v1.18.0/go.mod h1:4FelSpRwEGDpQ12mAdzqdOukCy4u8WUtOY6lkT/6HfU=
github.com/fujiwara/shapeio v1.0.0 h1:xG5D9oNqCSUUbryZ/jQV3cqe1v2suEjwPIcEg1gKM8M=
github.com/fujiwara/shapeio v1.0.0/go.mod h1:LmEmu6L/8jetyj1oewewFb7bZCNRwE7wLCUNzDLaLVA=
-github.com/gabriel-vasile/mimetype v1.4.9 h1:5k+WDwEsD9eTLL8Tz3L0VnmVh9QxGjRmjBvAG7U/oYY=
-github.com/gabriel-vasile/mimetype v1.4.9/go.mod h1:WnSQhFKJuBlRyLiKohA/2DtIlPFAbguNaG7QCHcyGok=
+github.com/gabriel-vasile/mimetype v1.4.11 h1:AQvxbp830wPhHTqc1u7nzoLT+ZFxGY7emj5DR5DYFik=
+github.com/gabriel-vasile/mimetype v1.4.11/go.mod h1:d+9Oxyo1wTzWdyVUPMmXFvp4F9tea18J8ufA774AB3s=
github.com/ghodss/yaml v1.0.0 h1:wQHKEahhL6wmXdzwWG11gIVCkOv05bNOh+Rxn0yngAk=
github.com/ghodss/yaml v1.0.0/go.mod h1:4dBDuWmgqj2HViK6kFavaiC9ZROes6MMH2rRYeMEF04=
github.com/go-ini/ini v1.67.0 h1:z6ZrTEZqSWOTyH2FlglNbNgARyHG8oLW9gMELqKr06A=
@@ -86,32 +82,51 @@ github.com/go-logfmt/logfmt v0.5.0/go.mod h1:wCYkCAKZfumFQihp8CzCvQ3paCTfi41vtzG
github.com/go-ole/go-ole v1.2.6/go.mod h1:pprOEPIfldk/42T2oK7lQ4v4JSDwmV0As9GaiUsvbm0=
github.com/go-ole/go-ole v1.3.0 h1:Dt6ye7+vXGIKZ7Xtk4s6/xVdGDQynvom7xCFEdWr6uE=
github.com/go-ole/go-ole v1.3.0/go.mod h1:5LS6F96DhAwUc7C+1HLexzMXY1xGRSryjyPPKW6zv78=
-github.com/go-openapi/jsonpointer v0.21.1 h1:whnzv/pNXtK2FbX/W9yJfRmE2gsmkfahjMKB0fZvcic=
-github.com/go-openapi/jsonpointer v0.21.1/go.mod h1:50I1STOfbY1ycR8jGz8DaMeLCdXiI6aDteEdRNNzpdk=
-github.com/go-openapi/jsonreference v0.21.0 h1:Rs+Y7hSXT83Jacb7kFyjn4ijOuVGSvOdF2+tg1TRrwQ=
-github.com/go-openapi/jsonreference v0.21.0/go.mod h1:LmZmgsrTkVg9LG4EaHeY8cBDslNPMo06cago5JNLkm4=
-github.com/go-openapi/spec v0.21.0 h1:LTVzPc3p/RzRnkQqLRndbAzjY0d0BCL72A6j3CdL9ZY=
-github.com/go-openapi/spec v0.21.0/go.mod h1:78u6VdPw81XU44qEWGhtr982gJ5BWg2c0I5XwVMotYk=
-github.com/go-openapi/swag v0.23.1 h1:lpsStH0n2ittzTnbaSloVZLuB5+fvSY/+hnagBjSNZU=
-github.com/go-openapi/swag v0.23.1/go.mod h1:STZs8TbRvEQQKUA+JZNAm3EWlgaOBGpyFDqQnDHMef0=
+github.com/go-openapi/jsonpointer v0.22.3 h1:dKMwfV4fmt6Ah90zloTbUKWMD+0he+12XYAsPotrkn8=
+github.com/go-openapi/jsonpointer v0.22.3/go.mod h1:0lBbqeRsQ5lIanv3LHZBrmRGHLHcQoOXQnf88fHlGWo=
+github.com/go-openapi/jsonreference v0.21.3 h1:96Dn+MRPa0nYAR8DR1E03SblB5FJvh7W6krPI0Z7qMc=
+github.com/go-openapi/jsonreference v0.21.3/go.mod h1:RqkUP0MrLf37HqxZxrIAtTWW4ZJIK1VzduhXYBEeGc4=
+github.com/go-openapi/spec v0.22.1 h1:beZMa5AVQzRspNjvhe5aG1/XyBSMeX1eEOs7dMoXh/k=
+github.com/go-openapi/spec v0.22.1/go.mod h1:c7aeIQT175dVowfp7FeCvXXnjN/MrpaONStibD2WtDA=
+github.com/go-openapi/swag v0.19.15 h1:D2NRCBzS9/pEY3gP9Nl8aDqGUcPFrwG2p+CNFrLyrCM=
+github.com/go-openapi/swag/conv v0.25.4 h1:/Dd7p0LZXczgUcC/Ikm1+YqVzkEeCc9LnOWjfkpkfe4=
+github.com/go-openapi/swag/conv v0.25.4/go.mod h1:3LXfie/lwoAv0NHoEuY1hjoFAYkvlqI/Bn5EQDD3PPU=
+github.com/go-openapi/swag/jsonname v0.25.4 h1:bZH0+MsS03MbnwBXYhuTttMOqk+5KcQ9869Vye1bNHI=
+github.com/go-openapi/swag/jsonname v0.25.4/go.mod h1:GPVEk9CWVhNvWhZgrnvRA6utbAltopbKwDu8mXNUMag=
+github.com/go-openapi/swag/jsonutils v0.25.4 h1:VSchfbGhD4UTf4vCdR2F4TLBdLwHyUDTd1/q4i+jGZA=
+github.com/go-openapi/swag/jsonutils v0.25.4/go.mod h1:7OYGXpvVFPn4PpaSdPHJBtF0iGnbEaTk8AvBkoWnaAY=
+github.com/go-openapi/swag/jsonutils/fixtures_test v0.25.4 h1:IACsSvBhiNJwlDix7wq39SS2Fh7lUOCJRmx/4SN4sVo=
+github.com/go-openapi/swag/jsonutils/fixtures_test v0.25.4/go.mod h1:Mt0Ost9l3cUzVv4OEZG+WSeoHwjWLnarzMePNDAOBiM=
+github.com/go-openapi/swag/loading v0.25.4 h1:jN4MvLj0X6yhCDduRsxDDw1aHe+ZWoLjW+9ZQWIKn2s=
+github.com/go-openapi/swag/loading v0.25.4/go.mod h1:rpUM1ZiyEP9+mNLIQUdMiD7dCETXvkkC30z53i+ftTE=
+github.com/go-openapi/swag/stringutils v0.25.4 h1:O6dU1Rd8bej4HPA3/CLPciNBBDwZj9HiEpdVsb8B5A8=
+github.com/go-openapi/swag/stringutils v0.25.4/go.mod h1:GTsRvhJW5xM5gkgiFe0fV3PUlFm0dr8vki6/VSRaZK0=
+github.com/go-openapi/swag/typeutils v0.25.4 h1:1/fbZOUN472NTc39zpa+YGHn3jzHWhv42wAJSN91wRw=
+github.com/go-openapi/swag/typeutils v0.25.4/go.mod h1:Ou7g//Wx8tTLS9vG0UmzfCsjZjKhpjxayRKTHXf2pTE=
+github.com/go-openapi/swag/yamlutils v0.25.4 h1:6jdaeSItEUb7ioS9lFoCZ65Cne1/RZtPBZ9A56h92Sw=
+github.com/go-openapi/swag/yamlutils v0.25.4/go.mod h1:MNzq1ulQu+yd8Kl7wPOut/YHAAU/H6hL91fF+E2RFwc=
+github.com/go-openapi/testify/enable/yaml/v2 v2.0.2 h1:0+Y41Pz1NkbTHz8NngxTuAXxEodtNSI1WG1c/m5Akw4=
+github.com/go-openapi/testify/enable/yaml/v2 v2.0.2/go.mod h1:kme83333GCtJQHXQ8UKX3IBZu6z8T5Dvy5+CW3NLUUg=
+github.com/go-openapi/testify/v2 v2.0.2 h1:X999g3jeLcoY8qctY/c/Z8iBHTbwLz7R2WXd6Ub6wls=
+github.com/go-openapi/testify/v2 v2.0.2/go.mod h1:HCPmvFFnheKK2BuwSA0TbbdxJ3I16pjwMkYkP4Ywn54=
github.com/go-playground/assert/v2 v2.2.0 h1:JvknZsQTYeFEAhQwI4qEt9cyV5ONwRHC+lYKSsYSR8s=
github.com/go-playground/assert/v2 v2.2.0/go.mod h1:VDjEfimB/XKnb+ZQfWdccd7VUvScMdVu0Titje2rxJ4=
github.com/go-playground/locales v0.14.1 h1:EWaQ/wswjilfKLTECiXz7Rh+3BjFhfDFKv/oXslEjJA=
github.com/go-playground/locales v0.14.1/go.mod h1:hxrqLVvrK65+Rwrd5Fc6F2O76J/NuW9t0sjnWqG1slY=
github.com/go-playground/universal-translator v0.18.1 h1:Bcnm0ZwsGyWbCzImXv+pAJnYK9S473LQFuzCbDbfSFY=
github.com/go-playground/universal-translator v0.18.1/go.mod h1:xekY+UJKNuX9WP91TpwSH2VMlDf28Uj24BCp08ZFTUY=
-github.com/go-playground/validator/v10 v10.27.0 h1:w8+XrWVMhGkxOaaowyKH35gFydVHOvC0/uWoy2Fzwn4=
-github.com/go-playground/validator/v10 v10.27.0/go.mod h1:I5QpIEbmr8On7W0TktmJAumgzX4CA1XNl4ZmDuVHKKo=
+github.com/go-playground/validator/v10 v10.28.0 h1:Q7ibns33JjyW48gHkuFT91qX48KG0ktULL6FgHdG688=
+github.com/go-playground/validator/v10 v10.28.0/go.mod h1:GoI6I1SjPBh9p7ykNE/yj3fFYbyDOpwMn5KXd+m2hUU=
github.com/go-stack/stack v1.8.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY=
-github.com/go-viper/mapstructure/v2 v2.3.0 h1:27XbWsHIqhbdR5TIC911OfYvgSaW93HM+dX7970Q7jk=
-github.com/go-viper/mapstructure/v2 v2.3.0/go.mod h1:oJDH3BJKyqBA2TXFhDsKDGDTlndYOZ6rGS0BRZIxGhM=
+github.com/go-viper/mapstructure/v2 v2.4.0 h1:EBsztssimR/CONLSZZ04E8qAkxNYq4Qp9LvH92wZUgs=
+github.com/go-viper/mapstructure/v2 v2.4.0/go.mod h1:oJDH3BJKyqBA2TXFhDsKDGDTlndYOZ6rGS0BRZIxGhM=
github.com/gobwas/glob v0.2.3 h1:A4xDbljILXROh+kObIiy5kIaPYD8e96x1tgBhUI5J+Y=
github.com/gobwas/glob v0.2.3/go.mod h1:d3Ez4x06l9bZtSvzIay5+Yzi0fmZzPgnTbPcKjJAkT8=
-github.com/goccy/go-json v0.10.5 h1:Fq85nIqj+gXn/S5ahsiTlK3TmC85qgirsdTP/+DeaC4=
-github.com/goccy/go-json v0.10.5/go.mod h1:oq7eo15ShAhp70Anwd5lgX2pLfOS3QCiwU/PULtXL6M=
+github.com/goccy/go-yaml v1.18.0 h1:8W7wMFS12Pcas7KU+VVkaiCng+kG8QiFeFwzFb+rwuw=
+github.com/goccy/go-yaml v1.18.0/go.mod h1:XBurs7gK8ATbW4ZPGKgcbrY1Br56PdM69F7LkFRi1kA=
github.com/gogo/protobuf v1.1.1/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ=
-github.com/golang-jwt/jwt/v5 v5.2.2 h1:Rl4B7itRWVtYIHFrSNd7vhTiz9UpLdi6gZhZ3wEeDy8=
-github.com/golang-jwt/jwt/v5 v5.2.2/go.mod h1:pqrtFR0X4osieyHYxtmOUWsAWrfe1Q5UVIyoH402zdk=
+github.com/golang-jwt/jwt/v5 v5.3.0 h1:pv4AsKCKKZuqlgs5sUmn4x8UlGa0kEVt/puTpKx9vvo=
+github.com/golang-jwt/jwt/v5 v5.3.0/go.mod h1:fxCRLWMO43lRc8nhHWY6LGqRcf+1gQWArsqaEUEa5bE=
github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
github.com/golang/protobuf v1.3.1/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
github.com/golang/protobuf v1.3.2/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
@@ -146,8 +161,8 @@ github.com/hashicorp/go-metrics v0.5.4 h1:8mmPiIJkTPPEbAiV97IxdAGNdRdaWwVap1BU6e
github.com/hashicorp/go-metrics v0.5.4/go.mod h1:CG5yz4NZ/AI/aQt9Ucm/vdBnbh7fvmv4lxZ350i+QQI=
github.com/hashicorp/go-msgpack v0.5.5 h1:i9R9JSrqIz0QVLz3sz+i3YJdT7TTSLcfLLzJi9aZTuI=
github.com/hashicorp/go-msgpack v0.5.5/go.mod h1:ahLV/dePpqEmjfWmKiqvPkv/twdG7iPBM1vqhUKIvfM=
-github.com/hashicorp/go-msgpack/v2 v2.1.3 h1:cB1w4Zrk0O3jQBTcFMKqYQWRFfsSQ/TYKNyUUVyCP2c=
-github.com/hashicorp/go-msgpack/v2 v2.1.3/go.mod h1:SjlwKKFnwBXvxD/I1bEcfJIBbEJ+MCUn39TxymNR5ZU=
+github.com/hashicorp/go-msgpack/v2 v2.1.5 h1:Ue879bPnutj/hXfmUk6s/jtIK90XxgiUIcXRl656T44=
+github.com/hashicorp/go-msgpack/v2 v2.1.5/go.mod h1:bjCsRXpZ7NsJdk45PoCQnzRGDaK8TKm5ZnDI/9y3J4M=
github.com/hashicorp/go-retryablehttp v0.5.3/go.mod h1:9B5zBasrRhHXnJnui7y6sL7es7NDiJgTc6Er0maI1Xs=
github.com/hashicorp/go-uuid v1.0.0 h1:RS8zrF7PhGwyNPOtxSClXXj9HA8feRnJzgnI1RJCSnM=
github.com/hashicorp/go-uuid v1.0.0/go.mod h1:6SBZvOh/SIDV7/2o3Jml5SYk/TvGqwFJ/bN7x4byOro=
@@ -169,8 +184,6 @@ github.com/invopop/jsonschema v0.4.0 h1:Yuy/unfgCnfV5Wl7H0HgFufp/rlurqPOOuacqyBy
github.com/invopop/jsonschema v0.4.0/go.mod h1:O9uiLokuu0+MGFlyiaqtWxwqJm41/+8Nj0lD7A36YH0=
github.com/joho/godotenv v1.5.1 h1:7eLL/+HRGLY0ldzfGMeQkb7vMd0as4CfYvUVzLqw0N0=
github.com/joho/godotenv v1.5.1/go.mod h1:f4LDr5Voq0i2e/R5DDNOoa2zzDfwtkZa6DnEwAbqwq4=
-github.com/josharian/intern v1.0.0 h1:vlS4z54oSdjm0bgjRigI+G1HpF+tI+9rE5LLzOg8HmY=
-github.com/josharian/intern v1.0.0/go.mod h1:5DoeVV0s6jJacbCEi61lwdGj/aVlrQvzHFFd8Hwg//Y=
github.com/jpillora/backoff v1.0.0/go.mod h1:J/6gKK9jxlEcS3zixgDgUAsiuZ7yrSoa/FX5e0EB2j4=
github.com/json-iterator/go v1.1.6/go.mod h1:+SdeFBvtyEkXs7REEP0seUULqWtbJapLOCVDaaPEHmU=
github.com/json-iterator/go v1.1.9/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4=
@@ -178,11 +191,13 @@ github.com/json-iterator/go v1.1.10/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/
github.com/json-iterator/go v1.1.11/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4=
github.com/julienschmidt/httprouter v1.2.0/go.mod h1:SYymIcj16QtmaHHD7aYtjjsJG7VTCxuUUipMqKk8s4w=
github.com/julienschmidt/httprouter v1.3.0/go.mod h1:JR6WtHb+2LUe8TCKY3cZOxFyyO8IZAc4RVcycCCAKdM=
-github.com/klauspost/compress v1.18.0 h1:c/Cqfb0r+Yi+JtIEq73FWXVkRonBlf0CRNYc8Zttxdo=
-github.com/klauspost/compress v1.18.0/go.mod h1:2Pp+KzxcywXVXMr50+X0Q/Lsb43OQHYWRCY2AiWywWQ=
+github.com/klauspost/compress v1.18.2 h1:iiPHWW0YrcFgpBYhsA6D1+fqHssJscY/Tm/y2Uqnapk=
+github.com/klauspost/compress v1.18.2/go.mod h1:R0h/fSBs8DE4ENlcrlib3PsXS61voFxhIs2DeRhCvJ4=
github.com/klauspost/cpuid/v2 v2.0.1/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa0213Md/qVLRg=
-github.com/klauspost/cpuid/v2 v2.2.11 h1:0OwqZRYI2rFrjS4kvkDnqJkKHdHaRnCm68/DY4OxRzU=
-github.com/klauspost/cpuid/v2 v2.2.11/go.mod h1:hqwkgyIinND0mEev00jJYCxPNVRVXFQeu1XKlok6oO0=
+github.com/klauspost/cpuid/v2 v2.3.0 h1:S4CRMLnYUhGeDFDqkGriYKdfoFlDnMtqTiI/sFzhA9Y=
+github.com/klauspost/cpuid/v2 v2.3.0/go.mod h1:hqwkgyIinND0mEev00jJYCxPNVRVXFQeu1XKlok6oO0=
+github.com/klauspost/crc32 v1.3.0 h1:sSmTt3gUt81RP655XGZPElI0PelVTZ6YwCRnPSupoFM=
+github.com/klauspost/crc32 v1.3.0/go.mod h1:D7kQaZhnkX/Y0tstFGf8VUzv2UofNGqCjnC3zdHB0Hw=
github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
github.com/konsorten/go-windows-terminal-sequences v1.0.3/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
github.com/kr/logfmt v0.0.0-20140226030751-b84e30acd515/go.mod h1:+0opPa2QZZtGFBFZlji/RkVcI2GknAs/DXo4wKdlNEc=
@@ -203,16 +218,14 @@ github.com/leodido/go-urn v1.4.0 h1:WT9HwE9SGECu3lg4d/dIA+jxlljEa1/ffXKmRjqdmIQ=
github.com/leodido/go-urn v1.4.0/go.mod h1:bvxc+MVxLKB4z00jd1z+Dvzr47oO32F/QSNjSBOlFxI=
github.com/lestrrat-go/envload v0.0.0-20180220234015-a3eb8ddeffcc h1:RKf14vYWi2ttpEmkA4aQ3j4u9dStX2t4M8UM6qqNsG8=
github.com/lestrrat-go/envload v0.0.0-20180220234015-a3eb8ddeffcc/go.mod h1:kopuH9ugFRkIXf3YoqHKyrJ9YfUFsckUU9S7B+XP+is=
-github.com/lestrrat-go/strftime v1.1.0 h1:gMESpZy44/4pXLO/m+sL0yBd1W6LjgjrrD4a68Gapyg=
-github.com/lestrrat-go/strftime v1.1.0/go.mod h1:uzeIB52CeUJenCo1syghlugshMysrqUT51HlxphXVeI=
-github.com/libdns/libdns v1.1.0 h1:9ze/tWvt7Df6sbhOJRB8jT33GHEHpEQXdtkE3hPthbU=
-github.com/libdns/libdns v1.1.0/go.mod h1:4Bj9+5CQiNMVGf87wjX4CY3HQJypUHRuLvlsfsZqLWQ=
+github.com/lestrrat-go/strftime v1.1.1 h1:zgf8QCsgj27GlKBy3SU9/8MMgegZ8UCzlCyHYrUF0QU=
+github.com/lestrrat-go/strftime v1.1.1/go.mod h1:YDrzHJAODYQ+xxvrn5SG01uFIQAeDTzpxNVppCz7Nmw=
+github.com/libdns/libdns v1.1.1 h1:wPrHrXILoSHKWJKGd0EiAVmiJbFShguILTg9leS/P/U=
+github.com/libdns/libdns v1.1.1/go.mod h1:4Bj9+5CQiNMVGf87wjX4CY3HQJypUHRuLvlsfsZqLWQ=
github.com/lithammer/shortuuid/v4 v4.2.0 h1:LMFOzVB3996a7b8aBuEXxqOBflbfPQAiVzkIcHO0h8c=
github.com/lithammer/shortuuid/v4 v4.2.0/go.mod h1:D5noHZ2oFw/YaKCfGy0YxyE7M0wMbezmMjPdhyEFe6Y=
-github.com/lufia/plan9stats v0.0.0-20250317134145-8bc96cf8fc35 h1:PpXWgLPs+Fqr325bN2FD2ISlRRztXibcX6e8f5FR5Dc=
-github.com/lufia/plan9stats v0.0.0-20250317134145-8bc96cf8fc35/go.mod h1:autxFIvghDt3jPTLoqZ9OZ7s9qTGNAWmYCjVFWPX/zg=
-github.com/mailru/easyjson v0.9.0 h1:PrnmzHw7262yW8sTBwxi1PdJA3Iw/EKBa8psRf7d9a4=
-github.com/mailru/easyjson v0.9.0/go.mod h1:1+xMtQp2MRNVL/V1bOzuP3aP8VNwRW55fQUto+XFtTU=
+github.com/lufia/plan9stats v0.0.0-20251013123823-9fd1530e3ec3 h1:PwQumkgq4/acIiZhtifTV5OUqqiP82UAl0h87xj/l9k=
+github.com/lufia/plan9stats v0.0.0-20251013123823-9fd1530e3ec3/go.mod h1:autxFIvghDt3jPTLoqZ9OZ7s9qTGNAWmYCjVFWPX/zg=
github.com/mattn/go-colorable v0.1.9/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc=
github.com/mattn/go-colorable v0.1.12/go.mod h1:u5H1YNBxpqRaxsYJYSkiCWKzEfiAb1Gb520KVy5xxl4=
github.com/mattn/go-colorable v0.1.14 h1:9A9LHSqF/7dyVVX6g0U9cwm9pG3kP9gSzcuIPHPsaIE=
@@ -222,16 +235,16 @@ github.com/mattn/go-isatty v0.0.14/go.mod h1:7GGIvUiUoEMVVmxf/4nioHXj79iQHKdU27k
github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
github.com/matttproud/golang_protobuf_extensions v1.0.1/go.mod h1:D8He9yQNgCq6Z5Ld7szi9bcBfOoFv/3dc6xSMkL2PC0=
-github.com/mholt/acmez/v3 v3.1.2 h1:auob8J/0FhmdClQicvJvuDavgd5ezwLBfKuYmynhYzc=
-github.com/mholt/acmez/v3 v3.1.2/go.mod h1:L1wOU06KKvq7tswuMDwKdcHeKpFFgkppZy/y0DFxagQ=
-github.com/miekg/dns v1.1.66 h1:FeZXOS3VCVsKnEAd+wBkjMC3D2K+ww66Cq3VnCINuJE=
-github.com/miekg/dns v1.1.66/go.mod h1:jGFzBsSNbJw6z1HYut1RKBKHA9PBdxeHrZG8J+gC2WE=
-github.com/minio/crc64nvme v1.0.2 h1:6uO1UxGAD+kwqWWp7mBFsi5gAse66C4NXO8cmcVculg=
-github.com/minio/crc64nvme v1.0.2/go.mod h1:eVfm2fAzLlxMdUGc0EEBGSMmPwmXD5XiNRpnu9J3bvg=
+github.com/mholt/acmez/v3 v3.1.4 h1:DyzZe/RnAzT3rpZj/2Ii5xZpiEvvYk3cQEN/RmqxwFQ=
+github.com/mholt/acmez/v3 v3.1.4/go.mod h1:L1wOU06KKvq7tswuMDwKdcHeKpFFgkppZy/y0DFxagQ=
+github.com/miekg/dns v1.1.68 h1:jsSRkNozw7G/mnmXULynzMNIsgY2dHC8LO6U6Ij2JEA=
+github.com/miekg/dns v1.1.68/go.mod h1:fujopn7TB3Pu3JM69XaawiU0wqjpL9/8xGop5UrTPps=
+github.com/minio/crc64nvme v1.1.1 h1:8dwx/Pz49suywbO+auHCBpCtlW1OfpcLN7wYgVR6wAI=
+github.com/minio/crc64nvme v1.1.1/go.mod h1:eVfm2fAzLlxMdUGc0EEBGSMmPwmXD5XiNRpnu9J3bvg=
github.com/minio/md5-simd v1.1.2 h1:Gdi1DZK69+ZVMoNHRXJyNcxrMA4dSxoYHZSQbirFg34=
github.com/minio/md5-simd v1.1.2/go.mod h1:MzdKDxYpY2BT9XQFocsiZf/NKVtR7nkE4RoEpN+20RM=
-github.com/minio/minio-go/v7 v7.0.94 h1:1ZoksIKPyaSt64AVOyaQvhDOgVC3MfZsWM6mZXRUGtM=
-github.com/minio/minio-go/v7 v7.0.94/go.mod h1:71t2CqDt3ThzESgZUlU1rBN54mksGGlkLcFgguDnnAc=
+github.com/minio/minio-go/v7 v7.0.97 h1:lqhREPyfgHTB/ciX8k2r8k0D93WaFqxbJX36UZq5occ=
+github.com/minio/minio-go/v7 v7.0.97/go.mod h1:re5VXuo0pwEtoNLsNuSr0RrLfT/MBtohwdaSmPPSRSk=
github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
github.com/modern-go/reflect2 v0.0.0-20180701023420-4b7aa43c6742/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0=
@@ -259,8 +272,8 @@ github.com/prometheus/client_golang v1.0.0/go.mod h1:db9x61etRT2tGnBNRi70OPL5Fsn
github.com/prometheus/client_golang v1.4.0/go.mod h1:e9GMxYsXl05ICDXkRhurwBS4Q3OK1iX/F2sw+iXX5zU=
github.com/prometheus/client_golang v1.7.1/go.mod h1:PY5Wy2awLA44sXw4AOSfFBetzPP4j5+D6mVACh+pe2M=
github.com/prometheus/client_golang v1.11.1/go.mod h1:Z6t4BnS23TR94PD6BsDNk8yVqroYurpAkEiz0P2BEV0=
-github.com/prometheus/client_golang v1.22.0 h1:rb93p9lokFEsctTys46VnV1kLCDpVZ0a/Y92Vm0Zc6Q=
-github.com/prometheus/client_golang v1.22.0/go.mod h1:R7ljNsLXhuQXYZYtw6GAE9AZg8Y7vEW5scdCXrWRXC0=
+github.com/prometheus/client_golang v1.23.2 h1:Je96obch5RDVy3FDMndoUsjAhG5Edi49h0RJWRi/o0o=
+github.com/prometheus/client_golang v1.23.2/go.mod h1:Tb1a6LWHB3/SPIzCoaDXI4I8UHKeFTEQ1YCr+0Gyqmg=
github.com/prometheus/client_model v0.0.0-20180712105110-5c3871d89910/go.mod h1:MbSGuTsp3dbXC40dX6PRTWyKYBIrTGTE9sqQNg2J8bo=
github.com/prometheus/client_model v0.0.0-20190129233127-fd36f4220a90/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
github.com/prometheus/client_model v0.2.0/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
@@ -270,31 +283,29 @@ github.com/prometheus/common v0.4.1/go.mod h1:TNfzLD0ON7rHzMJeJkieUDPYmFC7Snx/y8
github.com/prometheus/common v0.9.1/go.mod h1:yhUN8i9wzaXS3w1O07YhxHEBxD+W35wd8bs7vj7HSQ4=
github.com/prometheus/common v0.10.0/go.mod h1:Tlit/dnDKsSWFlCLTWaA1cyBgKHSMdTB80sz/V91rCo=
github.com/prometheus/common v0.26.0/go.mod h1:M7rCNAaPfAosfx8veZJCuw84e35h3Cfd9VFqTh1DIvc=
-github.com/prometheus/common v0.65.0 h1:QDwzd+G1twt//Kwj/Ww6E9FQq1iVMmODnILtW1t2VzE=
-github.com/prometheus/common v0.65.0/go.mod h1:0gZns+BLRQ3V6NdaerOhMbwwRbNh9hkGINtQAsP5GS8=
+github.com/prometheus/common v0.67.4 h1:yR3NqWO1/UyO1w2PhUvXlGQs/PtFmoveVO0KZ4+Lvsc=
+github.com/prometheus/common v0.67.4/go.mod h1:gP0fq6YjjNCLssJCQp0yk4M8W6ikLURwkdd/YKtTbyI=
github.com/prometheus/procfs v0.0.0-20181005140218-185b4288413d/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk=
github.com/prometheus/procfs v0.0.2/go.mod h1:TjEm7ze935MbeOT/UhFTIMYKhuLP4wbCsTZCD3I8kEA=
github.com/prometheus/procfs v0.0.8/go.mod h1:7Qr8sr6344vo1JqZ6HhLceV9o3AJ1Ff+GxbHq6oeK9A=
github.com/prometheus/procfs v0.1.3/go.mod h1:lV6e/gmhEcM9IjHGsFOCxxuZ+z1YqCvr4OA4YeYWdaU=
github.com/prometheus/procfs v0.6.0/go.mod h1:cz+aTbrPOrUb4q7XlbU9ygM+/jj0fzG6c1xBZuNvfVA=
-github.com/prometheus/procfs v0.17.0 h1:FuLQ+05u4ZI+SS/w9+BWEM2TXiHKsUQ9TADiRH7DuK0=
-github.com/prometheus/procfs v0.17.0/go.mod h1:oPQLaDAMRbA+u8H5Pbfq+dl3VDAvHxMUOVhe0wYB2zw=
+github.com/prometheus/procfs v0.19.2 h1:zUMhqEW66Ex7OXIiDkll3tl9a1ZdilUOd/F6ZXw4Vws=
+github.com/prometheus/procfs v0.19.2/go.mod h1:M0aotyiemPhBCM0z5w87kL22CxfcH05ZpYlu+b4J7mw=
github.com/puzpuzpuz/xsync/v3 v3.5.1 h1:GJYJZwO6IdxN/IKbneznS6yPkVC+c3zyY/j19c++5Fg=
github.com/puzpuzpuz/xsync/v3 v3.5.1/go.mod h1:VjzYrABPabuM4KyBh1Ftq6u8nhwY5tBPKP9jpmh0nnA=
-github.com/rogpeppe/go-internal v1.11.0 h1:cWPaGQEPrBb5/AsnsZesgZZ9yb1OQ+GOISoDNXVBh4M=
-github.com/rogpeppe/go-internal v1.11.0/go.mod h1:ddIwULY96R17DhadqLgMfk9H9tvdUzkipdSkR5nkCZA=
+github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0tI/otEQ=
+github.com/rogpeppe/go-internal v1.14.1/go.mod h1:MaRKkUm5W0goXpeCfT7UZI6fk/L7L7so1lCWt35ZSgc=
github.com/rs/xid v1.6.0 h1:fV591PaemRlL6JfRxGDEPl69wICngIQ3shQtzfy2gxU=
github.com/rs/xid v1.6.0/go.mod h1:7XoLgs4eV+QndskICGsho+ADou8ySMSjJKDIan90Nz0=
-github.com/russross/blackfriday/v2 v2.1.0 h1:JIOH55/0cWyOuilr9/qlrm0BSXldqnqwMsf35Ld67mk=
-github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
github.com/sergi/go-diff v1.3.1 h1:xkr+Oxo4BOQKmkn/B9eMK0g5Kg/983T9DqqPHwYqD+8=
github.com/sergi/go-diff v1.3.1/go.mod h1:aMJSSKb2lpPvRNec0+w3fl7LP9IOFzdc9Pa4NFbPK1I=
github.com/shirou/gopsutil/v3 v3.24.5 h1:i0t8kL+kQTvpAYToeuiVk3TgDeKOFioZO3Ztz/iZ9pI=
github.com/shirou/gopsutil/v3 v3.24.5/go.mod h1:bsoOS1aStSs9ErQ1WWfxllSeS1K5D+U30r2NfcubMVk=
-github.com/shoenig/go-m1cpu v0.1.6 h1:nxdKQNcEB6vzgA2E2bvzKIYRuNj7XNJ4S/aRSwKzFtM=
-github.com/shoenig/go-m1cpu v0.1.6/go.mod h1:1JJMcUBvfNwpq05QDQVAnx3gUHr9IYF7GNg9SUEw2VQ=
-github.com/shoenig/test v0.6.4 h1:kVTaSd7WLz5WZ2IaoM0RSzRsUD+m8wRR+5qvntpn4LU=
-github.com/shoenig/test v0.6.4/go.mod h1:byHiCGXqrVaflBLAMq/srcZIHynQPQgeyvkvXnjqq0k=
+github.com/shoenig/go-m1cpu v0.1.7 h1:C76Yd0ObKR82W4vhfjZiCp0HxcSZ8Nqd84v+HZ0qyI0=
+github.com/shoenig/go-m1cpu v0.1.7/go.mod h1:KkDOw6m3ZJQAPHbrzkZki4hnx+pDRR1Lo+ldA56wD5w=
+github.com/shoenig/test v1.7.0 h1:eWcHtTXa6QLnBvm0jgEabMRN/uJ4DMV3M8xUGgRkZmk=
+github.com/shoenig/test v1.7.0/go.mod h1:UxJ6u/x2v/TNs/LoLxBNJRV9DiwBBKYxXSyczsBHFoI=
github.com/sirupsen/logrus v1.2.0/go.mod h1:LxeOpSwHxABJmUn/MG1IvRgCAasNZTLOkJPxbbu5VWo=
github.com/sirupsen/logrus v1.4.2/go.mod h1:tLMulIdttU9McNUspp0xgXVQah82FyeX6MwdIuYE2rE=
github.com/sirupsen/logrus v1.6.0/go.mod h1:7uNnSEd1DgxDLC74fIahvMZmmYsHGZGEOFrfsX/uA88=
@@ -307,29 +318,29 @@ github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UV
github.com/stretchr/testify v1.3.1-0.20190311161405-34c6fa2dc709/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
github.com/stretchr/testify v1.7.2/go.mod h1:R6va5+xMeoiuVRoj+gSkQ7d3FALtqAAGI1FQKckRals=
-github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=
-github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
+github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
github.com/swaggo/echo-swagger v1.4.1 h1:Yf0uPaJWp1uRtDloZALyLnvdBeoEL5Kc7DtnjzO/TUk=
github.com/swaggo/echo-swagger v1.4.1/go.mod h1:C8bSi+9yH2FLZsnhqMZLIZddpUxZdBYuNHbtaS1Hljc=
github.com/swaggo/files/v2 v2.0.2 h1:Bq4tgS/yxLB/3nwOMcul5oLEUKa877Ykgz3CJMVbQKU=
github.com/swaggo/files/v2 v2.0.2/go.mod h1:TVqetIzZsO9OhHX1Am9sRf9LdrFZqoK49N37KON/jr0=
-github.com/swaggo/swag v1.16.4 h1:clWJtd9LStiG3VeijiCfOVODP6VpHtKdQy9ELFG3s1A=
-github.com/swaggo/swag v1.16.4/go.mod h1:VBsHJRsDvfYvqoiMKnsdwhNV9LEMHgEDZcyVYX0sxPg=
-github.com/tinylib/msgp v1.3.0 h1:ULuf7GPooDaIlbyvgAxBV/FI7ynli6LZ1/nVUNu+0ww=
-github.com/tinylib/msgp v1.3.0/go.mod h1:ykjzy2wzgrlvpDCRc4LA8UXy6D8bzMSuAF3WD57Gok0=
-github.com/tklauser/go-sysconf v0.3.15 h1:VE89k0criAymJ/Os65CSn1IXaol+1wrsFHEB8Ol49K4=
-github.com/tklauser/go-sysconf v0.3.15/go.mod h1:Dmjwr6tYFIseJw7a3dRLJfsHAMXZ3nEnL/aZY+0IuI4=
-github.com/tklauser/numcpus v0.10.0 h1:18njr6LDBk1zuna922MgdjQuJFjrdppsZG60sHGfjso=
-github.com/tklauser/numcpus v0.10.0/go.mod h1:BiTKazU708GQTYF4mB+cmlpT2Is1gLk7XVuEeem8LsQ=
+github.com/swaggo/swag v1.16.6 h1:qBNcx53ZaX+M5dxVyTrgQ0PJ/ACK+NzhwcbieTt+9yI=
+github.com/swaggo/swag v1.16.6/go.mod h1:ngP2etMK5a0P3QBizic5MEwpRmluJZPHjXcMoj4Xesg=
+github.com/tinylib/msgp v1.5.0 h1:GWnqAE54wmnlFazjq2+vgr736Akg58iiHImh+kPY2pc=
+github.com/tinylib/msgp v1.5.0/go.mod h1:cvjFkb4RiC8qSBOPMGPSzSAx47nAsfhLVTCZZNuHv5o=
+github.com/tklauser/go-sysconf v0.3.16 h1:frioLaCQSsF5Cy1jgRBrzr6t502KIIwQ0MArYICU0nA=
+github.com/tklauser/go-sysconf v0.3.16/go.mod h1:/qNL9xxDhc7tx3HSRsLWNnuzbVfh3e7gh/BmM179nYI=
+github.com/tklauser/numcpus v0.11.0 h1:nSTwhKH5e1dMNsCdVBukSZrURJRoHbSEQjdEbY+9RXw=
+github.com/tklauser/numcpus v0.11.0/go.mod h1:z+LwcLq54uWZTX0u/bGobaV34u6V7KNlTZejzM6/3MQ=
github.com/tv42/httpunix v0.0.0-20150427012821-b75d8614f926/go.mod h1:9ESjWnEqriFuLhtthL60Sar/7RFoluCcXsuvEwTV5KM=
-github.com/urfave/cli/v2 v2.27.7 h1:bH59vdhbjLv3LAvIu6gd0usJHgoTTPhCFib8qqOwXYU=
-github.com/urfave/cli/v2 v2.27.7/go.mod h1:CyNAG/xg+iAOg0N4MPGZqVmv2rCoP267496AOXUZjA4=
+github.com/urfave/cli/v3 v3.6.1 h1:j8Qq8NyUawj/7rTYdBGrxcH7A/j7/G8Q5LhWEW4G3Mo=
+github.com/urfave/cli/v3 v3.6.1/go.mod h1:ysVLtOEmg2tOy6PknnYVhDoouyC/6N42TMeoMzskhso=
github.com/valyala/bytebufferpool v1.0.0 h1:GqA5TC/0021Y/b9FG4Oi9Mr3q7XYx6KllzawFIhcdPw=
github.com/valyala/bytebufferpool v1.0.0/go.mod h1:6bBcMArwyJ5K/AmCkWv1jt77kVWyCJ6HpOuEn7z0Csc=
github.com/valyala/fasttemplate v1.2.2 h1:lxLXG0uE3Qnshl9QyaK6XJxMXlQZELvChBOCmQD0Loo=
github.com/valyala/fasttemplate v1.2.2/go.mod h1:KHLXt3tVN2HBp8eijSv/kGJopbvo7S+qRAEEKiv+SiQ=
-github.com/vektah/gqlparser/v2 v2.5.30 h1:EqLwGAFLIzt1wpx1IPpY67DwUujF1OfzgEyDsLrN6kE=
-github.com/vektah/gqlparser/v2 v2.5.30/go.mod h1:D1/VCZtV3LPnQrcPBeR/q5jkSQIPti0uYCP/RI0gIeo=
+github.com/vektah/gqlparser/v2 v2.5.31 h1:YhWGA1mfTjID7qJhd1+Vxhpk5HTgydrGU9IgkWBTJ7k=
+github.com/vektah/gqlparser/v2 v2.5.31/go.mod h1:c1I28gSOVNzlfc4WuDlqU7voQnsqI6OG2amkBAFmgts=
github.com/xeipuuv/gojsonpointer v0.0.0-20180127040702-4e3ac2762d5f/go.mod h1:N2zxlSyiKSe5eX1tZViRH5QA0qijqEDrYZiPEAiq3wU=
github.com/xeipuuv/gojsonpointer v0.0.0-20190905194746-02993c407bfb h1:zGWFAtiMcyryUHoUjUJX0/lt1H2+i2Ka2n+D3DImSNo=
github.com/xeipuuv/gojsonpointer v0.0.0-20190905194746-02993c407bfb/go.mod h1:N2zxlSyiKSe5eX1tZViRH5QA0qijqEDrYZiPEAiq3wU=
@@ -337,8 +348,6 @@ github.com/xeipuuv/gojsonreference v0.0.0-20180127040603-bd5ef7bd5415 h1:EzJWgHo
github.com/xeipuuv/gojsonreference v0.0.0-20180127040603-bd5ef7bd5415/go.mod h1:GwrjFmJcFw6At/Gs6z4yjiIwzuJ1/+UwLxMQDVQXShQ=
github.com/xeipuuv/gojsonschema v1.2.0 h1:LhYJRs+L4fBtjZUfuSZIKGeVu0QRy8e5Xi7D17UxZ74=
github.com/xeipuuv/gojsonschema v1.2.0/go.mod h1:anYRn/JVcOK2ZgGU+IjEV4nwlhoK5sQluxsYJ78Id3Y=
-github.com/xrash/smetrics v0.0.0-20240521201337-686a1a2994c1 h1:gEOO8jv9F4OT7lGCjxCBTO/36wtF6j2nSip77qHd4x4=
-github.com/xrash/smetrics v0.0.0-20240521201337-686a1a2994c1/go.mod h1:Ohn+xnUBiLI6FVj/9LpzZWtj1/D6lUovWYBkxHVV3aM=
github.com/xyproto/randomstring v1.0.5 h1:YtlWPoRdgMu3NZtP45drfy1GKoojuR7hmRcnhZqKjWU=
github.com/xyproto/randomstring v1.0.5/go.mod h1:rgmS5DeNXLivK7YprL0pY+lTuhNQW3iGxZ18UQApw/E=
github.com/yusufpapurcu/wmi v1.2.4 h1:zFUKzehAFReQwLys1b/iSMl+JQGSCSjtVqQn9bBrPo0=
@@ -349,40 +358,44 @@ github.com/zeebo/blake3 v0.2.4 h1:KYQPkhpRtcqh0ssGYcKLG1JYvddkEA8QwCM/yBqhaZI=
github.com/zeebo/blake3 v0.2.4/go.mod h1:7eeQ6d2iXWRGF6npfaxl2CU+xy2Fjo2gxeyZGCRUjcE=
github.com/zeebo/pcg v1.0.1 h1:lyqfGeWiv4ahac6ttHs+I5hwtH/+1mrhlCtVNQM2kHo=
github.com/zeebo/pcg v1.0.1/go.mod h1:09F0S9iiKrwn9rlI5yjLkmrug154/YRW6KnnXVDM/l4=
-go.etcd.io/bbolt v1.4.2 h1:IrUHp260R8c+zYx/Tm8QZr04CX+qWS5PGfPdevhdm1I=
-go.etcd.io/bbolt v1.4.2/go.mod h1:Is8rSHO/b4f3XigBC0lL0+4FwAQv3HXEEIgFMuKHceM=
+go.etcd.io/bbolt v1.4.3 h1:dEadXpI6G79deX5prL3QRNP6JB8UxVkqo4UPnHaNXJo=
+go.etcd.io/bbolt v1.4.3/go.mod h1:tKQlpPaYCVFctUIgFKFnAlvbmB3tpy1vkTnDWohtc0E=
go.uber.org/automaxprocs v1.6.0 h1:O3y2/QNTOdbF+e/dpXNNW7Rx2hZ4sTIPyybbxyNqTUs=
go.uber.org/automaxprocs v1.6.0/go.mod h1:ifeIMSnPZuznNm6jmdzmU3/bfk01Fe2fotchwEFJ8r8=
go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto=
go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE=
go.uber.org/multierr v1.11.0 h1:blXXJkSxSSfBVBlC76pxqeO+LN3aDfLQo+309xJstO0=
go.uber.org/multierr v1.11.0/go.mod h1:20+QtiLqy0Nd6FdQB9TLXag12DsQkrbs3htMFfDN80Y=
-go.uber.org/zap v1.27.0 h1:aJMhYGrd5QSmlpLMr2MftRKl7t8J8PTZPA732ud/XR8=
-go.uber.org/zap v1.27.0/go.mod h1:GB2qFLM7cTU87MWRP2mPIjqfIDnGu+VIO4V/SdhGo2E=
+go.uber.org/zap v1.27.1 h1:08RqriUEv8+ArZRYSTXy1LeBScaMpVSTBhCeaZYfMYc=
+go.uber.org/zap v1.27.1/go.mod h1:GB2qFLM7cTU87MWRP2mPIjqfIDnGu+VIO4V/SdhGo2E=
go.uber.org/zap/exp v0.3.0 h1:6JYzdifzYkGmTdRR59oYH+Ng7k49H9qVpWwNSsGJj3U=
go.uber.org/zap/exp v0.3.0/go.mod h1:5I384qq7XGxYyByIhHm6jg5CHkGY0nsTfbDLgDDlgJQ=
+go.yaml.in/yaml/v2 v2.4.3 h1:6gvOSjQoTB3vt1l+CU+tSyi/HOjfOjRLJ4YwYZGwRO0=
+go.yaml.in/yaml/v2 v2.4.3/go.mod h1:zSxWcmIDjOzPXpjlTTbAsKokqkDNAVtZO0WOMiT90s8=
+go.yaml.in/yaml/v3 v3.0.4 h1:tfq32ie2Jv2UxXFdLJdh3jXuOzWiL1fo0bu/FbuKpbc=
+go.yaml.in/yaml/v3 v3.0.4/go.mod h1:DhzuOOF2ATzADvBadXxruRBLzYTpT36CKvDb3+aBEFg=
golang.org/x/crypto v0.0.0-20180904163835-0709b304e793/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
-golang.org/x/crypto v0.39.0 h1:SHs+kF4LP+f+p14esP5jAoDpHU8Gu/v9lFRK6IT5imM=
-golang.org/x/crypto v0.39.0/go.mod h1:L+Xg3Wf6HoL4Bn4238Z6ft6KfEpN0tJGo53AAPC632U=
-golang.org/x/mod v0.25.0 h1:n7a+ZbQKQA/Ysbyb0/6IbB1H/X41mKgbhfv7AfG/44w=
-golang.org/x/mod v0.25.0/go.mod h1:IXM97Txy2VM4PJ3gI61r1YEk/gAj6zAHN3AdZt6S9Ww=
+golang.org/x/crypto v0.45.0 h1:jMBrvKuj23MTlT0bQEOBcAE0mjg8mK9RXFhRH6nyF3Q=
+golang.org/x/crypto v0.45.0/go.mod h1:XTGrrkGJve7CYK7J8PEww4aY7gM3qMCElcJQ8n8JdX4=
+golang.org/x/mod v0.30.0 h1:fDEXFVZ/fmCKProc/yAXXUijritrDzahmwwefnjoPFk=
+golang.org/x/mod v0.30.0/go.mod h1:lAsf5O2EvJeSFMiBxXDki7sCgAxEUcZHXoXMKT4GJKc=
golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
golang.org/x/net v0.0.0-20181114220301-adae6a3d119a/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
golang.org/x/net v0.0.0-20190108225652-1e06a53dbb7e/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
golang.org/x/net v0.0.0-20190613194153-d28f0bde5980/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
golang.org/x/net v0.0.0-20200625001655-4c5254603344/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA=
-golang.org/x/net v0.41.0 h1:vBTly1HeNPEn3wtREYfy4GZ/NECgw2Cnl+nK6Nz3uvw=
-golang.org/x/net v0.41.0/go.mod h1:B/K4NNqkfmg07DQYrbwvSluqCJOOXwUjeb/5lOisjbA=
+golang.org/x/net v0.47.0 h1:Mx+4dIFzqraBXUugkia1OOvlD6LemFo1ALMHjrXDOhY=
+golang.org/x/net v0.47.0/go.mod h1:/jNxtkgq5yWUGYkaZGqo27cfGZ1c5Nen03aYrrKpVRU=
golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
golang.org/x/sync v0.0.0-20201207232520-09787c993a3a/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.15.0 h1:KWH3jNZsfyT6xfAfKiz6MRNmd46ByHDYaZ7KSkCtdW8=
-golang.org/x/sync v0.15.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA=
+golang.org/x/sync v0.18.0 h1:kr88TuHDroi+UVf+0hZnirlk8o8T+4MrK6mr60WkH/I=
+golang.org/x/sync v0.18.0/go.mod h1:9KTHXmSnoGruLpwFjVSX0lNNA75CykiMECbovNTZqGI=
golang.org/x/sys v0.0.0-20180905080454-ebe1bf3edb33/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
golang.org/x/sys v0.0.0-20181116152217-5ac8a444bdc5/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
@@ -404,18 +417,18 @@ golang.org/x/sys v0.0.0-20210927094055-39ccf1dd6fa6/go.mod h1:oPkhp1MJrh7nUepCBc
golang.org/x/sys v0.0.0-20220503163025-988cb79eb6c6/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.1.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.33.0 h1:q3i8TbbEz+JRD9ywIRlyRAQbM0qF7hu24q3teo2hbuw=
-golang.org/x/sys v0.33.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
+golang.org/x/sys v0.38.0 h1:3yZWxaJjBmCWXqhN1qh02AkOnCQ1poK6oF+a7xWL6Gc=
+golang.org/x/sys v0.38.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=
golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
-golang.org/x/text v0.26.0 h1:P42AVeLghgTYr4+xUnTRKDMqpar+PtX7KWuNQL21L8M=
-golang.org/x/text v0.26.0/go.mod h1:QK15LZJUUQVJxhz7wXgxSy/CJaTFjd0G+YLonydOVQA=
+golang.org/x/text v0.31.0 h1:aC8ghyu4JhP8VojJ2lEHBnochRno1sgL6nEi9WGFGMM=
+golang.org/x/text v0.31.0/go.mod h1:tKRAlv61yKIjGGHX/4tP1LTbc13YSec1pxVEWXzfoeM=
golang.org/x/time v0.0.0-20210220033141-f8bda1e9f3ba/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
-golang.org/x/time v0.12.0 h1:ScB/8o8olJvc+CQPWrK3fPZNfh7qgwCrY0zJmoEQLSE=
-golang.org/x/time v0.12.0/go.mod h1:CDIdPxbZBQxdj6cxyCIdrNogrJKMJ7pr37NYpMcMDSg=
+golang.org/x/time v0.14.0 h1:MRx4UaLrDotUKUdCIqzPC48t1Y9hANFKIRpNx+Te8PI=
+golang.org/x/time v0.14.0/go.mod h1:eL/Oa2bBBK0TkX57Fyni+NgnyQQN4LitPmob2Hjnqw4=
golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
-golang.org/x/tools v0.34.0 h1:qIpSLOxeCYGg9TrcJokLBG4KFA6d795g0xkBkiESGlo=
-golang.org/x/tools v0.34.0/go.mod h1:pAP9OwEaY1CAW3HOmg3hLZC5Z0CCmzjAF2UQMSqNARg=
+golang.org/x/tools v0.39.0 h1:ik4ho21kwuQln40uelmciQPp9SipgNDdrafrYA4TmQQ=
+golang.org/x/tools v0.39.0/go.mod h1:JnefbkDPyD8UU2kI5fuf8ZX4/yUeh9W877ZeBONxUqQ=
golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
google.golang.org/appengine v1.4.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4=
google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8=
@@ -425,8 +438,8 @@ google.golang.org/protobuf v1.20.1-0.20200309200217-e05f789c0967/go.mod h1:A+miE
google.golang.org/protobuf v1.21.0/go.mod h1:47Nbq4nVaFHyn7ilMalzfO3qCViNmqZ2kzikPIcrTAo=
google.golang.org/protobuf v1.23.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw=
-google.golang.org/protobuf v1.36.6 h1:z1NpPI8ku2WgiWnf+t9wTPsn6eP1L7ksHUlkfLvd9xY=
-google.golang.org/protobuf v1.36.6/go.mod h1:jduwjTPXsFjZGTmRluh+L6NjiWu7pchiJ2/5YcXBHnY=
+google.golang.org/protobuf v1.36.10 h1:AYd7cD/uASjIL6Q9LiTjz8JLcrh/88q5UObnmY3aOOE=
+google.golang.org/protobuf v1.36.10/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco=
gopkg.in/alecthomas/kingpin.v2 v2.2.6/go.mod h1:FMv+mEhP44yOT+4EoQTLFTRgOQ1FBLkstjWtayDeSgw=
gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
diff --git a/vendor/github.com/99designs/gqlgen/.editorconfig b/vendor/github.com/99designs/gqlgen/.editorconfig
index feba8bbf..4e15c216 100644
--- a/vendor/github.com/99designs/gqlgen/.editorconfig
+++ b/vendor/github.com/99designs/gqlgen/.editorconfig
@@ -1,3 +1,4 @@
+# top-most EditorConfig file
root = true
[*]
@@ -11,8 +12,15 @@ indent_size = 4
[*.{go,gotpl}]
indent_style = tab
-[*.yml]
-indent_size = 2
+# Ignore yaml https://learn.microsoft.com/en-us/visualstudio/code-quality/use-roslyn-analyzers?view=vs-2022
+[*.{yaml,yml,yml.j2,yaml.j2}]
+generated_code = true
+# charset = unset
+# end_of_line = unset
+# insert_final_newline = unset
+# trim_trailing_whitespace = unset
+# indent_style = unset
+# indent_size = unset
# These often end up with go code inside, so lets keep tabs
[*.{html,md}]
diff --git a/vendor/github.com/99designs/gqlgen/.golangci.yml b/vendor/github.com/99designs/gqlgen/.golangci.yml
index af859a78..b521e91b 100644
--- a/vendor/github.com/99designs/gqlgen/.golangci.yml
+++ b/vendor/github.com/99designs/gqlgen/.golangci.yml
@@ -1,13 +1,50 @@
+# All settings can be found here https://github.com/golangci/golangci-lint/blob/HEAD/.golangci.reference.yml
version: "2"
run:
+ concurrency: 8
+ modules-download-mode: readonly
+ issues-exit-code: 1
tests: true
+ allow-parallel-runners: false
+issues:
+ # Maximum count of issues with the same text.
+ # Set to 0 to disable.
+ # Default: 3
+ max-issues-per-linter: 0
+ max-same-issues: 0
+ new: false
+formatters:
+ exclusions:
+ paths:
+ - codegen/testserver/followschema/resolver.go
+ - codegen/testserver/singlefile/resolver.go
+ - codegen/testserver/usefunctionsyntaxforexecutioncontext/resolver.go
+ - generated
+ enable:
+ - golines
+ - gofumpt
+ - gci
+ settings:
+ gci:
+ sections:
+ - standard
+ - default
+ - prefix(github.com/99designs/gqlgen)
+ golines:
+ # Target maximum line length.
+ # Default: 100
+ max-len: 100
linters:
default: none
enable:
+ - asasalint
+ - asciicheck
+ - bidichk
- bodyclose
- copyloopvar
- dupl
- dupword
+ - durationcheck
- errcheck
- gocritic
- govet
@@ -17,17 +54,28 @@ linters:
- nolintlint
- perfsprint
- prealloc
+ - reassign
- revive
- staticcheck
+ - testableexamples
- testifylint
- unconvert
+ - unparam
- unused
+ - usestdlibvars
+ - usetesting
+ - wastedassign
settings:
errcheck:
exclude-functions:
- (io.Writer).Write
+ - (http.ResponseWriter).Write
+ - (*bytes.Buffer).WriteByte
+ - (*strings.Builder).WriteByte
+ - (*strings.Builder).WriteString
- io.Copy
- io.WriteString
+ - fmt.Fprintln
gocritic:
enabled-checks:
- emptyStringTest
@@ -136,14 +184,4 @@ linters:
- third_party$
- builtin$
- examples$
-formatters:
- enable:
- - gofmt
- - goimports
- exclusions:
- generated: lax
- paths:
- - bin
- - third_party$
- - builtin$
- - examples$
+ - generated$
diff --git a/vendor/github.com/99designs/gqlgen/README.md b/vendor/github.com/99designs/gqlgen/README.md
index 7d0a46d0..bcc714ed 100644
--- a/vendor/github.com/99designs/gqlgen/README.md
+++ b/vendor/github.com/99designs/gqlgen/README.md
@@ -22,18 +22,16 @@ cd example
go mod init example
```
-2. Add `github.com/99designs/gqlgen` to your [project's tools.go](https://go.dev/wiki/Modules#how-can-i-track-tool-dependencies-for-a-module)
+2. Add `github.com/99designs/gqlgen` to your project, as a [tool dependency](https://go.dev/doc/modules/managing-dependencies#tools)
```shell
-printf '//go:build tools\npackage tools\nimport (_ "github.com/99designs/gqlgen"\n _ "github.com/99designs/gqlgen/graphql/introspection")' | gofmt > tools.go
-go mod tidy
+go get -tool github.com/99designs/gqlgen
```
3. Initialise gqlgen config and generate models
```shell
-go run github.com/99designs/gqlgen init
-go mod tidy
+go tool gqlgen init
```
4. Start the graphql server
diff --git a/vendor/github.com/99designs/gqlgen/api/generate.go b/vendor/github.com/99designs/gqlgen/api/generate.go
index 3dc5aad8..17973ee1 100644
--- a/vendor/github.com/99designs/gqlgen/api/generate.go
+++ b/vendor/github.com/99designs/gqlgen/api/generate.go
@@ -16,8 +16,12 @@ import (
)
var (
- urlRegex = regexp.MustCompile(`(?s)@link.*\(.*url:\s*?"(.*?)"[^)]+\)`) // regex to grab the url of a link directive, should it exist
- versionRegex = regexp.MustCompile(`v(\d+).(\d+)$`) // regex to grab the version number from a url
+ urlRegex = regexp.MustCompile(
+ `(?s)@link.*\(.*url:\s*?"(.*?)"[^)]+\)`,
+ ) // regex to grab the url of a link directive, should it exist
+ versionRegex = regexp.MustCompile(
+ `v(\d+).(\d+)$`,
+ ) // regex to grab the version number from a url
)
func Generate(cfg *config.Config, option ...Option) error {
@@ -33,7 +37,8 @@ func Generate(cfg *config.Config, option ...Option) error {
plugins = append(plugins, resolvergen.New())
if cfg.Federation.IsDefined() {
if cfg.Federation.Version == 0 { // default to using the user's choice of version, but if unset, try to sort out which federation version to use
- // check the sources, and if one is marked as federation v2, we mark the entirety to be generated using that format
+ // check the sources, and if one is marked as federation v2, we mark the entirety to be
+ // generated using that format
for _, v := range cfg.Sources {
cfg.Federation.Version = 1
urlString := urlRegex.FindStringSubmatch(v.Input)
@@ -63,6 +68,7 @@ func Generate(cfg *config.Config, option ...Option) error {
}
for _, p := range plugins {
+ //nolint:staticcheck // for backwards compatibility only
if inj, ok := p.(plugin.EarlySourceInjector); ok {
if s := inj.InjectSourceEarly(); s != nil {
cfg.Sources = append(cfg.Sources, s)
@@ -101,6 +107,11 @@ func Generate(cfg *config.Config, option ...Option) error {
return fmt.Errorf("failed to load schema: %w", err)
}
+ codegen.ClearInlineArgsMetadata()
+ if err := codegen.ExpandInlineArguments(cfg.Schema); err != nil {
+ return fmt.Errorf("failed to expand inline arguments: %w", err)
+ }
+
if err := cfg.Init(); err != nil {
return fmt.Errorf("generating core failed: %w", err)
}
@@ -122,6 +133,7 @@ func Generate(cfg *config.Config, option ...Option) error {
}
}
}
+
// Merge again now that the generated models have been injected into the typemap
dataPlugins := make([]any, len(plugins))
for index := range plugins {
diff --git a/vendor/github.com/99designs/gqlgen/codegen/args.go b/vendor/github.com/99designs/gqlgen/codegen/args.go
index 736680b3..a291e906 100644
--- a/vendor/github.com/99designs/gqlgen/codegen/args.go
+++ b/vendor/github.com/99designs/gqlgen/codegen/args.go
@@ -31,7 +31,8 @@ type FieldArgument struct {
func (f *FieldArgument) ImplDirectives() []*Directive {
d := make([]*Directive, 0)
for i := range f.Directives {
- if !f.Directives[i].SkipRuntime && f.Directives[i].IsLocation(ast.LocationArgumentDefinition) {
+ if !f.Directives[i].SkipRuntime &&
+ f.Directives[i].IsLocation(ast.LocationArgumentDefinition) {
d = append(d, f.Directives[i])
}
}
@@ -76,7 +77,11 @@ func (b *builder) buildArg(obj *Object, arg *ast.ArgumentDefinition) (*FieldArgu
return &newArg, nil
}
-func (b *builder) bindArgs(field *Field, sig *types.Signature, params *types.Tuple) ([]*FieldArgument, error) {
+func (b *builder) bindArgs(
+ field *Field,
+ sig *types.Signature,
+ params *types.Tuple,
+) ([]*FieldArgument, error) {
n := params.Len()
newArgs := make([]*FieldArgument, 0, len(field.Args))
// Accept variadic methods (i.e. have optional parameters).
diff --git a/vendor/github.com/99designs/gqlgen/codegen/args.gotpl b/vendor/github.com/99designs/gqlgen/codegen/args.gotpl
index a81ea24f..6c267bc6 100644
--- a/vendor/github.com/99designs/gqlgen/codegen/args.gotpl
+++ b/vendor/github.com/99designs/gqlgen/codegen/args.gotpl
@@ -10,10 +10,18 @@ func (ec *executionContext) {{ $name }}(ctx context.Context, rawArgs map[string]
args := map[string]any{}
{{- range $i, $arg := . }}
- {{ if $useFunctionSyntaxForExecutionContext -}}
- arg{{$i}}, err := {{ $name }}{{$arg.Name | go}}(ctx, ec, rawArgs)
+ {{ if $arg.ImplDirectives }}
+ {{ if $useFunctionSyntaxForExecutionContext -}}
+ arg{{$i}}, err := {{ $name }}{{$arg.Name | go}}(ctx, ec, rawArgs)
+ {{- else -}}
+ arg{{$i}}, err := ec.{{ $name }}{{$arg.Name | go}}(ctx, rawArgs)
+ {{- end }}
{{- else -}}
- arg{{$i}}, err := ec.{{ $name }}{{$arg.Name | go}}(ctx, rawArgs)
+ {{ if $useFunctionSyntaxForExecutionContext -}}
+ arg{{$i}}, err := graphql.ProcessArgFieldWithEC(ctx, ec, rawArgs, {{$arg.Name|quote}}, {{ $arg.TypeReference.UnmarshalFunc }})
+ {{- else -}}
+ arg{{$i}}, err := graphql.ProcessArgField(ctx, rawArgs, {{$arg.Name|quote}}, ec.{{ $arg.TypeReference.UnmarshalFunc }})
+ {{- end }}
{{- end }}
if err != nil {
return nil, err
@@ -24,6 +32,9 @@ func (ec *executionContext) {{ $name }}(ctx context.Context, rawArgs map[string]
}
{{- range $i, $arg := . }}
+ {{ if not $arg.ImplDirectives -}}
+ {{- continue -}}
+ {{- end }}
{{ if $useFunctionSyntaxForExecutionContext -}}
func {{ $name }}{{$arg.Name | go}}(
ctx context.Context,
diff --git a/vendor/github.com/99designs/gqlgen/codegen/config/binder.go b/vendor/github.com/99designs/gqlgen/codegen/config/binder.go
index c96b2618..921714ae 100644
--- a/vendor/github.com/99designs/gqlgen/codegen/config/binder.go
+++ b/vendor/github.com/99designs/gqlgen/codegen/config/binder.go
@@ -175,9 +175,10 @@ func indexDefs(pkg *packages.Package) map[string]types.Object {
}
if _, ok := res[astNode.Name]; !ok {
- // The above check may not be really needed, it is only here to have a consistent behavior with
- // previous implementation of FindObject() function which only honored the first inclusion of a def.
- // If this is still needed, we can consider something like sync.Map.LoadOrStore() to avoid two lookups.
+ // The above check may not be really needed, it is only here to have a consistent
+ // behavior with previous implementation of FindObject() function which only honored the
+ // first inclusion of a def. If this is still needed, we can consider something like
+ // sync.Map.LoadOrStore() to avoid two lookups.
res[astNode.Name] = def
}
}
@@ -192,7 +193,8 @@ func (b *Binder) PointerTo(ref *TypeReference) *TypeReference {
return &newRef
}
-// TypeReference is used by args and field types. The Definition can refer to both input and output types.
+// TypeReference is used by args and field types. The Definition can refer to both input and output
+// types.
type TypeReference struct {
Definition *ast.Definition
GQL *ast.Type
@@ -230,7 +232,8 @@ func (ref *TypeReference) IsPtr() bool {
return isPtr
}
-// fix for https://github.com/golang/go/issues/31103 may make it possible to remove this (may still be useful)
+// fix for https://github.com/golang/go/issues/31103 may make it possible to remove this (may still
+// be useful)
func (ref *TypeReference) IsPtrToPtr() bool {
if p, isPtr := ref.GO.(*types.Pointer); isPtr {
_, isPtr := p.Elem().(*types.Pointer)
@@ -293,7 +296,9 @@ func (ref *TypeReference) UniquenessKey() string {
// Fix for #896
elemNullability = "ᚄ"
}
- return nullability + ref.Definition.Name + "2" + templates.TypeIdentifier(ref.GO) + elemNullability
+ return nullability + ref.Definition.Name + "2" + templates.TypeIdentifier(
+ ref.GO,
+ ) + elemNullability
}
func (ref *TypeReference) MarshalFunc() string {
@@ -370,7 +375,10 @@ func unwrapOmittable(t types.Type) (types.Type, bool) {
return named.TypeArgs().At(0), true
}
-func (b *Binder) TypeReference(schemaType *ast.Type, bindTarget types.Type) (ret *TypeReference, err error) {
+func (b *Binder) TypeReference(
+ schemaType *ast.Type,
+ bindTarget types.Type,
+) (ret *TypeReference, err error) {
if bindTarget != nil {
bindTarget = code.Unalias(bindTarget)
}
@@ -464,7 +472,8 @@ func (b *Binder) TypeReference(schemaType *ast.Type, bindTarget types.Type) (ret
ref.GO = t
ref.IsMarshaler = true
} else if underlying := basicUnderlying(t); def.IsLeafType() && underlying != nil && underlying.Kind() == types.String {
- // TODO delete before v1. Backwards compatibility case for named types wrapping strings (see #595)
+ // TODO delete before v1. Backwards compatibility case for named types wrapping strings
+ // (see #595)
ref.GO = t
ref.CastType = underlying
@@ -485,8 +494,11 @@ func (b *Binder) TypeReference(schemaType *ast.Type, bindTarget types.Type) (ret
if bindTarget != nil {
if err = code.CompatibleTypes(ref.GO, bindTarget); err != nil {
- // if the bind type implements the graphql.ContextMarshaler/graphql.ContextUnmarshaler/graphql.Marshaler/graphql.Unmarshaler interface, we can use it
- if hasMethod(bindTarget, "MarshalGQLContext") && hasMethod(bindTarget, "UnmarshalGQLContext") {
+ // if the bind type implements the
+ // graphql.ContextMarshaler/graphql.ContextUnmarshaler/graphql.Marshaler/graphql.Unmarshaler
+ // interface, we can use it
+ if hasMethod(bindTarget, "MarshalGQLContext") &&
+ hasMethod(bindTarget, "UnmarshalGQLContext") {
ref.IsContext = true
ref.IsMarshaler = true
ref.Marshaler = nil
@@ -523,7 +535,8 @@ func (b *Binder) CopyModifiersFromAst(t *ast.Type, base types.Type) types.Type {
base = types.Unalias(base)
if t.Elem != nil {
child := b.CopyModifiersFromAst(t.Elem, base)
- if _, isStruct := child.Underlying().(*types.Struct); isStruct && !b.cfg.OmitSliceElementPointers {
+ if _, isStruct := child.Underlying().(*types.Struct); isStruct &&
+ !b.cfg.OmitSliceElementPointers {
child = types.NewPointer(child)
}
return types.NewSlice(child)
@@ -613,7 +626,11 @@ func (b *Binder) enumValues(def *ast.Definition) map[string]EnumValue {
return model.EnumValues
}
-func (b *Binder) enumReference(ref *TypeReference, obj types.Object, values map[string]EnumValue) error {
+func (b *Binder) enumReference(
+ ref *TypeReference,
+ obj types.Object,
+ values map[string]EnumValue,
+) error {
if len(ref.Definition.EnumValues) != len(values) {
return fmt.Errorf("not all enum values are binded for %v", ref.Definition.Name)
}
@@ -637,7 +654,11 @@ func (b *Binder) enumReference(ref *TypeReference, obj types.Object, values map[
for _, value := range ref.Definition.EnumValues {
v, ok := values[value.Name]
if !ok {
- return fmt.Errorf("enum value not found for: %v, of enum: %v", value.Name, ref.Definition.Name)
+ return fmt.Errorf(
+ "enum value not found for: %v, of enum: %v",
+ value.Name,
+ ref.Definition.Name,
+ )
}
pkgName, typeName := code.PkgAndType(v.Value)
diff --git a/vendor/github.com/99designs/gqlgen/codegen/config/config.go b/vendor/github.com/99designs/gqlgen/codegen/config/config.go
index 32919509..3b87a358 100644
--- a/vendor/github.com/99designs/gqlgen/codegen/config/config.go
+++ b/vendor/github.com/99designs/gqlgen/codegen/config/config.go
@@ -12,10 +12,10 @@ import (
"sort"
"strings"
+ "github.com/goccy/go-yaml"
"github.com/vektah/gqlparser/v2"
"github.com/vektah/gqlparser/v2/ast"
"golang.org/x/tools/go/packages"
- "gopkg.in/yaml.v3"
"github.com/99designs/gqlgen/codegen/templates"
"github.com/99designs/gqlgen/internal/code"
@@ -30,6 +30,7 @@ type Config struct {
AutoBind []string `yaml:"autobind"`
Models TypeMap `yaml:"models,omitempty"`
StructTag string `yaml:"struct_tag,omitempty"`
+ EmbeddedStructsPrefix string `yaml:"embedded_structs_prefix,omitempty"`
Directives map[string]DirectiveConfig `yaml:"directives,omitempty"`
LocalPrefix string `yaml:"local_prefix,omitempty"`
GoBuildTags StringList `yaml:"go_build_tags,omitempty"`
@@ -68,8 +69,9 @@ type Config struct {
var cfgFilenames = []string{".gqlgen.yml", "gqlgen.yml", "gqlgen.yaml"}
-// templatePackageNames is a list of packages names that the default templates use, in order to preload those for performance considerations
-// any additional package added to the base templates should be added here to improve performance and load all packages in bulk
+// templatePackageNames is a list of packages names that the default templates use, in order to
+// preload those for performance considerations any additional package added to the base templates
+// should be added here to improve performance and load all packages in bulk
var templatePackageNames = []string{
"context", "fmt", "io", "strconv", "time", "sync", "strings", "sync/atomic", "embed", "golang.org/x/sync/semaphore",
"errors", "bytes", "github.com/vektah/gqlparser/v2", "github.com/vektah/gqlparser/v2/ast",
@@ -90,6 +92,7 @@ func DefaultConfig() *Config {
ResolversAlwaysReturnPointers: true,
NullableInputOmittable: false,
EnableModelJsonOmitzeroTag: &falseValue,
+ EmbeddedStructsPrefix: "Base",
}
}
@@ -106,13 +109,17 @@ func LoadDefaultConfig() (*Config, error) {
return nil, fmt.Errorf("unable to open schema: %w", err)
}
- config.Sources = append(config.Sources, &ast.Source{Name: filename, Input: string(schemaRaw)})
+ config.Sources = append(
+ config.Sources,
+ &ast.Source{Name: filename, Input: string(schemaRaw)},
+ )
}
return config, nil
}
-// LoadConfigFromDefaultLocations looks for a config file in the current directory, and all parent directories
+// LoadConfigFromDefaultLocations looks for a config file in the current directory, and all parent
+// directories
// walking up the tree. The closest config file will be returned.
func LoadConfigFromDefaultLocations() (*Config, error) {
cfgFile, err := findCfg()
@@ -144,11 +151,17 @@ func LoadConfig(filename string) (*Config, error) {
return ReadConfig(bytes.NewReader(b))
}
-func ReadConfig(cfgFile io.Reader) (*Config, error) {
+func ReadConfig(cfgFile io.Reader) (cfg *Config, err error) {
+ defer func() {
+ if r := recover(); r != nil {
+ cfg = nil
+ err = fmt.Errorf("unable to parse config: panic during decode: %v", r)
+ }
+ }()
+
config := DefaultConfig()
- dec := yaml.NewDecoder(cfgFile)
- dec.KnownFields(true)
+ dec := yaml.NewDecoder(cfgFile, yaml.DisallowUnknownField())
if err := dec.Decode(config); err != nil {
return nil, fmt.Errorf("unable to parse config: %w", err)
@@ -189,20 +202,24 @@ func CompleteConfig(config *Config) error {
pathParts := strings.SplitN(f, "**", 2)
rest := strings.TrimPrefix(strings.TrimPrefix(pathParts[1], `\`), `/`)
// turn the rest of the glob into a regex, anchored only at the end because ** allows
- // for any number of dirs in between and walk will let us match against the full path name
+ // for any number of dirs in between and walk will let us match against the full path
+ // name
globRe := regexp.MustCompile(path2regex.Replace(rest) + `$`)
- if err := filepath.Walk(pathParts[0], func(path string, info os.FileInfo, err error) error {
- if err != nil {
- return err
- }
+ if err := filepath.Walk(
+ pathParts[0],
+ func(path string, info os.FileInfo, err error) error {
+ if err != nil {
+ return err
+ }
- if globRe.MatchString(strings.TrimPrefix(path, pathParts[0])) {
- matches = append(matches, path)
- }
+ if globRe.MatchString(strings.TrimPrefix(path, pathParts[0])) {
+ matches = append(matches, path)
+ }
- return nil
- }); err != nil {
+ return nil
+ },
+ ); err != nil {
return fmt.Errorf("failed to walk schema at root %s: %w", pathParts[0], err)
}
} else {
@@ -230,7 +247,10 @@ func CompleteConfig(config *Config) error {
return fmt.Errorf("unable to open schema: %w", err)
}
- config.Sources = append(config.Sources, &ast.Source{Name: filename, Input: string(schemaRaw)})
+ config.Sources = append(
+ config.Sources,
+ &ast.Source{Name: filename, Input: string(schemaRaw)},
+ )
}
config.GoInitialisms.setInitialisms()
@@ -296,7 +316,7 @@ func (c *Config) IsRoot(def *ast.Definition) bool {
}
func (c *Config) injectTypesFromSchema() error {
- for _, d := range []string{"goModel", "goExtraField", "goField", "goTag", "goEnum"} {
+ for _, d := range []string{"goModel", "goExtraField", "goField", "goTag", "goEnum", "inlineArguments"} {
c.Directives[d] = DirectiveConfig{SkipRuntime: true}
}
@@ -423,7 +443,10 @@ func (c *Config) injectTypesFromSchema() error {
if extraFieldName == "" {
// Embeddable fields
- typeMapEntry.EmbedExtraFields = append(typeMapEntry.EmbedExtraFields, extraField)
+ typeMapEntry.EmbedExtraFields = append(
+ typeMapEntry.EmbedExtraFields,
+ extraField,
+ )
} else {
// Regular fields
if typeMapEntry.ExtraFields == nil {
@@ -599,34 +622,43 @@ func (c *Config) check() error {
if err := c.Resolver.Check(); err != nil {
return fmt.Errorf("config.resolver: %w", err)
}
- fileList[c.Resolver.ImportPath()] = append(fileList[c.Resolver.ImportPath()], FilenamePackage{
- Filename: c.Resolver.Filename,
- Package: c.Resolver.Package,
- Declaree: "resolver",
- })
+ fileList[c.Resolver.ImportPath()] = append(
+ fileList[c.Resolver.ImportPath()],
+ FilenamePackage{
+ Filename: c.Resolver.Filename,
+ Package: c.Resolver.Package,
+ Declaree: "resolver",
+ },
+ )
}
if c.Federation.IsDefined() {
if err := c.Federation.Check(); err != nil {
return fmt.Errorf("config.federation: %w", err)
}
- fileList[c.Federation.ImportPath()] = append(fileList[c.Federation.ImportPath()], FilenamePackage{
- Filename: c.Federation.Filename,
- Package: c.Federation.Package,
- Declaree: "federation",
- })
+ fileList[c.Federation.ImportPath()] = append(
+ fileList[c.Federation.ImportPath()],
+ FilenamePackage{
+ Filename: c.Federation.Filename,
+ Package: c.Federation.Package,
+ Declaree: "federation",
+ },
+ )
if c.Federation.ImportPath() != c.Exec.ImportPath() {
return errors.New("federation and exec must be in the same package")
}
}
if c.Federated {
- return errors.New("federated has been removed, instead use\nfederation:\n filename: path/to/federated.go")
+ return errors.New(
+ "federated has been removed, instead use\nfederation:\n filename: path/to/federated.go",
+ )
}
for importPath, pkg := range fileList {
for _, file1 := range pkg {
for _, file2 := range pkg {
if file1.Package != file2.Package {
- return fmt.Errorf("%s and %s define the same import path (%s) with different package names (%s vs %s)",
+ return fmt.Errorf(
+ "%s and %s define the same import path (%s) with different package names (%s vs %s)",
file1.Declaree,
file2.Declaree,
importPath,
@@ -657,14 +689,22 @@ func (tm TypeMap) Check() error {
for typeName, entry := range tm {
for _, model := range entry.Model {
if strings.LastIndex(model, ".") < strings.LastIndex(model, "/") {
- return fmt.Errorf("model %s: invalid type specifier \"%s\" - you need to specify a struct to map to", typeName, entry.Model)
+ return fmt.Errorf(
+ "model %s: invalid type specifier \"%s\" - you need to specify a struct to map to",
+ typeName,
+ entry.Model,
+ )
}
}
if len(entry.Model) == 0 {
for enum, v := range entry.EnumValues {
if v.Value != "" {
- return fmt.Errorf("model is empty for: %v, but enum value is specified for %v", typeName, enum)
+ return fmt.Errorf(
+ "model is empty for: %v, but enum value is specified for %v",
+ typeName,
+ enum,
+ )
}
}
}
@@ -719,7 +759,8 @@ type DirectiveConfig struct {
// The function implemmentation should be provided here as a string.
//
// The function should have the following signature:
- // func(ctx context.Context, obj any, next graphql.Resolver[, directive arguments if any]) (res any, err error)
+ // func(ctx context.Context, obj any, next graphql.Resolver[, directive arguments if any]) (res
+ // any, err error)
Implementation *string
}
@@ -779,7 +820,10 @@ func (c *Config) autobind() error {
for i, p := range ps {
if p == nil || p.Module == nil {
- return fmt.Errorf("unable to load %s - make sure you're using an import path to a package that exists", c.AutoBind[i])
+ return fmt.Errorf(
+ "unable to load %s - make sure you're using an import path to a package that exists",
+ c.AutoBind[i],
+ )
}
autobindType := c.lookupAutobindType(p, t)
@@ -831,17 +875,31 @@ func (c *Config) lookupAutobindType(p *packages.Package, schemaType *ast.Definit
func (c *Config) injectBuiltins() {
builtins := TypeMap{
- "__Directive": {Model: StringList{"github.com/99designs/gqlgen/graphql/introspection.Directive"}},
+ "__Directive": {
+ Model: StringList{"github.com/99designs/gqlgen/graphql/introspection.Directive"},
+ },
"__DirectiveLocation": {Model: StringList{"github.com/99designs/gqlgen/graphql.String"}},
- "__Type": {Model: StringList{"github.com/99designs/gqlgen/graphql/introspection.Type"}},
- "__TypeKind": {Model: StringList{"github.com/99designs/gqlgen/graphql.String"}},
- "__Field": {Model: StringList{"github.com/99designs/gqlgen/graphql/introspection.Field"}},
- "__EnumValue": {Model: StringList{"github.com/99designs/gqlgen/graphql/introspection.EnumValue"}},
- "__InputValue": {Model: StringList{"github.com/99designs/gqlgen/graphql/introspection.InputValue"}},
- "__Schema": {Model: StringList{"github.com/99designs/gqlgen/graphql/introspection.Schema"}},
- "Float": {Model: StringList{"github.com/99designs/gqlgen/graphql.FloatContext"}},
- "String": {Model: StringList{"github.com/99designs/gqlgen/graphql.String"}},
- "Boolean": {Model: StringList{"github.com/99designs/gqlgen/graphql.Boolean"}},
+ "__Type": {
+ Model: StringList{"github.com/99designs/gqlgen/graphql/introspection.Type"},
+ },
+ "__TypeKind": {Model: StringList{"github.com/99designs/gqlgen/graphql.String"}},
+ "__Field": {
+ Model: StringList{"github.com/99designs/gqlgen/graphql/introspection.Field"},
+ },
+ "__EnumValue": {
+ Model: StringList{"github.com/99designs/gqlgen/graphql/introspection.EnumValue"},
+ },
+ "__InputValue": {
+ Model: StringList{"github.com/99designs/gqlgen/graphql/introspection.InputValue"},
+ },
+ "__Schema": {
+ Model: StringList{"github.com/99designs/gqlgen/graphql/introspection.Schema"},
+ },
+ "Float": {
+ Model: StringList{"github.com/99designs/gqlgen/graphql.FloatContext"},
+ },
+ "String": {Model: StringList{"github.com/99designs/gqlgen/graphql.String"}},
+ "Boolean": {Model: StringList{"github.com/99designs/gqlgen/graphql.Boolean"}},
"Int": {
// FIXME: using int / int64 for Int is not spec compliant and introduces
// security risks. We should default to int32.
@@ -880,7 +938,8 @@ func (c *Config) injectBuiltins() {
}
for typeName, entry := range extraBuiltins {
- if t, ok := c.Schema.Types[typeName]; !c.Models.Exists(typeName) && ok && t.Kind == ast.Scalar {
+ if t, ok := c.Schema.Types[typeName]; !c.Models.Exists(typeName) && ok &&
+ t.Kind == ast.Scalar {
c.Models[typeName] = entry
}
}
diff --git a/vendor/github.com/99designs/gqlgen/codegen/config/exec.go b/vendor/github.com/99designs/gqlgen/codegen/config/exec.go
index 37ec2c30..dfd91bd5 100644
--- a/vendor/github.com/99designs/gqlgen/codegen/config/exec.go
+++ b/vendor/github.com/99designs/gqlgen/codegen/config/exec.go
@@ -33,7 +33,8 @@ type ExecLayout string
var (
// Write all generated code to a single file.
ExecLayoutSingleFile ExecLayout = "single-file"
- // Write generated code to a directory, generating one Go source file for each GraphQL schema file.
+ // Write generated code to a directory, generating one Go source file for each GraphQL schema
+ // file.
ExecLayoutFollowSchema ExecLayout = "follow-schema"
)
@@ -48,7 +49,9 @@ func (r *ExecConfig) Check() error {
return errors.New("filename must be specified when using single-file layout")
}
if !strings.HasSuffix(r.Filename, ".go") {
- return errors.New("filename should be path to a go source file when using single-file layout")
+ return errors.New(
+ "filename should be path to a go source file when using single-file layout",
+ )
}
r.Filename = abs(r.Filename)
case ExecLayoutFollowSchema:
@@ -61,7 +64,9 @@ func (r *ExecConfig) Check() error {
}
if strings.ContainsAny(r.Package, "./\\") {
- return errors.New("package should be the output package name only, do not include the output filename")
+ return errors.New(
+ "package should be the output package name only, do not include the output filename",
+ )
}
if r.Package == "" && r.Dir() != "" {
diff --git a/vendor/github.com/99designs/gqlgen/codegen/config/initialisms.go b/vendor/github.com/99designs/gqlgen/codegen/config/initialisms.go
index 432c56e0..ba536d9e 100644
--- a/vendor/github.com/99designs/gqlgen/codegen/config/initialisms.go
+++ b/vendor/github.com/99designs/gqlgen/codegen/config/initialisms.go
@@ -6,7 +6,8 @@ import (
"github.com/99designs/gqlgen/codegen/templates"
)
-// GoInitialismsConfig allows to modify the default behavior of naming Go methods, types and properties
+// GoInitialismsConfig allows to modify the default behavior of naming Go methods, types and
+// properties
type GoInitialismsConfig struct {
// If true, the Initialisms won't get appended to the default ones but replace them
ReplaceDefaults bool `yaml:"replace_defaults"`
diff --git a/vendor/github.com/99designs/gqlgen/codegen/config/package.go b/vendor/github.com/99designs/gqlgen/codegen/config/package.go
index a399b2cc..4876f398 100644
--- a/vendor/github.com/99designs/gqlgen/codegen/config/package.go
+++ b/vendor/github.com/99designs/gqlgen/codegen/config/package.go
@@ -44,7 +44,9 @@ func (c *PackageConfig) IsDefined() bool {
func (c *PackageConfig) Check() error {
if strings.ContainsAny(c.Package, "./\\") {
- return errors.New("package should be the output package name only, do not include the output filename")
+ return errors.New(
+ "package should be the output package name only, do not include the output filename",
+ )
}
if c.Filename == "" {
return errors.New("filename must be specified")
diff --git a/vendor/github.com/99designs/gqlgen/codegen/config/resolver.go b/vendor/github.com/99designs/gqlgen/codegen/config/resolver.go
index fa0744e1..bb44969b 100644
--- a/vendor/github.com/99designs/gqlgen/codegen/config/resolver.go
+++ b/vendor/github.com/99designs/gqlgen/codegen/config/resolver.go
@@ -43,7 +43,10 @@ func (r *ResolverConfig) Check() error {
return fmt.Errorf("filename must be specified with layout=%s", r.Layout)
}
if !strings.HasSuffix(r.Filename, ".go") {
- return fmt.Errorf("filename should be path to a go source file with layout=%s", r.Layout)
+ return fmt.Errorf(
+ "filename should be path to a go source file with layout=%s",
+ r.Layout,
+ )
}
r.Filename = abs(r.Filename)
case LayoutFollowSchema:
@@ -57,11 +60,18 @@ func (r *ResolverConfig) Check() error {
r.Filename = abs(r.Filename)
}
default:
- return fmt.Errorf("invalid layout %s. must be %s or %s", r.Layout, LayoutSingleFile, LayoutFollowSchema)
+ return fmt.Errorf(
+ "invalid layout %s. must be %s or %s",
+ r.Layout,
+ LayoutSingleFile,
+ LayoutFollowSchema,
+ )
}
if strings.ContainsAny(r.Package, "./\\") {
- return errors.New("package should be the output package name only, do not include the output filename")
+ return errors.New(
+ "package should be the output package name only, do not include the output filename",
+ )
}
if r.Package == "" && r.Dir() != "" {
diff --git a/vendor/github.com/99designs/gqlgen/codegen/data.go b/vendor/github.com/99designs/gqlgen/codegen/data.go
index d3d8cd89..cc556670 100644
--- a/vendor/github.com/99designs/gqlgen/codegen/data.go
+++ b/vendor/github.com/99designs/gqlgen/codegen/data.go
@@ -13,7 +13,8 @@ import (
"github.com/99designs/gqlgen/codegen/config"
)
-// Data is a unified model of the code to be generated. Plugins may modify this structure to do things like implement
+// Data is a unified model of the code to be generated. Plugins may modify this structure to do
+// things like implement
// resolvers or directives automatically (eg grpc, validation)
type Data struct {
Config *config.Config
@@ -48,7 +49,8 @@ func (d *Data) HasEmbeddableSources() bool {
return hasEmbeddableSources
}
-// AugmentedSource contains extra information about graphql schema files which is not known directly from the Config.Sources data
+// AugmentedSource contains extra information about graphql schema files which is not known directly
+// from the Config.Sources data
type AugmentedSource struct {
// path relative to Config.Exec.Filename
RelativePath string
@@ -103,7 +105,6 @@ func (d *Data) Directives() DirectiveList {
}
func BuildData(cfg *config.Config, plugins ...any) (*Data, error) {
- // We reload all packages to allow packages to be compared correctly.
cfg.ReloadAllPackages()
b := builder{
@@ -195,10 +196,18 @@ func BuildData(cfg *config.Config, plugins ...any) (*Data, error) {
}
// otherwise show a generic error message
- return nil, errors.New("invalid types were encountered while traversing the go source code, this probably means the invalid code generated isnt correct. add try adding -v to debug")
+ return nil, errors.New(
+ "invalid types were encountered while traversing the go source code, this probably means the invalid code generated isnt correct. add try adding -v to debug",
+ )
}
+ var sources []*ast.Source
+ sources, err = SerializeTransformedSchema(cfg.Schema, cfg.Sources)
+ if err != nil {
+ return nil, fmt.Errorf("failed to serialize transformed schema: %w", err)
+ }
+
aSources := []AugmentedSource{}
- for _, s := range cfg.Sources {
+ for _, s := range sources {
wd, err := os.Getwd()
if err != nil {
return nil, fmt.Errorf("failed to get working directory: %w", err)
@@ -207,7 +216,12 @@ func BuildData(cfg *config.Config, plugins ...any) (*Data, error) {
sourcePath := filepath.Join(wd, s.Name)
relative, err := filepath.Rel(outputDir, sourcePath)
if err != nil {
- return nil, fmt.Errorf("failed to compute path of %s relative to %s: %w", sourcePath, outputDir, err)
+ return nil, fmt.Errorf(
+ "failed to compute path of %s relative to %s: %w",
+ sourcePath,
+ outputDir,
+ err,
+ )
}
relative = filepath.ToSlash(relative)
embeddable := true
diff --git a/vendor/github.com/99designs/gqlgen/codegen/directive.go b/vendor/github.com/99designs/gqlgen/codegen/directive.go
index f7a7c1c8..fb6de795 100644
--- a/vendor/github.com/99designs/gqlgen/codegen/directive.go
+++ b/vendor/github.com/99designs/gqlgen/codegen/directive.go
@@ -38,7 +38,10 @@ func (d *Directive) IsLocation(location ...ast.DirectiveLocation) bool {
return false
}
-func locationDirectives(directives DirectiveList, location ...ast.DirectiveLocation) map[string]*Directive {
+func locationDirectives(
+ directives DirectiveList,
+ location ...ast.DirectiveLocation,
+) map[string]*Directive {
mDirectives := make(map[string]*Directive)
for name, d := range directives {
if d.IsLocation(location...) {
@@ -73,7 +76,12 @@ func (b *builder) buildDirectives() (map[string]*Directive, error) {
var err error
newArg.Default, err = arg.DefaultValue.Value(nil)
if err != nil {
- return nil, fmt.Errorf("default value for directive argument %s(%s) is not valid: %w", dir.Name, arg.Name, err)
+ return nil, fmt.Errorf(
+ "default value for directive argument %s(%s) is not valid: %w",
+ dir.Name,
+ arg.Name,
+ err,
+ )
}
}
args = append(args, newArg)
@@ -142,7 +150,14 @@ func (d *Directive) CallArgs() string {
args := []string{"ctx", "obj", "n"}
for _, arg := range d.Args {
- args = append(args, fmt.Sprintf("args[%q].(%s)", arg.Name, templates.CurrentImports.LookupType(arg.TypeReference.GO)))
+ args = append(
+ args,
+ fmt.Sprintf(
+ "args[%q].(%s)",
+ arg.Name,
+ templates.CurrentImports.LookupType(arg.TypeReference.GO),
+ ),
+ )
}
return strings.Join(args, ", ")
@@ -170,9 +185,17 @@ func (d *Directive) CallName() string {
func (d *Directive) Declaration() string {
res := d.CallName() + " func(ctx context.Context, obj any, next graphql.Resolver"
+ var resSb173 strings.Builder
for _, arg := range d.Args {
- res += fmt.Sprintf(", %s %s", templates.ToGoPrivate(arg.Name), templates.CurrentImports.LookupType(arg.TypeReference.GO))
+ resSb173.WriteString(
+ fmt.Sprintf(
+ ", %s %s",
+ templates.ToGoPrivate(arg.Name),
+ templates.CurrentImports.LookupType(arg.TypeReference.GO),
+ ),
+ )
}
+ res += resSb173.String()
res += ") (res any, err error)"
return res
diff --git a/vendor/github.com/99designs/gqlgen/codegen/directives.gotpl b/vendor/github.com/99designs/gqlgen/codegen/directives.gotpl
index e575c3d6..f1584dc5 100644
--- a/vendor/github.com/99designs/gqlgen/codegen/directives.gotpl
+++ b/vendor/github.com/99designs/gqlgen/codegen/directives.gotpl
@@ -73,7 +73,7 @@
if data, ok := tmp.(graphql.Marshaler); ok {
return data
}
- ec.Errorf(ctx, `unexpected type %T from directive, should be graphql.Marshaler`, tmp)
+ graphql.AddErrorf(ctx, `unexpected type %T from directive, should be graphql.Marshaler`, tmp)
return graphql.Null
{{end}}
@@ -147,7 +147,7 @@ func (ec *executionContext) _subscriptionMiddleware(ctx context.Context, obj *as
if data, ok := tmp.(func(ctx context.Context) graphql.Marshaler); ok {
return data
}
- ec.Errorf(ctx, `unexpected type %T from directive, should be graphql.Marshaler`, tmp)
+ graphql.AddErrorf(ctx, `unexpected type %T from directive, should be graphql.Marshaler`, tmp)
return func(ctx context.Context) graphql.Marshaler {
return graphql.Null
}
@@ -156,9 +156,9 @@ func (ec *executionContext) _subscriptionMiddleware(ctx context.Context, obj *as
{{ if .Directives.LocationDirectives "FIELD" }}
{{ if $useFunctionSyntaxForExecutionContext -}}
- func _fieldMiddleware(ctx context.Context, ec *executionContext, obj any, next graphql.Resolver) any {
+ func _fieldMiddleware(ctx context.Context, ec *executionContext, obj any, next graphql.Resolver) graphql.Resolver {
{{- else -}}
- func (ec *executionContext) _fieldMiddleware(ctx context.Context, obj any, next graphql.Resolver) any {
+ func (ec *executionContext) _fieldMiddleware(ctx context.Context, obj any, next graphql.Resolver) graphql.Resolver {
{{- end }}
{{- if .Directives.LocationDirectives "FIELD" }}
fc := graphql.GetFieldContext(ctx)
@@ -186,11 +186,6 @@ func (ec *executionContext) _subscriptionMiddleware(ctx context.Context, obj *as
}
}
{{- end }}
- res, err := ec.ResolverMiddleware(ctx, next)
- if err != nil {
- ec.Error(ctx, err)
- return nil
- }
- return res
+ return next
}
{{ end }}
diff --git a/vendor/github.com/99designs/gqlgen/codegen/field.go b/vendor/github.com/99designs/gqlgen/codegen/field.go
index 7fb36ebb..73b081e8 100644
--- a/vendor/github.com/99designs/gqlgen/codegen/field.go
+++ b/vendor/github.com/99designs/gqlgen/codegen/field.go
@@ -76,7 +76,8 @@ func (b *builder) buildField(obj *Object, field *ast.FieldDefinition) (*Field, e
log.Println(err.Error())
}
- if f.IsResolver && b.Config.ResolversAlwaysReturnPointers && !f.TypeReference.IsPtr() && f.TypeReference.IsStruct() {
+ if f.IsResolver && b.Config.ResolversAlwaysReturnPointers && !f.TypeReference.IsPtr() &&
+ f.TypeReference.IsStruct() {
f.TypeReference = b.Binder.PointerTo(f.TypeReference)
}
@@ -317,9 +318,13 @@ func (b *builder) findBindMethodTarget(in types.Type, name string) (types.Object
return nil, nil
}
-func (b *builder) findBindMethoderTarget(methodFunc func(i int) *types.Func, methodCount int, name string) (types.Object, error) {
+func (b *builder) findBindMethoderTarget(
+ methodFunc func(i int) *types.Func,
+ methodCount int,
+ name string,
+) (types.Object, error) {
var found types.Object
- for i := 0; i < methodCount; i++ {
+ for i := range methodCount {
method := methodFunc(i)
if !method.Exported() || !strings.EqualFold(method.Name(), name) {
continue
@@ -373,7 +378,10 @@ func (b *builder) findBindEmbedsTarget(in types.Type, name string) (types.Object
return nil, nil
}
-func (b *builder) findBindStructEmbedsTarget(strukt *types.Struct, name string) (types.Object, error) {
+func (b *builder) findBindStructEmbedsTarget(
+ strukt *types.Struct,
+ name string,
+) (types.Object, error) {
var found types.Object
for i := 0; i < strukt.NumFields(); i++ {
field := strukt.Field(i)
@@ -403,7 +411,10 @@ func (b *builder) findBindStructEmbedsTarget(strukt *types.Struct, name string)
return found, nil
}
-func (b *builder) findBindInterfaceEmbedsTarget(iface *types.Interface, name string) (types.Object, error) {
+func (b *builder) findBindInterfaceEmbedsTarget(
+ iface *types.Interface,
+ name string,
+) (types.Object, error) {
var found types.Object
for i := 0; i < iface.NumEmbeddeds(); i++ {
embeddedType := iface.EmbeddedType(i)
@@ -518,6 +529,36 @@ func (f *Field) IsRoot() bool {
return f.Object.Root
}
+func contains(slice []string, str string) bool {
+ for _, s := range slice {
+ if s == str {
+ return true
+ }
+ }
+ return false
+}
+
+func formatGoType(goType string) string {
+ if strings.Contains(goType, "/") {
+ lastDot := strings.LastIndex(goType, ".")
+ if lastDot == -1 {
+ return goType
+ }
+
+ packagePath := goType[:lastDot]
+ typeName := goType[lastDot+1:]
+
+ alias := templates.CurrentImports.Lookup(packagePath)
+ if alias == "" {
+ return typeName
+ }
+
+ return alias + "." + typeName
+ }
+
+ return goType
+}
+
func (f *Field) ShortResolverDeclaration() string {
return f.ShortResolverSignature(nil)
}
@@ -537,9 +578,33 @@ func (f *Field) ShortResolverSignature(ft *goast.FuncType) string {
if !f.Object.Root {
res += fmt.Sprintf(", obj %s", templates.CurrentImports.LookupType(f.Object.Reference()))
}
- for _, arg := range f.Args {
- res += fmt.Sprintf(", %s %s", arg.VarName, templates.CurrentImports.LookupType(arg.TypeReference.GO))
+ var resSb540 strings.Builder
+
+ var inlineInfo *InlineArgsInfo
+ if f.Object != nil && f.Object.Definition != nil {
+ inlineInfo = GetInlineArgsMetadata(f.Object.Name, f.Name)
}
+ if inlineInfo != nil {
+ goType := formatGoType(inlineInfo.GoType)
+ resSb540.WriteString(fmt.Sprintf(", %s %s", inlineInfo.OriginalArgName, goType))
+
+ for _, arg := range f.Args {
+ if !contains(inlineInfo.ExpandedArgs, arg.Name) {
+ resSb540.WriteString(
+ fmt.Sprintf(
+ ", %s %s",
+ arg.VarName,
+ templates.CurrentImports.LookupType(arg.TypeReference.GO),
+ ),
+ )
+ }
+ }
+ } else {
+ for _, arg := range f.Args {
+ resSb540.WriteString(fmt.Sprintf(", %s %s", arg.VarName, templates.CurrentImports.LookupType(arg.TypeReference.GO)))
+ }
+ }
+ res += resSb540.String()
result := templates.CurrentImports.LookupType(f.TypeReference.GO)
if f.Object.Stream {
@@ -555,7 +620,11 @@ func (f *Field) ShortResolverSignature(ft *goast.FuncType) string {
namedE = ft.Results.List[1].Names[0].Name
}
}
- res += fmt.Sprintf(") (%s %s, %s error)", namedV, result, namedE)
+ if namedV != "" || namedE != "" {
+ res += fmt.Sprintf(") (%s %s, %s error)", namedV, result, namedE)
+ } else {
+ res += fmt.Sprintf(") (%s, error)", result)
+ }
return res
}
@@ -568,9 +637,17 @@ func (f *Field) GoResultName() (string, bool) {
func (f *Field) ComplexitySignature() string {
res := "func(childComplexity int"
+ var resSb571 strings.Builder
for _, arg := range f.Args {
- res += fmt.Sprintf(", %s %s", arg.VarName, templates.CurrentImports.LookupType(arg.TypeReference.GO))
+ resSb571.WriteString(
+ fmt.Sprintf(
+ ", %s %s",
+ arg.VarName,
+ templates.CurrentImports.LookupType(arg.TypeReference.GO),
+ ),
+ )
}
+ res += resSb571.String()
res += ") int"
return res
}
@@ -578,7 +655,11 @@ func (f *Field) ComplexitySignature() string {
func (f *Field) ComplexityArgs() string {
args := make([]string, len(f.Args))
for i, arg := range f.Args {
- args[i] = "args[" + strconv.Quote(arg.Name) + "].(" + templates.CurrentImports.LookupType(arg.TypeReference.GO) + ")"
+ args[i] = "args[" + strconv.Quote(
+ arg.Name,
+ ) + "].(" + templates.CurrentImports.LookupType(
+ arg.TypeReference.GO,
+ ) + ")"
}
return strings.Join(args, ", ")
@@ -588,7 +669,7 @@ func (f *Field) CallArgs() string {
args := make([]string, 0, len(f.Args)+2)
if f.IsResolver {
- args = append(args, "rctx")
+ args = append(args, "ctx")
if !f.Object.Root {
args = append(args, "obj")
@@ -597,21 +678,100 @@ func (f *Field) CallArgs() string {
args = append(args, "ctx")
}
- for _, arg := range f.Args {
- tmp := "fc.Args[" + strconv.Quote(arg.Name) + "].(" + templates.CurrentImports.LookupType(arg.TypeReference.GO) + ")"
+ var inlineInfo *InlineArgsInfo
+ if f.Object != nil && f.Object.Definition != nil {
+ inlineInfo = GetInlineArgsMetadata(f.Object.Name, f.Name)
+ }
+ if inlineInfo != nil {
+ isMap := strings.Contains(inlineInfo.GoType, "map[")
- if iface, ok := arg.TypeReference.GO.(*types.Interface); ok && iface.Empty() {
- tmp = fmt.Sprintf(`
+ var entries []string
+ for _, argName := range inlineInfo.ExpandedArgs {
+ var argRef *FieldArgument
+ for _, arg := range f.Args {
+ if arg.Name == argName {
+ argRef = arg
+ break
+ }
+ }
+ if argRef != nil {
+ goType := templates.CurrentImports.LookupType(argRef.TypeReference.GO)
+ var entry string
+ if isMap {
+ entry = fmt.Sprintf("%q: fc.Args[%q].(%s)", argName, argName, goType)
+ } else {
+ fieldName := templates.ToGo(argName)
+ entry = fmt.Sprintf("%s: fc.Args[%q].(%s)", fieldName, argName, goType)
+ }
+ entries = append(entries, entry)
+ }
+ }
+
+ goType := formatGoType(inlineInfo.GoType)
+ bundled := fmt.Sprintf("%s{\n\t\t%s,\n\t}", goType, strings.Join(entries, ",\n\t\t"))
+ args = append(args, bundled)
+
+ for _, arg := range f.Args {
+ if !contains(inlineInfo.ExpandedArgs, arg.Name) {
+ tmp := "fc.Args[" + strconv.Quote(
+ arg.Name,
+ ) + "].(" + templates.CurrentImports.LookupType(
+ arg.TypeReference.GO,
+ ) + ")"
+
+ if iface, ok := arg.TypeReference.GO.(*types.Interface); ok && iface.Empty() {
+ tmp = fmt.Sprintf(`
func () any {
if fc.Args["%s"] == nil {
return nil
}
return fc.Args["%s"].(any)
}()`, arg.Name, arg.Name,
- )
- }
+ )
+ }
- args = append(args, tmp)
+ args = append(args, tmp)
+ }
+ }
+ } else {
+ for _, arg := range f.Args {
+ tmp := "fc.Args[" + strconv.Quote(arg.Name) + "].(" + templates.CurrentImports.LookupType(arg.TypeReference.GO) + ")"
+
+ if iface, ok := arg.TypeReference.GO.(*types.Interface); ok && iface.Empty() {
+ tmp = fmt.Sprintf(`
+ func () any {
+ if fc.Args["%s"] == nil {
+ return nil
+ }
+ return fc.Args["%s"].(any)
+ }()`, arg.Name, arg.Name,
+ )
+ }
+
+ args = append(args, tmp)
+ }
+ }
+
+ return strings.Join(args, ", ")
+}
+
+// StubCallArgs returns a comma-separated list of argument variable names for stub code.
+func (f *Field) StubCallArgs() string {
+ args := make([]string, 0, len(f.Args)+2)
+
+ inlineInfo := GetInlineArgsMetadata(f.Object.Name, f.Name)
+ if inlineInfo != nil {
+ args = append(args, inlineInfo.OriginalArgName)
+
+ for _, arg := range f.Args {
+ if !contains(inlineInfo.ExpandedArgs, arg.Name) {
+ args = append(args, arg.VarName)
+ }
+ }
+ } else {
+ for _, arg := range f.Args {
+ args = append(args, arg.VarName)
+ }
}
return strings.Join(args, ", ")
diff --git a/vendor/github.com/99designs/gqlgen/codegen/field.gotpl b/vendor/github.com/99designs/gqlgen/codegen/field.gotpl
index 1c7ba70a..09f3c32c 100644
--- a/vendor/github.com/99designs/gqlgen/codegen/field.gotpl
+++ b/vendor/github.com/99designs/gqlgen/codegen/field.gotpl
@@ -11,24 +11,26 @@ func (ec *executionContext) _{{$object.Name}}_{{$field.Name}}(ctx context.Contex
{{- if $object.Stream }}
{{- $null = "nil" }}
{{- end }}
- {{ if $useFunctionSyntaxForExecutionContext -}}
- fc, err := {{ $field.FieldContextFunc }}(ctx, ec, field)
- {{- else -}}
- fc, err := ec.{{ $field.FieldContextFunc }}(ctx, field)
- {{- end }}
- if err != nil {
- return {{ $null }}
- }
- ctx = graphql.WithFieldContext(ctx, fc)
- {{- if not $.Config.OmitPanicHandler }}
- defer func () {
- if r := recover(); r != nil {
- ec.Error(ctx, ec.Recover(ctx, r))
- ret = {{ $null }}
- }
- }()
- {{- end }}
+
{{- if $field.TypeReference.IsRoot }}
+ {{ if $useFunctionSyntaxForExecutionContext -}}
+ fc, err := {{ $field.FieldContextFunc }}(ctx, ec, field)
+ {{- else -}}
+ fc, err := ec.{{ $field.FieldContextFunc }}(ctx, field)
+ {{- end }}
+ if err != nil {
+ return {{ $null }}
+ }
+ ctx = graphql.WithFieldContext(ctx, fc)
+ {{- if not $.Config.OmitPanicHandler }}
+ defer func () {
+ if r := recover(); r != nil {
+ ec.Error(ctx, ec.Recover(ctx, r))
+ ret = {{ $null }}
+ }
+ }()
+ {{- end }}
+
{{- if $field.TypeReference.IsPtr }}
res := &{{ $field.TypeReference.Elem.GO | ref }}{}
{{- else }}
@@ -41,62 +43,46 @@ func (ec *executionContext) _{{$object.Name}}_{{$field.Name}}(ctx context.Contex
return ec.{{ $field.TypeReference.MarshalFunc }}(ctx, field.Selections, res)
{{- end }}
{{- else}}
- {{- if $.AllDirectives.LocationDirectives "FIELD" }}
+ return graphql.ResolveField{{- if $object.Stream }}Stream{{- end }}(
+ ctx,
+ ec.OperationContext,
+ field,
{{ if $useFunctionSyntaxForExecutionContext -}}
- resTmp := _fieldMiddleware(ctx, ec, {{if $object.Root}}nil{{else}}obj{{end}}, func(rctx context.Context) (any, error) {
+ func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { return {{ $field.FieldContextFunc }}(ctx, ec, field) },
{{- else -}}
- resTmp := ec._fieldMiddleware(ctx, {{if $object.Root}}nil{{else}}obj{{end}}, func(rctx context.Context) (any, error) {
+ ec.{{ $field.FieldContextFunc }},
{{- end }}
- {{ template "field" (dict "Field" $field "UseFunctionSyntaxForExecutionContext" $useFunctionSyntaxForExecutionContext) }}
- })
- {{ else }}
- resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (any, error) {
- {{ template "field" (dict "Field" $field "UseFunctionSyntaxForExecutionContext" $useFunctionSyntaxForExecutionContext) }}
- })
- if err != nil {
- ec.Error(ctx, err)
- return {{ $null }}
- }
- {{- end }}
- if resTmp == nil {
- {{- if $field.TypeReference.GQL.NonNull }}
- if !graphql.HasFieldError(ctx, fc) {
- ec.Errorf(ctx, "must not be null")
- }
- {{- end }}
- return {{ $null }}
- }
- {{- if $object.Stream }}
- return func(ctx context.Context) graphql.Marshaler {
- select {
- case res, ok := <-resTmp.(<-chan {{$field.TypeReference.GO | ref}}):
- if !ok {
- return nil
- }
- return graphql.WriterFunc(func(w io.Writer) {
- w.Write([]byte{'{'})
- graphql.MarshalString(field.Alias).MarshalGQL(w)
- w.Write([]byte{':'})
+ func(ctx context.Context) (any, error) {
+ {{- template "fieldDefinition" $field }}
+ },
+ {{if or ($.AllDirectives.LocationDirectives "FIELD") $field.HasDirectives -}}
+ func(ctx context.Context, next graphql.Resolver) graphql.Resolver {
+ {{- if $field.HasDirectives -}}
+ directive0 := next
+ {{ template "implDirectives" (dict "Field" $field "UseFunctionSyntaxForExecutionContext" $useFunctionSyntaxForExecutionContext) }}
+ next = directive{{$field.ImplDirectives|len}}
+ {{end}}
+ {{- if $.AllDirectives.LocationDirectives "FIELD" -}}
{{ if $useFunctionSyntaxForExecutionContext -}}
- {{ $field.TypeReference.MarshalFunc }}(ctx, ec, field.Selections, res).MarshalGQL(w)
+ return _fieldMiddleware(ctx, ec, {{if $object.Root}}nil{{else}}obj{{end}}, next)
{{- else -}}
- ec.{{ $field.TypeReference.MarshalFunc }}(ctx, field.Selections, res).MarshalGQL(w)
+ return ec._fieldMiddleware(ctx, {{if $object.Root}}nil{{else}}obj{{end}}, next)
{{- end }}
- w.Write([]byte{'}'})
- })
- case <-ctx.Done():
- return nil
- }
- }
- {{- else }}
- res := resTmp.({{$field.TypeReference.GO | ref}})
- fc.Result = res
+ {{- else -}}
+ return next
+ {{end -}}
+ },
+ {{else -}}
+ nil,
+ {{end -}}
{{ if $useFunctionSyntaxForExecutionContext -}}
- return {{ $field.TypeReference.MarshalFunc }}(ctx, ec, field.Selections, res)
+ func(ctx context.Context, selections ast.SelectionSet, v {{ $field.TypeReference.GO | ref }}) graphql.Marshaler { return {{ $field.TypeReference.MarshalFunc }}(ctx, ec, selections, v) },
{{- else -}}
- return ec.{{ $field.TypeReference.MarshalFunc }}(ctx, field.Selections, res)
+ ec.{{ $field.TypeReference.MarshalFunc }},
{{- end }}
- {{- end }}
+ {{ not $.Config.OmitPanicHandler }},
+ {{ $field.TypeReference.GQL.NonNull }},
+ )
{{- end }}
}
@@ -154,32 +140,12 @@ func (ec *executionContext) {{ $field.FieldContextFunc }}({{ if not $field.Args
{{- end }}{{- end}}
-{{ define "field" }}
- {{- $useFunctionSyntaxForExecutionContext := .UseFunctionSyntaxForExecutionContext -}}
- {{- if .Field.HasDirectives -}}
- directive0 := func(rctx context.Context) (any, error) {
- ctx = rctx // use context from middleware stack in children
- {{ template "fieldDefinition" .Field }}
- }
- {{ template "implDirectives" (dict "Field" .Field "UseFunctionSyntaxForExecutionContext" $useFunctionSyntaxForExecutionContext) }}
- tmp, err := directive{{.Field.ImplDirectives|len}}(rctx)
- if err != nil {
- return nil, graphql.ErrorOnPath(ctx, err)
- }
- if tmp == nil {
- return nil, nil
- }
- if data, ok := tmp.({{if .Field.Stream}}<-chan {{end}}{{ .Field.TypeReference.GO | ref }}) ; ok {
- return data, nil
- }
- return nil, fmt.Errorf(`unexpected type %T from directive, should be {{if .Field.Stream}}<-chan {{end}}{{ .Field.TypeReference.GO }}`, tmp)
- {{- else -}}
- ctx = rctx // use context from middleware stack in children
- {{ template "fieldDefinition" .Field }}
- {{- end -}}
-{{ end }}
-
{{ define "fieldDefinition" }}
+ {{- if or .IsResolver .IsMethod -}}
+ {{- if gt (len .Args) 0 -}}
+ fc := graphql.GetFieldContext(ctx)
+ {{- end }}
+ {{ end }}
{{- if .IsResolver -}}
return ec.resolvers.{{ .ShortInvocation }}
{{- else if .IsMap -}}
diff --git a/vendor/github.com/99designs/gqlgen/codegen/generated!.gotpl b/vendor/github.com/99designs/gqlgen/codegen/generated!.gotpl
index 9a6b9e10..b09d770e 100644
--- a/vendor/github.com/99designs/gqlgen/codegen/generated!.gotpl
+++ b/vendor/github.com/99designs/gqlgen/codegen/generated!.gotpl
@@ -145,7 +145,7 @@
}
{{ end }}
return e.complexity.{{ucFirst $object.Name}}.{{$field.GoFieldName}}(childComplexity{{if $field.Args}}, {{$field.ComplexityArgs}} {{ end }}), true
- {{ end }}
+ {{- end }}
{{- end }}
{{- end }}
{{ end }}
diff --git a/vendor/github.com/99designs/gqlgen/codegen/inline_arguments.go b/vendor/github.com/99designs/gqlgen/codegen/inline_arguments.go
new file mode 100644
index 00000000..e5c7b3a5
--- /dev/null
+++ b/vendor/github.com/99designs/gqlgen/codegen/inline_arguments.go
@@ -0,0 +1,156 @@
+package codegen
+
+import (
+ "bytes"
+ "fmt"
+
+ "github.com/vektah/gqlparser/v2/ast"
+ "github.com/vektah/gqlparser/v2/formatter"
+)
+
+// InlineArgsInfo stores metadata about arguments that were inlined.
+// Used during codegen to bundle expanded arguments back into a single resolver parameter.
+type InlineArgsInfo struct {
+ OriginalArgName string
+ OriginalType string
+ OriginalASTType *ast.Type
+ GoType string
+ ExpandedArgs []string
+}
+
+// inlineArgsMetadata maps "TypeName.FieldName" to inline args metadata.
+var inlineArgsMetadata = make(map[string]*InlineArgsInfo)
+
+// ExpandInlineArguments expands arguments marked with @inlineArguments
+// and stores metadata for later codegen phase.
+func ExpandInlineArguments(schema *ast.Schema) error {
+ for typeName, typeDef := range schema.Types {
+ if typeDef.Kind != ast.Object && typeDef.Kind != ast.Interface {
+ continue
+ }
+
+ for _, field := range typeDef.Fields {
+ var inlinedIndices []int
+ var expandedArguments [][]*ast.ArgumentDefinition
+
+ for i, arg := range field.Arguments {
+ if arg.Directives.ForName("inlineArguments") == nil {
+ continue
+ }
+
+ argTypeName := arg.Type.Name()
+ inputType := schema.Types[argTypeName]
+ if inputType == nil {
+ return fmt.Errorf(
+ "@inlineArguments on %s.%s(%s): type %s not found in schema",
+ typeName, field.Name, arg.Name, argTypeName,
+ )
+ }
+
+ if inputType.Kind != ast.InputObject {
+ return fmt.Errorf(
+ "@inlineArguments on %s.%s(%s): type %s must be an INPUT_OBJECT (input types only), got %s. The directive can only expand input object types into individual arguments",
+ typeName,
+ field.Name,
+ arg.Name,
+ argTypeName,
+ inputType.Kind,
+ )
+ }
+
+ var expanded []*ast.ArgumentDefinition
+ var expandedNames []string
+
+ for _, inputField := range inputType.Fields {
+ expandedArg := &ast.ArgumentDefinition{
+ Name: inputField.Name,
+ Type: inputField.Type,
+ Description: inputField.Description,
+ DefaultValue: inputField.DefaultValue,
+ Directives: inputField.Directives,
+ Position: inputField.Position,
+ }
+ expanded = append(expanded, expandedArg)
+ expandedNames = append(expandedNames, inputField.Name)
+ }
+
+ goType := argTypeName
+ if goModelDir := inputType.Directives.ForName("goModel"); goModelDir != nil {
+ if modelArg := goModelDir.Arguments.ForName("model"); modelArg != nil {
+ if modelValue, err := modelArg.Value.Value(nil); err == nil {
+ goType = modelValue.(string)
+ }
+ }
+ }
+
+ key := fmt.Sprintf("%s.%s", typeName, field.Name)
+ inlineArgsMetadata[key] = &InlineArgsInfo{
+ OriginalArgName: arg.Name,
+ OriginalType: argTypeName,
+ OriginalASTType: arg.Type,
+ GoType: goType,
+ ExpandedArgs: expandedNames,
+ }
+
+ inlinedIndices = append(inlinedIndices, i)
+ expandedArguments = append(expandedArguments, expanded)
+ }
+
+ if len(inlinedIndices) > 0 {
+ var newArgs ast.ArgumentDefinitionList
+
+ for i, arg := range field.Arguments {
+ inlinedIdx := -1
+ for idx, inlined := range inlinedIndices {
+ if inlined == i {
+ inlinedIdx = idx
+ break
+ }
+ }
+
+ if inlinedIdx >= 0 {
+ newArgs = append(newArgs, expandedArguments[inlinedIdx]...)
+ } else {
+ newArgs = append(newArgs, arg)
+ }
+ }
+
+ field.Arguments = newArgs
+ }
+ }
+ }
+
+ return nil
+}
+
+// GetInlineArgsMetadata retrieves metadata for a given type and field.
+func GetInlineArgsMetadata(typeName, fieldName string) *InlineArgsInfo {
+ key := fmt.Sprintf("%s.%s", typeName, fieldName)
+ return inlineArgsMetadata[key]
+}
+
+// ClearInlineArgsMetadata clears all stored metadata.
+func ClearInlineArgsMetadata() {
+ inlineArgsMetadata = make(map[string]*InlineArgsInfo)
+}
+
+func SerializeTransformedSchema(
+ schema *ast.Schema,
+ originalSources []*ast.Source,
+) ([]*ast.Source, error) {
+ if len(inlineArgsMetadata) == 0 {
+ return originalSources, nil
+ }
+
+ var buf bytes.Buffer
+ f := formatter.NewFormatter(&buf)
+ f.FormatSchema(schema)
+
+ return []*ast.Source{
+ {
+ Name: "inline_arguments_transformed_schema.graphql",
+ Input: buf.String(),
+ BuiltIn: true,
+ },
+ }, nil
+}
diff --git a/vendor/github.com/99designs/gqlgen/codegen/interface.go b/vendor/github.com/99designs/gqlgen/codegen/interface.go
index 729e93f0..1f7c7e05 100644
--- a/vendor/github.com/99designs/gqlgen/codegen/interface.go
+++ b/vendor/github.com/99designs/gqlgen/codegen/interface.go
@@ -89,7 +89,11 @@ func (b *builder) buildInterface(typ *ast.Definition) (*Interface, error) {
}
if !anyValid {
- return nil, fmt.Errorf("%s does not satisfy the interface %s", implementorType.String(), i.Type.String())
+ return nil, fmt.Errorf(
+ "%s does not satisfy the interface %s",
+ implementorType.String(),
+ i.Type.String(),
+ )
}
}
diff --git a/vendor/github.com/99designs/gqlgen/codegen/object.go b/vendor/github.com/99designs/gqlgen/codegen/object.go
index 81dce31e..6b1cb9ff 100644
--- a/vendor/github.com/99designs/gqlgen/codegen/object.go
+++ b/vendor/github.com/99designs/gqlgen/codegen/object.go
@@ -97,9 +97,11 @@ type Objects []*Object
func (o *Object) Implementors() string {
satisfiedBy := strconv.Quote(o.Name)
+ var satisfiedBySb100 strings.Builder
for _, s := range o.Implements {
- satisfiedBy += ", " + strconv.Quote(s.Name)
+ satisfiedBySb100.WriteString(", " + strconv.Quote(s.Name))
}
+ satisfiedBy += satisfiedBySb100.String()
return "[]string{" + satisfiedBy + "}"
}
diff --git a/vendor/github.com/99designs/gqlgen/codegen/object.gotpl b/vendor/github.com/99designs/gqlgen/codegen/object.gotpl
index f42d3574..dd6f8a68 100644
--- a/vendor/github.com/99designs/gqlgen/codegen/object.gotpl
+++ b/vendor/github.com/99designs/gqlgen/codegen/object.gotpl
@@ -15,7 +15,7 @@ func (ec *executionContext) _{{$object.Name}}(ctx context.Context, sel ast.Selec
Object: {{$object.Name|quote}},
})
if len(fields) != 1 {
- ec.Errorf(ctx, "must subscribe to exactly one stream")
+ graphql.AddErrorf(ctx, "must subscribe to exactly one stream")
return nil
}
diff --git a/vendor/github.com/99designs/gqlgen/codegen/templates/import.go b/vendor/github.com/99designs/gqlgen/codegen/templates/import.go
index c26bdeab..512e5960 100644
--- a/vendor/github.com/99designs/gqlgen/codegen/templates/import.go
+++ b/vendor/github.com/99designs/gqlgen/codegen/templates/import.go
@@ -32,12 +32,14 @@ func (i *Import) String() string {
func (s *Imports) String() string {
res := ""
+ var resSb35 strings.Builder
for i, imp := range s.imports {
if i != 0 {
- res += "\n"
+ resSb35.WriteString("\n")
}
- res += imp.String()
+ resSb35.WriteString(imp.String())
}
+ res += resSb35.String()
return res
}
diff --git a/vendor/github.com/99designs/gqlgen/codegen/templates/templates.go b/vendor/github.com/99designs/gqlgen/codegen/templates/templates.go
index f5d6c639..2c8417d6 100644
--- a/vendor/github.com/99designs/gqlgen/codegen/templates/templates.go
+++ b/vendor/github.com/99designs/gqlgen/codegen/templates/templates.go
@@ -22,8 +22,9 @@ import (
"github.com/99designs/gqlgen/internal/imports"
)
-// CurrentImports keeps track of all the import declarations that are needed during the execution of a plugin.
-// this is done with a global because subtemplates currently get called in functions. Lets aim to remove this eventually.
+// CurrentImports keeps track of all the import declarations that are needed during the execution of
+// a plugin. this is done with a global because subtemplates currently get called in functions. Lets
+// aim to remove this eventually.
var CurrentImports *Imports
// Options specify various parameters to rendering a template.
@@ -542,7 +543,9 @@ func wordWalker(str string, f func(*wordInfo)) {
// do NOT count this as an initialism.
switch upperWord {
case "ID", "IP":
- if remainingRunes := runes[w:]; word == string(remainingRunes[:2]) && !eow && len(remainingRunes) > 3 && unicode.IsUpper(remainingRunes[3]) {
+ if remainingRunes := runes[w:]; word == string(remainingRunes[:2]) && !eow &&
+ len(remainingRunes) > 3 &&
+ unicode.IsUpper(remainingRunes[3]) {
continue
}
}
@@ -811,7 +814,8 @@ var CommonInitialisms = map[string]bool{
"GCP": true,
}
-// GetInitialisms returns the initialisms to capitalize in Go names. If unchanged, default initialisms will be returned
+// GetInitialisms returns the initialisms to capitalize in Go names. If unchanged, default
+// initialisms will be returned
var GetInitialisms = func() map[string]bool {
return CommonInitialisms
}
diff --git a/vendor/github.com/99designs/gqlgen/codegen/type.go b/vendor/github.com/99designs/gqlgen/codegen/type.go
index dcd9d291..c35fdb9c 100644
--- a/vendor/github.com/99designs/gqlgen/codegen/type.go
+++ b/vendor/github.com/99designs/gqlgen/codegen/type.go
@@ -21,7 +21,14 @@ func processType(ret map[string]*config.TypeReference, ref *config.TypeReference
existingGQL := fmt.Sprintf("%v", existing.GQL)
newGQL := fmt.Sprintf("%v", ref.GQL)
if existingGQL != newGQL {
- panic(fmt.Sprintf("non-unique key \"%s\", trying to replace %s with %s", key, existingGQL, newGQL))
+ panic(
+ fmt.Sprintf(
+ "non-unique key \"%s\", trying to replace %s with %s",
+ key,
+ existingGQL,
+ newGQL,
+ ),
+ )
}
}
ret[key] = ref
diff --git a/vendor/github.com/99designs/gqlgen/codegen/type.gotpl b/vendor/github.com/99designs/gqlgen/codegen/type.gotpl
index 16521016..78e60b2f 100644
--- a/vendor/github.com/99designs/gqlgen/codegen/type.gotpl
+++ b/vendor/github.com/99designs/gqlgen/codegen/type.gotpl
@@ -217,7 +217,7 @@
if v == nil {
{{- if $type.GQL.NonNull }}
if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
- ec.Errorf(ctx, "the requested element is null which the schema does not allow")
+ graphql.AddErrorf(ctx, "the requested element is null which the schema does not allow")
}
{{- end }}
return graphql.Null
@@ -253,7 +253,7 @@
{{- if $type.GQL.NonNull }}
if res == graphql.Null {
if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
- ec.Errorf(ctx, "the requested element is null which the schema does not allow")
+ graphql.AddErrorf(ctx, "the requested element is null which the schema does not allow")
}
}
{{- end }}
@@ -288,7 +288,7 @@
}
{{- end }}
- {{- if $type.HasEnumValues }}
+ {{- if and $type.HasEnumValues (not $type.IsSlice) }}
{{- $enum := $type.GO }}
{{- if $type.IsNilable }}
{{- $enum = $type.GO.Elem }}
diff --git a/vendor/github.com/99designs/gqlgen/codegen/util.go b/vendor/github.com/99designs/gqlgen/codegen/util.go
index f3b2d5f9..2b682053 100644
--- a/vendor/github.com/99designs/gqlgen/codegen/util.go
+++ b/vendor/github.com/99designs/gqlgen/codegen/util.go
@@ -14,7 +14,11 @@ func findGoNamedType(def types.Type) (*types.Named, error) {
namedType, ok := def.(*types.Named)
//nolint:staticcheck // yes, it is bad to end in newline here
if !ok {
- return nil, fmt.Errorf("expected %s to be a named type, instead found %T\n", def.String(), def)
+ return nil, fmt.Errorf(
+ "expected %s to be a named type, instead found %T\n",
+ def.String(),
+ def,
+ )
}
return namedType, nil
@@ -34,7 +38,11 @@ func findGoInterface(def types.Type) (*types.Interface, error) {
underlying, ok := namedType.Underlying().(*types.Interface)
if !ok {
- return nil, fmt.Errorf("expected %s to be a named interface, instead found %s", def.String(), namedType.String())
+ return nil, fmt.Errorf(
+ "expected %s to be a named interface, instead found %s",
+ def.String(),
+ namedType.String(),
+ )
}
return underlying, nil
diff --git a/vendor/github.com/99designs/gqlgen/complexity/complexity.go b/vendor/github.com/99designs/gqlgen/complexity/complexity.go
index 3e88413a..3bebfb50 100644
--- a/vendor/github.com/99designs/gqlgen/complexity/complexity.go
+++ b/vendor/github.com/99designs/gqlgen/complexity/complexity.go
@@ -8,7 +8,12 @@ import (
"github.com/99designs/gqlgen/graphql"
)
-func Calculate(ctx context.Context, es graphql.ExecutableSchema, op *ast.OperationDefinition, vars map[string]any) int {
+func Calculate(
+ ctx context.Context,
+ es graphql.ExecutableSchema,
+ op *ast.OperationDefinition,
+ vars map[string]any,
+) int {
walker := complexityWalker{
es: es,
schema: es.Schema(),
@@ -23,7 +28,10 @@ type complexityWalker struct {
vars map[string]any
}
-func (cw complexityWalker) selectionSetComplexity(ctx context.Context, selectionSet ast.SelectionSet) int {
+func (cw complexityWalker) selectionSetComplexity(
+ ctx context.Context,
+ selectionSet ast.SelectionSet,
+) int {
var complexity int
for _, selection := range selectionSet {
switch s := selection.(type) {
@@ -59,7 +67,13 @@ func (cw complexityWalker) selectionSetComplexity(ctx context.Context, selection
return complexity
}
-func (cw complexityWalker) interfaceFieldComplexity(ctx context.Context, def *ast.Definition, field string, childComplexity int, args map[string]any) int {
+func (cw complexityWalker) interfaceFieldComplexity(
+ ctx context.Context,
+ def *ast.Definition,
+ field string,
+ childComplexity int,
+ args map[string]any,
+) int {
// Interfaces don't have their own separate field costs, so they have to assume the worst case.
// We iterate over all implementors and choose the most expensive one.
maxComplexity := 0
@@ -73,8 +87,14 @@ func (cw complexityWalker) interfaceFieldComplexity(ctx context.Context, def *as
return maxComplexity
}
-func (cw complexityWalker) fieldComplexity(ctx context.Context, object, field string, childComplexity int, args map[string]any) int {
- if customComplexity, ok := cw.es.Complexity(ctx, object, field, childComplexity, args); ok && customComplexity >= childComplexity {
+func (cw complexityWalker) fieldComplexity(
+ ctx context.Context,
+ object, field string,
+ childComplexity int,
+ args map[string]any,
+) int {
+ if customComplexity, ok := cw.es.Complexity(ctx, object, field, childComplexity, args); ok &&
+ customComplexity >= 1 {
return customComplexity
}
// default complexity calculation
diff --git a/vendor/github.com/99designs/gqlgen/graphql/args.go b/vendor/github.com/99designs/gqlgen/graphql/args.go
new file mode 100644
index 00000000..0638da37
--- /dev/null
+++ b/vendor/github.com/99designs/gqlgen/graphql/args.go
@@ -0,0 +1,42 @@
+package graphql
+
+import (
+ "context"
+)
+
+// ProcessArgField Parses argument value without Execution Context
+// This function is called from generated code
+func ProcessArgField[T any](
+ ctx context.Context,
+ rawArgs map[string]any,
+ fieldName string,
+ valueMapperFn func(ctx context.Context, value any) (T, error),
+) (T, error) {
+ value, exists := rawArgs[fieldName]
+ if !exists {
+ var zeroVal T
+ return zeroVal, nil
+ }
+
+ ctx = WithPathContext(ctx, NewPathWithField(fieldName))
+ return valueMapperFn(ctx, value)
+}
+
+// ProcessArgFieldWithEC Parses argument value with Execution Context
+// This function is called from generated code
+func ProcessArgFieldWithEC[T, EC any](
+ ctx context.Context,
+ ec EC,
+ rawArgs map[string]any,
+ fieldName string,
+ valueMapperFn func(ctx context.Context, ec EC, value any) (T, error),
+) (T, error) {
+ value, exists := rawArgs[fieldName]
+ if !exists {
+ var zeroVal T
+ return zeroVal, nil
+ }
+
+ ctx = WithPathContext(ctx, NewPathWithField(fieldName))
+ return valueMapperFn(ctx, ec, value)
+}
diff --git a/vendor/github.com/99designs/gqlgen/graphql/cache.go b/vendor/github.com/99designs/gqlgen/graphql/cache.go
index 836d9868..6eb4dc9e 100644
--- a/vendor/github.com/99designs/gqlgen/graphql/cache.go
+++ b/vendor/github.com/99designs/gqlgen/graphql/cache.go
@@ -11,7 +11,8 @@ type Cache[T any] interface {
Add(ctx context.Context, key string, value T)
}
-// MapCache is the simplest implementation of a cache, because it can not evict it should only be used in tests
+// MapCache is the simplest implementation of a cache, because it can not evict it should only be
+// used in tests
type MapCache[T any] map[string]T
// Get looks up a key's value from the cache.
diff --git a/vendor/github.com/99designs/gqlgen/graphql/collect_fields_cache_store.go b/vendor/github.com/99designs/gqlgen/graphql/collect_fields_cache_store.go
new file mode 100644
index 00000000..69dc7974
--- /dev/null
+++ b/vendor/github.com/99designs/gqlgen/graphql/collect_fields_cache_store.go
@@ -0,0 +1,79 @@
+package graphql
+
+import (
+ "hash/fnv"
+ "reflect"
+ "sync"
+
+ "github.com/vektah/gqlparser/v2/ast"
+)
+
+// collectFieldsCacheKey is the cache key for CollectFields results.
+type collectFieldsCacheKey struct {
+ selectionPtr uintptr // Pointer to the underlying SelectionSet data
+ selectionLen int // Length of the selection set
+ satisfiesHash uint64 // Hash of the satisfies array
+}
+
+// collectFieldsCacheStore manages CollectFields cache entries safely.
+type collectFieldsCacheStore struct {
+ mu sync.RWMutex
+ items map[collectFieldsCacheKey][]CollectedField
+}
+
+// Get returns the cached result for the key if present.
+func (s *collectFieldsCacheStore) Get(key collectFieldsCacheKey) ([]CollectedField, bool) {
+ s.mu.RLock()
+ defer s.mu.RUnlock()
+ if s.items == nil {
+ return nil, false
+ }
+ val, ok := s.items[key]
+ return val, ok
+}
+
+// Add stores the value when absent and returns the cached value.
+func (s *collectFieldsCacheStore) Add(
+ key collectFieldsCacheKey,
+ value []CollectedField,
+) []CollectedField {
+ s.mu.Lock()
+ defer s.mu.Unlock()
+
+ if s.items == nil {
+ s.items = make(map[collectFieldsCacheKey][]CollectedField)
+ }
+
+ if existing, ok := s.items[key]; ok {
+ return existing
+ }
+ s.items[key] = value
+ return value
+}
+
+// Len returns the number of cached entries.
+func (s *collectFieldsCacheStore) Len() int {
+ s.mu.RLock()
+ defer s.mu.RUnlock()
+ return len(s.items)
+}
+
+// makeCollectFieldsCacheKey generates a cache key for CollectFields.
+func makeCollectFieldsCacheKey(selSet ast.SelectionSet, satisfies []string) collectFieldsCacheKey {
+ var selectionPtr uintptr
+ if selSet != nil {
+ selectionPtr = reflect.ValueOf(selSet).Pointer()
+ }
+
+ h := fnv.New64a()
+ for _, s := range satisfies {
+ h.Write([]byte(s))
+ h.Write([]byte{0})
+ }
+
+ return collectFieldsCacheKey{
+ selectionPtr: selectionPtr,
+ selectionLen: len(selSet),
+ satisfiesHash: h.Sum64(),
+ }
+}
diff --git a/vendor/github.com/99designs/gqlgen/graphql/context_field.go b/vendor/github.com/99designs/gqlgen/graphql/context_field.go
index dbb8d9e9..b1d18e2f 100644
--- a/vendor/github.com/99designs/gqlgen/graphql/context_field.go
+++ b/vendor/github.com/99designs/gqlgen/graphql/context_field.go
@@ -18,7 +18,8 @@ type FieldContext struct {
Parent *FieldContext
// The name of the type this field belongs to
Object string
- // These are the args after processing, they can be mutated in middleware to change what the resolver will get.
+ // These are the args after processing, they can be mutated in middleware to change what the
+ // resolver will get.
Args map[string]any
// The raw field
Field CollectedField
diff --git a/vendor/github.com/99designs/gqlgen/graphql/context_operation.go b/vendor/github.com/99designs/gqlgen/graphql/context_operation.go
index 696ac1e7..e25fa6ba 100644
--- a/vendor/github.com/99designs/gqlgen/graphql/context_operation.go
+++ b/vendor/github.com/99designs/gqlgen/graphql/context_operation.go
@@ -27,6 +27,8 @@ type OperationContext struct {
RootResolverMiddleware RootFieldMiddleware
Stats Stats
+
+ collectFieldsCache collectFieldsCacheStore
}
func (c *OperationContext) Validate(ctx context.Context) error {
@@ -84,8 +86,9 @@ func CollectFieldsCtx(ctx context.Context, satisfies []string) []CollectedField
return CollectFields(GetOperationContext(ctx), resctx.Field.Selections, satisfies)
}
-// CollectAllFields returns a slice of all GraphQL field names that were selected for the current resolver context.
-// The slice will contain the unique set of all field names requested regardless of fragment type conditions.
+// CollectAllFields returns a slice of all GraphQL field names that were selected for the current
+// resolver context. The slice will contain the unique set of all field names requested regardless
+// of fragment type conditions.
func CollectAllFields(ctx context.Context) []string {
resctx := GetFieldContext(ctx)
collected := CollectFields(GetOperationContext(ctx), resctx.Field.Selections, nil)
@@ -103,6 +106,7 @@ Next:
}
// Errorf sends an error string to the client, passing it through the formatter.
+//
// Deprecated: use graphql.AddErrorf(ctx, err) instead
func (c *OperationContext) Errorf(ctx context.Context, format string, args ...any) {
AddErrorf(ctx, format, args...)
diff --git a/vendor/github.com/99designs/gqlgen/graphql/context_response.go b/vendor/github.com/99designs/gqlgen/graphql/context_response.go
index 340a4048..3931f511 100644
--- a/vendor/github.com/99designs/gqlgen/graphql/context_response.go
+++ b/vendor/github.com/99designs/gqlgen/graphql/context_response.go
@@ -29,7 +29,11 @@ func getResponseContext(ctx context.Context) *responseContext {
return val
}
-func WithResponseContext(ctx context.Context, presenterFunc ErrorPresenterFunc, recoverFunc RecoverFunc) context.Context {
+func WithResponseContext(
+ ctx context.Context,
+ presenterFunc ErrorPresenterFunc,
+ recoverFunc RecoverFunc,
+) context.Context {
return context.WithValue(ctx, resultCtx, &responseContext{
errorPresenter: presenterFunc,
recover: recoverFunc,
@@ -57,6 +61,9 @@ func AddError(ctx context.Context, err error) {
c := getResponseContext(ctx)
presentedError := c.errorPresenter(ctx, ErrorOnPath(ctx, err))
+ if presentedError == nil {
+ return
+ }
c.errorsMu.Lock()
defer c.errorsMu.Unlock()
diff --git a/vendor/github.com/99designs/gqlgen/graphql/duration.go b/vendor/github.com/99designs/gqlgen/graphql/duration.go
index bf2b5647..be84b5a4 100644
--- a/vendor/github.com/99designs/gqlgen/graphql/duration.go
+++ b/vendor/github.com/99designs/gqlgen/graphql/duration.go
@@ -8,6 +8,18 @@ import (
)
// UnmarshalDuration returns the duration from a string in ISO8601 format
+// PnDTnHnMn.nS with days considered to be exactly 24 hours.
+// See https://en.wikipedia.org/wiki/ISO_8601#Durations
+// P - Period
+// D - D is the
+// T - T is the time designator that precedes the time components
+// H - H is the hour designator that follows the value for the number of hours.
+// M - M is the minute designator that follows the value for the number of minutes.
+// S - S is the second designator that follows the value for the number of seconds.
+// "PT20.345S" -- parses as "20.345 seconds"
+// "PT15M" -- parses as "15 minutes" (where a minute is 60 seconds)
+// "PT10H" -- parses as "10 hours" (where an hour is 3600 seconds)
+// "P2D" -- parses as "2 days" (where a day is 24 hours or 86400 seconds)
func UnmarshalDuration(v any) (time.Duration, error) {
input, ok := v.(string)
if !ok {
@@ -21,7 +33,19 @@ func UnmarshalDuration(v any) (time.Duration, error) {
return d2.ToTimeDuration(), nil
}
-// MarshalDuration returns the duration on ISO8601 format
+// MarshalDuration returns the duration in ISO8601 format
+// PnDTnHnMn.nS with days considered to be exactly 24 hours.
+// See https://en.wikipedia.org/wiki/ISO_8601#Durations
+// P - Period
+// D - D is the
+// T - T is the time designator that precedes the time components
+// H - H is the hour designator that follows the value for the number of hours.
+// M - M is the minute designator that follows the value for the number of minutes.
+// S - S is the second designator that follows the value for the number of seconds.
+// "PT20.345S" -- parses as "20.345 seconds"
+// "PT15M" -- parses as "15 minutes" (where a minute is 60 seconds)
+// "PT10H" -- parses as "10 hours" (where an hour is 3600 seconds)
+// "P2D" -- parses as "2 days" (where a day is 24 hours or 86400 seconds)
func MarshalDuration(d time.Duration) Marshaler {
return MarshalString(dur.Format(d))
}
diff --git a/vendor/github.com/99designs/gqlgen/graphql/executable_schema.go b/vendor/github.com/99designs/gqlgen/graphql/executable_schema.go
index 4870e4fc..1cb8b473 100644
--- a/vendor/github.com/99designs/gqlgen/graphql/executable_schema.go
+++ b/vendor/github.com/99designs/gqlgen/graphql/executable_schema.go
@@ -12,17 +12,40 @@ import (
type ExecutableSchema interface {
Schema() *ast.Schema
- Complexity(ctx context.Context, typeName, fieldName string, childComplexity int, args map[string]any) (int, bool)
+ Complexity(
+ ctx context.Context,
+ typeName, fieldName string,
+ childComplexity int,
+ args map[string]any,
+ ) (int, bool)
Exec(ctx context.Context) ResponseHandler
}
-// CollectFields returns the set of fields from an ast.SelectionSet where all collected fields satisfy at least one of the GraphQL types
-// passed through satisfies. Providing an empty slice for satisfies will collect all fields regardless of fragment type conditions.
-func CollectFields(reqCtx *OperationContext, selSet ast.SelectionSet, satisfies []string) []CollectedField {
- return collectFields(reqCtx, selSet, satisfies, map[string]bool{})
+// CollectFields returns the set of fields from an ast.SelectionSet where all collected fields
+// satisfy at least one of the GraphQL types passed through satisfies. Providing an empty slice for
+// satisfies will collect all fields regardless of fragment type conditions.
+func CollectFields(
+ reqCtx *OperationContext,
+ selSet ast.SelectionSet,
+ satisfies []string,
+) []CollectedField {
+ cacheKey := makeCollectFieldsCacheKey(selSet, satisfies)
+
+ if cached, ok := reqCtx.collectFieldsCache.Get(cacheKey); ok {
+ return cached
+ }
+
+ result := collectFields(reqCtx, selSet, satisfies, map[string]bool{})
+
+ return reqCtx.collectFieldsCache.Add(cacheKey, result)
}
-func collectFields(reqCtx *OperationContext, selSet ast.SelectionSet, satisfies []string, visited map[string]bool) []CollectedField {
+func collectFields(
+ reqCtx *OperationContext,
+ selSet ast.SelectionSet,
+ satisfies []string,
+ visited map[string]bool,
+) []CollectedField {
groupedFields := make([]CollectedField, 0, len(selSet))
for _, sel := range selSet {
@@ -127,7 +150,12 @@ func doesFragmentConditionMatch(typeCondition string, satisfies []string) bool {
return false
}
-func getOrCreateAndAppendField(c *[]CollectedField, name, alias string, objectDefinition *ast.Definition, creator func() CollectedField) *CollectedField {
+func getOrCreateAndAppendField(
+ c *[]CollectedField,
+ name, alias string,
+ objectDefinition *ast.Definition,
+ creator func() CollectedField,
+) *CollectedField {
for i, cf := range *c {
if cf.Name == name && cf.Alias == alias {
if cf.ObjectDefinition == objectDefinition {
@@ -179,7 +207,10 @@ func shouldIncludeNode(directives ast.DirectiveList, variables map[string]any) b
return !skip && include
}
-func deferrable(directives ast.DirectiveList, variables map[string]any) (shouldDefer bool, label string) {
+func deferrable(
+ directives ast.DirectiveList,
+ variables map[string]any,
+) (shouldDefer bool, label string) {
d := directives.ForName("defer")
if d == nil {
return false, ""
diff --git a/vendor/github.com/99designs/gqlgen/graphql/executor/executor.go b/vendor/github.com/99designs/gqlgen/graphql/executor/executor.go
index 95302f91..c9769664 100644
--- a/vendor/github.com/99designs/gqlgen/graphql/executor/executor.go
+++ b/vendor/github.com/99designs/gqlgen/graphql/executor/executor.go
@@ -27,6 +27,7 @@ type Executor struct {
parserTokenLimit int
disableSuggestion bool
+ defaultRulesFn func() *rules.Rules
}
var _ graphql.GraphExecutor = &Executor{}
@@ -45,6 +46,11 @@ func New(es graphql.ExecutableSchema) *Executor {
return e
}
+// SetDefaultRulesFn is to customize the Default GraphQL Validation Rules
+func (e *Executor) SetDefaultRulesFn(f func() *rules.Rules) {
+ e.defaultRulesFn = f
+}
+
func (e *Executor) CreateOperationContext(
ctx context.Context,
params *graphql.RawParams,
@@ -86,7 +92,11 @@ func (e *Executor) CreateOperationContext(
}
var err error
- opCtx.Variables, err = validator.VariableValues(e.es.Schema(), opCtx.Operation, params.Variables)
+ opCtx.Variables, err = validator.VariableValues(
+ e.es.Schema(),
+ opCtx.Operation,
+ params.Variables,
+ )
if err != nil {
gqlErr, ok := err.(*gqlerror.Error)
if ok {
@@ -109,10 +119,9 @@ func (e *Executor) DispatchOperation(
ctx context.Context,
opCtx *graphql.OperationContext,
) (graphql.ResponseHandler, context.Context) {
- ctx = graphql.WithOperationContext(ctx, opCtx)
+ innerCtx := graphql.WithOperationContext(ctx, opCtx)
- var innerCtx context.Context
- res := e.ext.operationMiddleware(ctx, func(ctx context.Context) graphql.ResponseHandler {
+ res := e.ext.operationMiddleware(innerCtx, func(ctx context.Context) graphql.ResponseHandler {
innerCtx = ctx
tmpResponseContext := graphql.WithResponseContext(ctx, e.errorPresenter, e.recoverFunc)
@@ -223,8 +232,12 @@ func (e *Executor) parseQuery(
return nil, gqlerror.List{gqlErr}
}
- currentRules := rules.NewDefaultRules()
-
+ var currentRules *rules.Rules
+ if e.defaultRulesFn == nil {
+ currentRules = rules.NewDefaultRules()
+ } else {
+ currentRules = e.defaultRulesFn()
+ }
// Customise rules as required
// TODO(steve): consider currentRules.RemoveRule(rules.MaxIntrospectionDepth.Name)
diff --git a/vendor/github.com/99designs/gqlgen/graphql/executor/extensions.go b/vendor/github.com/99designs/gqlgen/graphql/executor/extensions.go
index 758d8e4e..8b374995 100644
--- a/vendor/github.com/99designs/gqlgen/graphql/executor/extensions.go
+++ b/vendor/github.com/99designs/gqlgen/graphql/executor/extensions.go
@@ -29,22 +29,26 @@ func (e *Executor) Use(extension graphql.HandlerExtension) {
}
}
-// AroundFields is a convenience method for creating an extension that only implements field middleware
+// AroundFields is a convenience method for creating an extension that only implements field
+// middleware
func (e *Executor) AroundFields(f graphql.FieldMiddleware) {
e.Use(aroundFieldFunc(f))
}
-// AroundRootFields is a convenience method for creating an extension that only implements root field middleware
+// AroundRootFields is a convenience method for creating an extension that only implements root
+// field middleware
func (e *Executor) AroundRootFields(f graphql.RootFieldMiddleware) {
e.Use(aroundRootFieldFunc(f))
}
-// AroundOperations is a convenience method for creating an extension that only implements operation middleware
+// AroundOperations is a convenience method for creating an extension that only implements operation
+// middleware
func (e *Executor) AroundOperations(f graphql.OperationMiddleware) {
e.Use(aroundOpFunc(f))
}
-// AroundResponses is a convenience method for creating an extension that only implements response middleware
+// AroundResponses is a convenience method for creating an extension that only implements response
+// middleware
func (e *Executor) AroundResponses(f graphql.ResponseMiddleware) {
e.Use(aroundRespFunc(f))
}
@@ -140,7 +144,10 @@ func (r aroundOpFunc) Validate(schema graphql.ExecutableSchema) error {
return nil
}
-func (r aroundOpFunc) InterceptOperation(ctx context.Context, next graphql.OperationHandler) graphql.ResponseHandler {
+func (r aroundOpFunc) InterceptOperation(
+ ctx context.Context,
+ next graphql.OperationHandler,
+) graphql.ResponseHandler {
return r(ctx, next)
}
@@ -157,7 +164,10 @@ func (r aroundRespFunc) Validate(schema graphql.ExecutableSchema) error {
return nil
}
-func (r aroundRespFunc) InterceptResponse(ctx context.Context, next graphql.ResponseHandler) *graphql.Response {
+func (r aroundRespFunc) InterceptResponse(
+ ctx context.Context,
+ next graphql.ResponseHandler,
+) *graphql.Response {
return r(ctx, next)
}
@@ -174,7 +184,10 @@ func (f aroundFieldFunc) Validate(schema graphql.ExecutableSchema) error {
return nil
}
-func (f aroundFieldFunc) InterceptField(ctx context.Context, next graphql.Resolver) (res any, err error) {
+func (f aroundFieldFunc) InterceptField(
+ ctx context.Context,
+ next graphql.Resolver,
+) (res any, err error) {
return f(ctx, next)
}
@@ -191,6 +204,9 @@ func (f aroundRootFieldFunc) Validate(schema graphql.ExecutableSchema) error {
return nil
}
-func (f aroundRootFieldFunc) InterceptRootField(ctx context.Context, next graphql.RootResolver) graphql.Marshaler {
+func (f aroundRootFieldFunc) InterceptRootField(
+ ctx context.Context,
+ next graphql.RootResolver,
+) graphql.Marshaler {
return f(ctx, next)
}
diff --git a/vendor/github.com/99designs/gqlgen/graphql/fieldset.go b/vendor/github.com/99designs/gqlgen/graphql/fieldset.go
index 73c048dc..17ed5389 100644
--- a/vendor/github.com/99designs/gqlgen/graphql/fieldset.go
+++ b/vendor/github.com/99designs/gqlgen/graphql/fieldset.go
@@ -40,7 +40,8 @@ func (m *FieldSet) Dispatch(ctx context.Context) {
d := m.delayed[0]
m.Values[d.i] = d.f(ctx)
} else if len(m.delayed) > 1 {
- // more than one concurrent task, use the main goroutine to do one, only spawn goroutines for the others
+ // more than one concurrent task, use the main goroutine to do one, only spawn goroutines
+ // for the others
var wg sync.WaitGroup
for _, d := range m.delayed[1:] {
diff --git a/vendor/github.com/99designs/gqlgen/graphql/handler.go b/vendor/github.com/99designs/gqlgen/graphql/handler.go
index ab2ed4b6..e9978b76 100644
--- a/vendor/github.com/99designs/gqlgen/graphql/handler.go
+++ b/vendor/github.com/99designs/gqlgen/graphql/handler.go
@@ -33,13 +33,20 @@ type (
}
GraphExecutor interface {
- CreateOperationContext(ctx context.Context, params *RawParams) (*OperationContext, gqlerror.List)
- DispatchOperation(ctx context.Context, opCtx *OperationContext) (ResponseHandler, context.Context)
+ CreateOperationContext(
+ ctx context.Context,
+ params *RawParams,
+ ) (*OperationContext, gqlerror.List)
+ DispatchOperation(
+ ctx context.Context,
+ opCtx *OperationContext,
+ ) (ResponseHandler, context.Context)
DispatchError(ctx context.Context, list gqlerror.List) *Response
}
- // HandlerExtension adds functionality to the http handler. See the list of possible hook points below
- // Its important to understand the lifecycle of a graphql request and the terminology we use in gqlgen
+ // HandlerExtension adds functionality to the http handler. See the list of possible hook points
+ // below Its important to understand the lifecycle of a graphql request and the terminology we
+ // use in gqlgen
// before working with these
//
// +--- REQUEST POST /graphql --------------------------------------------+
@@ -51,30 +58,36 @@ type (
// | +--------------------------------------------------------------------+ |
// +------------------------------------------------------------------------+
HandlerExtension interface {
- // ExtensionName should be a CamelCase string version of the extension which may be shown in stats and logging.
+ // ExtensionName should be a CamelCase string version of the extension which may be shown in
+ // stats and logging.
ExtensionName() string
- // Validate is called when adding an extension to the server, it allows validation against the servers schema.
+ // Validate is called when adding an extension to the server, it allows validation against
+ // the servers schema.
Validate(schema ExecutableSchema) error
}
- // OperationParameterMutator is called before creating a request context. allows manipulating the raw query
+ // OperationParameterMutator is called before creating a request context. allows manipulating
+ // the raw query
// on the way in.
OperationParameterMutator interface {
MutateOperationParameters(ctx context.Context, request *RawParams) *gqlerror.Error
}
- // OperationContextMutator is called after creating the request context, but before executing the root resolver.
+ // OperationContextMutator is called after creating the request context, but before executing
+ // the root resolver.
OperationContextMutator interface {
MutateOperationContext(ctx context.Context, opCtx *OperationContext) *gqlerror.Error
}
- // OperationInterceptor is called for each incoming query, for basic requests the writer will be invoked once,
+ // OperationInterceptor is called for each incoming query, for basic requests the writer will be
+ // invoked once,
// for subscriptions it will be invoked multiple times.
OperationInterceptor interface {
InterceptOperation(ctx context.Context, next OperationHandler) ResponseHandler
}
- // ResponseInterceptor is called around each graphql operation response. This can be called many times for a single
+ // ResponseInterceptor is called around each graphql operation response. This can be called many
+ // times for a single
// operation the case of subscriptions.
ResponseInterceptor interface {
InterceptResponse(ctx context.Context, next ResponseHandler) *Response
@@ -89,7 +102,8 @@ type (
InterceptField(ctx context.Context, next Resolver) (res any, err error)
}
- // Transport provides support for different wire level encodings of graphql requests, eg Form, Get, Post, Websocket
+ // Transport provides support for different wire level encodings of graphql requests, eg Form,
+ // Get, Post, Websocket
Transport interface {
Supports(r *http.Request) bool
Do(w http.ResponseWriter, r *http.Request, exec GraphExecutor)
@@ -110,7 +124,11 @@ func (p *RawParams) AddUpload(upload Upload, key, path string) *gqlerror.Error {
for i, p := range parts[1:] {
last := i == len(parts)-2
if ptr == nil {
- return gqlerror.Errorf("path is missing \"variables.\" prefix, key: %s, path: %s", key, path)
+ return gqlerror.Errorf(
+ "path is missing \"variables.\" prefix, key: %s, path: %s",
+ key,
+ path,
+ )
}
if index, parseNbrErr := strconv.Atoi(p); parseNbrErr == nil {
if last {
diff --git a/vendor/github.com/99designs/gqlgen/graphql/handler/extension/apq.go b/vendor/github.com/99designs/gqlgen/graphql/handler/extension/apq.go
index 9390c4fe..50abf109 100644
--- a/vendor/github.com/99designs/gqlgen/graphql/handler/extension/apq.go
+++ b/vendor/github.com/99designs/gqlgen/graphql/handler/extension/apq.go
@@ -18,8 +18,9 @@ const (
errPersistedQueryNotFoundCode = "PERSISTED_QUERY_NOT_FOUND"
)
-// AutomaticPersistedQuery saves client upload by optimistically sending only the hashes of queries, if the server
-// does not yet know what the query is for the hash it will respond telling the client to send the query along with the
+// AutomaticPersistedQuery saves client upload by optimistically sending only the hashes of queries,
+// if the server does not yet know what the query is for the hash it will respond telling the client
+// to send the query along with the
// hash in the next request.
// see https://github.com/apollographql/apollo-link-persisted-queries
type AutomaticPersistedQuery struct {
@@ -52,7 +53,10 @@ func (a AutomaticPersistedQuery) Validate(schema graphql.ExecutableSchema) error
return nil
}
-func (a AutomaticPersistedQuery) MutateOperationParameters(ctx context.Context, rawParams *graphql.RawParams) *gqlerror.Error {
+func (a AutomaticPersistedQuery) MutateOperationParameters(
+ ctx context.Context,
+ rawParams *graphql.RawParams,
+) *gqlerror.Error {
if rawParams.Extensions["persistedQuery"] == nil {
return nil
}
diff --git a/vendor/github.com/99designs/gqlgen/graphql/handler/extension/complexity.go b/vendor/github.com/99designs/gqlgen/graphql/handler/extension/complexity.go
index b24494a7..df7465f2 100644
--- a/vendor/github.com/99designs/gqlgen/graphql/handler/extension/complexity.go
+++ b/vendor/github.com/99designs/gqlgen/graphql/handler/extension/complexity.go
@@ -58,7 +58,10 @@ func (c *ComplexityLimit) Validate(schema graphql.ExecutableSchema) error {
return nil
}
-func (c ComplexityLimit) MutateOperationContext(ctx context.Context, opCtx *graphql.OperationContext) *gqlerror.Error {
+func (c ComplexityLimit) MutateOperationContext(
+ ctx context.Context,
+ opCtx *graphql.OperationContext,
+) *gqlerror.Error {
op := opCtx.Doc.Operations.ForName(opCtx.OperationName)
complexityCalcs := complexity.Calculate(ctx, c.es, op, opCtx.Variables)
@@ -70,7 +73,11 @@ func (c ComplexityLimit) MutateOperationContext(ctx context.Context, opCtx *grap
})
if complexityCalcs > limit {
- err := gqlerror.Errorf("operation has complexity %d, which exceeds the limit of %d", complexityCalcs, limit)
+ err := gqlerror.Errorf(
+ "operation has complexity %d, which exceeds the limit of %d",
+ complexityCalcs,
+ limit,
+ )
errcode.Set(err, errComplexityLimit)
return err
}
diff --git a/vendor/github.com/99designs/gqlgen/graphql/handler/extension/introspection.go b/vendor/github.com/99designs/gqlgen/graphql/handler/extension/introspection.go
index bdf0fdf8..bd40d4b4 100644
--- a/vendor/github.com/99designs/gqlgen/graphql/handler/extension/introspection.go
+++ b/vendor/github.com/99designs/gqlgen/graphql/handler/extension/introspection.go
@@ -24,7 +24,10 @@ func (c Introspection) Validate(schema graphql.ExecutableSchema) error {
return nil
}
-func (c Introspection) MutateOperationContext(ctx context.Context, opCtx *graphql.OperationContext) *gqlerror.Error {
+func (c Introspection) MutateOperationContext(
+ ctx context.Context,
+ opCtx *graphql.OperationContext,
+) *gqlerror.Error {
opCtx.DisableIntrospection = false
return nil
}
diff --git a/vendor/github.com/99designs/gqlgen/graphql/handler/server.go b/vendor/github.com/99designs/gqlgen/graphql/handler/server.go
index d80e60dc..1e717cb2 100644
--- a/vendor/github.com/99designs/gqlgen/graphql/handler/server.go
+++ b/vendor/github.com/99designs/gqlgen/graphql/handler/server.go
@@ -10,6 +10,7 @@ import (
"github.com/vektah/gqlparser/v2/ast"
"github.com/vektah/gqlparser/v2/gqlerror"
+ "github.com/vektah/gqlparser/v2/validator/rules"
"github.com/99designs/gqlgen/graphql"
"github.com/99designs/gqlgen/graphql/executor"
@@ -25,27 +26,31 @@ type (
}
)
+// New returns a new Server for the given executable schema. The Server is not
+// ready for use until the transports you require are added and configured with
+// Server.AddTransport. See the implementation of [NewDefaultServer] for an
+// example.
func New(es graphql.ExecutableSchema) *Server {
return &Server{
exec: executor.New(es),
}
}
-// NewDefaultServer is a demonstration only. Not for prod.
+// NewDefaultServer returns a Server for the given executable schema which is
+// only suitable for use in examples.
//
-// Currently, the server just picks the first available transport,
-// so this example NewDefaultServer orders them, but it is just
-// for demonstration purposes.
-// You will likely want to tune and better configure Websocket transport
-// since adding a new one (To configure it) doesn't have effect.
+// Deprecated:
+// The Server returned by NewDefaultServer is not suitable for production use.
+// Use [New] instead and add transports configured for your use case,
+// appropriate caches, and introspection if required. See the implementation of
+// NewDefaultServer for an example of starting point to construct a Server.
//
-// Also SSE support is not in here at all!
-// SSE when used over HTTP/1.1 (but not HTTP/2 or HTTP/3),
-// SSE suffers from a severe limitation to the maximum number
-// of open connections of 6 per browser. See:
+// SSE is not supported using this example. SSE when used over HTTP/1.1 (but not
+// HTTP/2 or HTTP/3) suffers from a severe limitation to the maximum number of
+// open connections of 6 per browser, see [Using server-sent events].
+//
+// [Using server-sent events]:
// https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events/Using_server-sent_events#sect1
-//
-// Deprecated: This was and is just an example.
func NewDefaultServer(es graphql.ExecutableSchema) *Server {
srv := New(es)
@@ -67,6 +72,9 @@ func NewDefaultServer(es graphql.ExecutableSchema) *Server {
return srv
}
+// AddTransport adds a transport to the Server. The server picks the first
+// supported transport. Adding a transport which has already been added has no
+// effect.
func (s *Server) AddTransport(transport graphql.Transport) {
s.transports = append(s.transports, transport)
}
@@ -91,26 +99,32 @@ func (s *Server) SetDisableSuggestion(value bool) {
s.exec.SetDisableSuggestion(value)
}
+// Use adds the given extension middleware to the server. Extensions are run in
+// order from first to last added.
func (s *Server) Use(extension graphql.HandlerExtension) {
s.exec.Use(extension)
}
-// AroundFields is a convenience method for creating an extension that only implements field middleware
+// AroundFields is a convenience method for creating an extension that only implements field
+// middleware
func (s *Server) AroundFields(f graphql.FieldMiddleware) {
s.exec.AroundFields(f)
}
-// AroundRootFields is a convenience method for creating an extension that only implements field middleware
+// AroundRootFields is a convenience method for creating an extension that only implements field
+// middleware
func (s *Server) AroundRootFields(f graphql.RootFieldMiddleware) {
s.exec.AroundRootFields(f)
}
-// AroundOperations is a convenience method for creating an extension that only implements operation middleware
+// AroundOperations is a convenience method for creating an extension that only implements operation
+// middleware
func (s *Server) AroundOperations(f graphql.OperationMiddleware) {
s.exec.AroundOperations(f)
}
-// AroundResponses is a convenience method for creating an extension that only implements response middleware
+// AroundResponses is a convenience method for creating an extension that only implements response
+// middleware
func (s *Server) AroundResponses(f graphql.ResponseMiddleware) {
s.exec.AroundResponses(f)
}
@@ -124,6 +138,11 @@ func (s *Server) getTransport(r *http.Request) graphql.Transport {
return nil
}
+// SetValidationRulesFn is to customize the Default GraphQL Validation Rules
+func (s *Server) SetValidationRulesFn(f func() *rules.Rules) {
+ s.exec.SetDefaultRulesFn(f)
+}
+
func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) {
defer func() {
if err := recover(); err != nil {
@@ -173,7 +192,10 @@ func (r OperationFunc) Validate(schema graphql.ExecutableSchema) error {
return nil
}
-func (r OperationFunc) InterceptOperation(ctx context.Context, next graphql.OperationHandler) graphql.ResponseHandler {
+func (r OperationFunc) InterceptOperation(
+ ctx context.Context,
+ next graphql.OperationHandler,
+) graphql.ResponseHandler {
return r(ctx, next)
}
@@ -190,7 +212,10 @@ func (r ResponseFunc) Validate(schema graphql.ExecutableSchema) error {
return nil
}
-func (r ResponseFunc) InterceptResponse(ctx context.Context, next graphql.ResponseHandler) *graphql.Response {
+func (r ResponseFunc) InterceptResponse(
+ ctx context.Context,
+ next graphql.ResponseHandler,
+) *graphql.Response {
return r(ctx, next)
}
diff --git a/vendor/github.com/99designs/gqlgen/graphql/handler/transport/error.go b/vendor/github.com/99designs/gqlgen/graphql/handler/transport/error.go
index 1fefb573..bd2c7ca8 100644
--- a/vendor/github.com/99designs/gqlgen/graphql/handler/transport/error.go
+++ b/vendor/github.com/99designs/gqlgen/graphql/handler/transport/error.go
@@ -10,7 +10,8 @@ import (
"github.com/99designs/gqlgen/graphql"
)
-// SendError sends a best effort error to a raw response writer. It assumes the client can understand the standard
+// SendError sends a best effort error to a raw response writer. It assumes the client can
+// understand the standard
// json error response
func SendError(w http.ResponseWriter, code int, errors ...*gqlerror.Error) {
w.WriteHeader(code)
diff --git a/vendor/github.com/99designs/gqlgen/graphql/handler/transport/headers.go b/vendor/github.com/99designs/gqlgen/graphql/handler/transport/headers.go
index c792575f..394e840f 100644
--- a/vendor/github.com/99designs/gqlgen/graphql/handler/transport/headers.go
+++ b/vendor/github.com/99designs/gqlgen/graphql/handler/transport/headers.go
@@ -11,7 +11,11 @@ const (
acceptApplicationGraphqlResponseJson = "application/graphql-response+json"
)
-func determineResponseContentType(explicitHeaders map[string][]string, r *http.Request, useGrapQLResponseJsonByDefault bool) string {
+func determineResponseContentType(
+ explicitHeaders map[string][]string,
+ r *http.Request,
+ useGrapQLResponseJsonByDefault bool,
+) string {
for k, v := range explicitHeaders {
if strings.EqualFold(k, "Content-Type") {
return v[0]
diff --git a/vendor/github.com/99designs/gqlgen/graphql/handler/transport/http_form_multipart.go b/vendor/github.com/99designs/gqlgen/graphql/handler/transport/http_form_multipart.go
index b9eb5f8f..ef020319 100644
--- a/vendor/github.com/99designs/gqlgen/graphql/handler/transport/http_form_multipart.go
+++ b/vendor/github.com/99designs/gqlgen/graphql/handler/transport/http_form_multipart.go
@@ -10,7 +10,8 @@ import (
"github.com/99designs/gqlgen/graphql"
)
-// MultipartForm the Multipart request spec https://github.com/jaydenseric/graphql-multipart-request-spec
+// MultipartForm the Multipart request spec
+// https://github.com/jaydenseric/graphql-multipart-request-spec
type MultipartForm struct {
// MaxUploadSize sets the maximum number of bytes used to parse a request body
// as multipart/form-data.
@@ -38,7 +39,7 @@ func (f MultipartForm) Supports(r *http.Request) bool {
return false
}
- return r.Method == "POST" && mediaType == "multipart/form-data"
+ return r.Method == http.MethodPost && mediaType == "multipart/form-data"
}
func (f MultipartForm) maxUploadSize() int64 {
diff --git a/vendor/github.com/99designs/gqlgen/graphql/handler/transport/http_form_urlencoded.go b/vendor/github.com/99designs/gqlgen/graphql/handler/transport/http_form_urlencoded.go
index f877c2dd..d6aec95a 100644
--- a/vendor/github.com/99designs/gqlgen/graphql/handler/transport/http_form_urlencoded.go
+++ b/vendor/github.com/99designs/gqlgen/graphql/handler/transport/http_form_urlencoded.go
@@ -31,7 +31,7 @@ func (h UrlEncodedForm) Supports(r *http.Request) bool {
return false
}
- return r.Method == "POST" && mediaType == "application/x-www-form-urlencoded"
+ return r.Method == http.MethodPost && mediaType == "application/x-www-form-urlencoded"
}
func (h UrlEncodedForm) Do(w http.ResponseWriter, r *http.Request, exec graphql.GraphExecutor) {
diff --git a/vendor/github.com/99designs/gqlgen/graphql/handler/transport/http_get.go b/vendor/github.com/99designs/gqlgen/graphql/handler/transport/http_get.go
index 26f8a681..5c5ca436 100644
--- a/vendor/github.com/99designs/gqlgen/graphql/handler/transport/http_get.go
+++ b/vendor/github.com/99designs/gqlgen/graphql/handler/transport/http_get.go
@@ -20,7 +20,8 @@ type GET struct {
// Map of all headers that are added to graphql response. If not
// set, only one header: Content-Type: application/graphql-response+json will be set.
ResponseHeaders map[string][]string
- // UseGrapQLResponseJsonByDefault determines whether to use 'application/graphql-response+json' as the response content type
+ // UseGrapQLResponseJsonByDefault determines whether to use 'application/graphql-response+json'
+ // as the response content type
// when the Accept header is empty or 'application/*' or '*/*'.
UseGrapQLResponseJsonByDefault bool
}
@@ -32,7 +33,7 @@ func (h GET) Supports(r *http.Request) bool {
return false
}
- return r.Method == "GET"
+ return r.Method == http.MethodGet
}
func (h GET) Do(w http.ResponseWriter, r *http.Request, exec graphql.GraphExecutor) {
@@ -42,7 +43,11 @@ func (h GET) Do(w http.ResponseWriter, r *http.Request, exec graphql.GraphExecut
writeJsonError(w, err.Error())
return
}
- contentType := determineResponseContentType(h.ResponseHeaders, r, h.UseGrapQLResponseJsonByDefault)
+ contentType := determineResponseContentType(
+ h.ResponseHeaders,
+ r,
+ h.UseGrapQLResponseJsonByDefault,
+ )
responseHeaders := mergeHeaders(
map[string][]string{
"Content-Type": {contentType},
diff --git a/vendor/github.com/99designs/gqlgen/graphql/handler/transport/http_graphql.go b/vendor/github.com/99designs/gqlgen/graphql/handler/transport/http_graphql.go
index 0bad1110..80177c0d 100644
--- a/vendor/github.com/99designs/gqlgen/graphql/handler/transport/http_graphql.go
+++ b/vendor/github.com/99designs/gqlgen/graphql/handler/transport/http_graphql.go
@@ -33,7 +33,7 @@ func (h GRAPHQL) Supports(r *http.Request) bool {
return false
}
- return r.Method == "POST" && mediaType == "application/graphql"
+ return r.Method == http.MethodPost && mediaType == "application/graphql"
}
func (h GRAPHQL) Do(w http.ResponseWriter, r *http.Request, exec graphql.GraphExecutor) {
diff --git a/vendor/github.com/99designs/gqlgen/graphql/handler/transport/http_multipart_mixed.go b/vendor/github.com/99designs/gqlgen/graphql/handler/transport/http_multipart_mixed.go
index 9cf1b533..686aeb41 100644
--- a/vendor/github.com/99designs/gqlgen/graphql/handler/transport/http_multipart_mixed.go
+++ b/vendor/github.com/99designs/gqlgen/graphql/handler/transport/http_multipart_mixed.go
@@ -40,16 +40,20 @@ func (t MultipartMixed) Supports(r *http.Request) bool {
// Do implements the multipart/mixed spec as a multipart/mixed response
func (t MultipartMixed) Do(w http.ResponseWriter, r *http.Request, exec graphql.GraphExecutor) {
// Implements the multipart/mixed spec as a multipart/mixed response:
- // * https://github.com/graphql/graphql-wg/blob/e4ef5f9d5997815d9de6681655c152b6b7838b4c/rfcs/DeferStream.md
+ // *
+ // https://github.com/graphql/graphql-wg/blob/e4ef5f9d5997815d9de6681655c152b6b7838b4c/rfcs/DeferStream.md
// 2022/08/23 as implemented by gqlgen.
- // * https://github.com/graphql/graphql-wg/blob/f22ea7748c6ebdf88fdbf770a8d9e41984ebd429/rfcs/DeferStream.md June 2023 Spec for the
+ // *
+ // https://github.com/graphql/graphql-wg/blob/f22ea7748c6ebdf88fdbf770a8d9e41984ebd429/rfcs/DeferStream.md
+ // June 2023 Spec for the
// `incremental` field
// * https://github.com/graphql/graphql-over-http/blob/main/rfcs/IncrementalDelivery.md
// multipart specification
// Follows the format that is used in the Apollo Client tests:
// https://github.com/apollographql/apollo-client/blob/v3.11.8/src/link/http/__tests__/responseIterator.ts#L68
- // Apollo Client, despite mentioning in its requests that they require the 2022 spec, it wants the
- // `incremental` field to be an array of responses, not a single response. Theoretically we could
+ // Apollo Client, despite mentioning in its requests that they require the 2022 spec, it wants
+ // the `incremental` field to be an array of responses, not a single response. Theoretically we
+ // could
// batch responses in the `incremental` field, if we wanted to optimize this code.
ctx := r.Context()
flusher, ok := w.(http.Flusher)
@@ -178,7 +182,8 @@ func writeContentTypeHeader(w io.Writer) {
fmt.Fprintf(w, "Content-Type: application/json\r\n\r\n")
}
-// multipartResponseAggregator helps us reduce the number of responses sent to the frontend by batching all the
+// multipartResponseAggregator helps us reduce the number of responses sent to the frontend by
+// batching all the
// incremental responses together.
type multipartResponseAggregator struct {
mu sync.Mutex
diff --git a/vendor/github.com/99designs/gqlgen/graphql/handler/transport/http_post.go b/vendor/github.com/99designs/gqlgen/graphql/handler/transport/http_post.go
index d57bf3c4..f4d698fe 100644
--- a/vendor/github.com/99designs/gqlgen/graphql/handler/transport/http_post.go
+++ b/vendor/github.com/99designs/gqlgen/graphql/handler/transport/http_post.go
@@ -20,7 +20,8 @@ type POST struct {
// set, only one header: Content-Type: application/graphql-response+json will be set.
ResponseHeaders map[string][]string
- // UseGrapQLResponseJsonByDefault determines whether to use 'application/graphql-response+json' as the response content type
+ // UseGrapQLResponseJsonByDefault determines whether to use 'application/graphql-response+json'
+ // as the response content type
// when the Accept header is empty or 'application/*' or '*/*'.
UseGrapQLResponseJsonByDefault bool
}
@@ -37,7 +38,7 @@ func (h POST) Supports(r *http.Request) bool {
return false
}
- return r.Method == "POST" && mediaType == "application/json"
+ return r.Method == http.MethodPost && mediaType == "application/json"
}
func getRequestBody(r *http.Request) (string, error) {
@@ -59,7 +60,11 @@ var pool = sync.Pool{
func (h POST) Do(w http.ResponseWriter, r *http.Request, exec graphql.GraphExecutor) {
ctx := r.Context()
- contentType := determineResponseContentType(h.ResponseHeaders, r, h.UseGrapQLResponseJsonByDefault)
+ contentType := determineResponseContentType(
+ h.ResponseHeaders,
+ r,
+ h.UseGrapQLResponseJsonByDefault,
+ )
responseHeaders := mergeHeaders(
map[string][]string{
"Content-Type": {contentType},
diff --git a/vendor/github.com/99designs/gqlgen/graphql/handler/transport/options.go b/vendor/github.com/99designs/gqlgen/graphql/handler/transport/options.go
index 5d7f4b88..4b471df6 100644
--- a/vendor/github.com/99designs/gqlgen/graphql/handler/transport/options.go
+++ b/vendor/github.com/99designs/gqlgen/graphql/handler/transport/options.go
@@ -16,7 +16,7 @@ type Options struct {
var _ graphql.Transport = Options{}
func (o Options) Supports(r *http.Request) bool {
- return r.Method == "HEAD" || r.Method == "OPTIONS"
+ return r.Method == http.MethodHead || r.Method == http.MethodOptions
}
func (o Options) Do(w http.ResponseWriter, r *http.Request, exec graphql.GraphExecutor) {
diff --git a/vendor/github.com/99designs/gqlgen/graphql/handler/transport/reader.go b/vendor/github.com/99designs/gqlgen/graphql/handler/transport/reader.go
index c58eccf3..5812a529 100644
--- a/vendor/github.com/99designs/gqlgen/graphql/handler/transport/reader.go
+++ b/vendor/github.com/99designs/gqlgen/graphql/handler/transport/reader.go
@@ -19,7 +19,7 @@ func (r *bytesReader) Read(b []byte) (n int, err error) {
}
n = copy(b, (*r.s)[r.i:])
r.i += int64(n)
- return
+ return n, err
}
func (r *bytesReader) Seek(offset int64, whence int) (int64, error) {
diff --git a/vendor/github.com/99designs/gqlgen/graphql/handler/transport/websocket.go b/vendor/github.com/99designs/gqlgen/graphql/handler/transport/websocket.go
index d6c174cd..8d7680b6 100644
--- a/vendor/github.com/99designs/gqlgen/graphql/handler/transport/websocket.go
+++ b/vendor/github.com/99designs/gqlgen/graphql/handler/transport/websocket.go
@@ -103,11 +103,15 @@ func (t Websocket) Do(w http.ResponseWriter, r *http.Request, exec graphql.Graph
var me messageExchanger
switch ws.Subprotocol() {
default:
- msg := websocket.FormatCloseMessage(websocket.CloseProtocolError, fmt.Sprintf("unsupported negotiated subprotocol %s", ws.Subprotocol()))
+ msg := websocket.FormatCloseMessage(
+ websocket.CloseProtocolError,
+ fmt.Sprintf("unsupported negotiated subprotocol %s", ws.Subprotocol()),
+ )
_ = ws.WriteMessage(websocket.CloseMessage, msg)
return
case graphqlwsSubprotocol, "":
- // clients are required to send a subprotocol, to be backward compatible with the previous implementation we select
+ // clients are required to send a subprotocol, to be backward compatible with the previous
+ // implementation we select
// "graphql-ws" by default
me = graphqlwsMessageExchanger{c: ws}
case graphqltransportwsSubprotocol:
@@ -245,7 +249,8 @@ func (c *wsConnection) run() {
// If we're running in graphql-ws mode, create a timer that will trigger a
// keep alive message every interval
- if (c.conn.Subprotocol() == "" || c.conn.Subprotocol() == graphqlwsSubprotocol) && c.KeepAlivePingInterval != 0 {
+ if (c.conn.Subprotocol() == "" || c.conn.Subprotocol() == graphqlwsSubprotocol) &&
+ c.KeepAlivePingInterval != 0 {
c.mu.Lock()
c.keepAliveTicker = time.NewTicker(c.KeepAlivePingInterval)
c.mu.Unlock()
@@ -498,7 +503,10 @@ func (c *wsConnection) close(closeCode int, message string) {
c.mu.Unlock()
return
}
- _ = c.conn.WriteMessage(websocket.CloseMessage, websocket.FormatCloseMessage(closeCode, message))
+ _ = c.conn.WriteMessage(
+ websocket.CloseMessage,
+ websocket.FormatCloseMessage(closeCode, message),
+ )
for _, closer := range c.active {
closer()
}
diff --git a/vendor/github.com/99designs/gqlgen/graphql/handler/transport/websocket_resolver_error.go b/vendor/github.com/99designs/gqlgen/graphql/handler/transport/websocket_resolver_error.go
index cb8e3ed1..a60914f8 100644
--- a/vendor/github.com/99designs/gqlgen/graphql/handler/transport/websocket_resolver_error.go
+++ b/vendor/github.com/99designs/gqlgen/graphql/handler/transport/websocket_resolver_error.go
@@ -18,7 +18,8 @@ type subscriptionError struct {
errs []*gqlerror.Error
}
-// AddSubscriptionError is used to let websocket return an error message after subscription resolver returns a channel.
+// AddSubscriptionError is used to let websocket return an error message after subscription resolver
+// returns a channel.
// for example:
//
// func (r *subscriptionResolver) Method(ctx context.Context) (<-chan *model.Message, error) {
diff --git a/vendor/github.com/99designs/gqlgen/graphql/input.go b/vendor/github.com/99designs/gqlgen/graphql/input.go
index 681fe080..93de656c 100644
--- a/vendor/github.com/99designs/gqlgen/graphql/input.go
+++ b/vendor/github.com/99designs/gqlgen/graphql/input.go
@@ -22,7 +22,8 @@ func BuildUnmarshalerMap(unmarshaler ...any) map[reflect.Type]reflect.Value {
return maps
}
-// WithUnmarshalerMap returns a new context with a map from input types to their unmarshaler functions.
+// WithUnmarshalerMap returns a new context with a map from input types to their unmarshaler
+// functions.
func WithUnmarshalerMap(ctx context.Context, maps map[reflect.Type]reflect.Value) context.Context {
return context.WithValue(ctx, unmarshalInputCtx, maps)
}
diff --git a/vendor/github.com/99designs/gqlgen/graphql/int.go b/vendor/github.com/99designs/gqlgen/graphql/int.go
index ba269e13..6e799975 100644
--- a/vendor/github.com/99designs/gqlgen/graphql/int.go
+++ b/vendor/github.com/99designs/gqlgen/graphql/int.go
@@ -5,83 +5,84 @@ import (
"fmt"
"io"
"math"
+ "reflect"
"strconv"
)
func MarshalInt(i int) Marshaler {
return WriterFunc(func(w io.Writer) {
- io.WriteString(w, strconv.Itoa(i))
+ _, _ = io.WriteString(w, strconv.FormatInt(int64(i), 10))
})
}
func UnmarshalInt(v any) (int, error) {
- switch v := v.(type) {
- case string:
- return strconv.Atoi(v)
- case int:
- return v, nil
- case int64:
- return int(v), nil
- case json.Number:
- return strconv.Atoi(string(v))
- case nil:
- return 0, nil
- default:
- return 0, fmt.Errorf("%T is not an int", v)
- }
+ return interfaceToSignedNumber[int](v)
}
-func MarshalInt64(i int64) Marshaler {
+func MarshalInt8(i int8) Marshaler {
return WriterFunc(func(w io.Writer) {
- io.WriteString(w, strconv.FormatInt(i, 10))
+ _, _ = io.WriteString(w, strconv.FormatInt(int64(i), 10))
})
}
-func UnmarshalInt64(v any) (int64, error) {
- switch v := v.(type) {
- case string:
- return strconv.ParseInt(v, 10, 64)
- case int:
- return int64(v), nil
- case int64:
- return v, nil
- case json.Number:
- return strconv.ParseInt(string(v), 10, 64)
- case nil:
- return 0, nil
- default:
- return 0, fmt.Errorf("%T is not an int", v)
- }
+func UnmarshalInt8(v any) (int8, error) {
+ return interfaceToSignedNumber[int8](v)
+}
+
+func MarshalInt16(i int16) Marshaler {
+ return WriterFunc(func(w io.Writer) {
+ _, _ = io.WriteString(w, strconv.FormatInt(int64(i), 10))
+ })
+}
+
+func UnmarshalInt16(v any) (int16, error) {
+ return interfaceToSignedNumber[int16](v)
}
func MarshalInt32(i int32) Marshaler {
return WriterFunc(func(w io.Writer) {
- io.WriteString(w, strconv.FormatInt(int64(i), 10))
+ _, _ = io.WriteString(w, strconv.FormatInt(int64(i), 10))
})
}
func UnmarshalInt32(v any) (int32, error) {
+ return interfaceToSignedNumber[int32](v)
+}
+
+func MarshalInt64(i int64) Marshaler {
+ return WriterFunc(func(w io.Writer) {
+ _, _ = io.WriteString(w, strconv.FormatInt(i, 10))
+ })
+}
+
+func UnmarshalInt64(v any) (int64, error) {
+ return interfaceToSignedNumber[int64](v)
+}
+
+type number interface {
+ int | int8 | int16 | int32 | int64 | uint | uint8 | uint16 | uint32 | uint64
+}
+
+func interfaceToSignedNumber[N number](v any) (N, error) {
switch v := v.(type) {
+ case int, int8, int16, int32, int64:
+ return safeCastSignedNumber[N](reflect.ValueOf(v).Int())
case string:
iv, err := strconv.ParseInt(v, 10, 64)
if err != nil {
return 0, err
}
- return safeCastInt32(iv)
- case int:
- return safeCastInt32(int64(v))
- case int64:
- return safeCastInt32(v)
+ return safeCastSignedNumber[N](iv)
case json.Number:
iv, err := strconv.ParseInt(string(v), 10, 64)
if err != nil {
return 0, err
}
- return safeCastInt32(iv)
+ return safeCastSignedNumber[N](iv)
case nil:
return 0, nil
default:
- return 0, fmt.Errorf("%T is not an int", v)
+ return 0, fmt.Errorf("%T is not an %T", v, N(0))
}
}
@@ -98,27 +99,62 @@ func (e IntegerError) Error() string {
return e.Message
}
-type Int32OverflowError struct {
- Value int64
+type NumberOverflowError struct {
+ Value any
*IntegerError
}
-func newInt32OverflowError(i int64) *Int32OverflowError {
- return &Int32OverflowError{
- Value: i,
- IntegerError: &IntegerError{
- Message: fmt.Sprintf("%d overflows signed 32-bit integer", i),
- },
+type maxNumber interface {
+ int64 | uint64
+}
+
+func newNumberOverflowError[N maxNumber](i any, bitsize int) *NumberOverflowError {
+ switch v := i.(type) {
+ case int64:
+ return &NumberOverflowError{
+ Value: v,
+ IntegerError: &IntegerError{
+ Message: fmt.Sprintf("%d overflows signed %d-bit integer", i, bitsize),
+ },
+ }
+ default:
+ return &NumberOverflowError{
+ Value: v,
+ IntegerError: &IntegerError{
+ Message: fmt.Sprintf("%d overflows unsigned %d-bit integer", i, bitsize),
+ },
+ }
}
}
-func (e *Int32OverflowError) Unwrap() error {
+func (e *NumberOverflowError) Unwrap() error {
return e.IntegerError
}
-func safeCastInt32(i int64) (int32, error) {
- if i > math.MaxInt32 || i < math.MinInt32 {
- return 0, newInt32OverflowError(i)
+// safeCastSignedNumber converts an int64 to a number of type N.
+func safeCastSignedNumber[N number](val int64) (N, error) {
+ var zero N
+ switch any(zero).(type) {
+ case int8:
+ if val > math.MaxInt8 || val < math.MinInt8 {
+ return 0, newNumberOverflowError[int64](val, 8)
+ }
+ case int16:
+ if val > math.MaxInt16 || val < math.MinInt16 {
+ return 0, newNumberOverflowError[int64](val, 16)
+ }
+ case int32:
+ if val > math.MaxInt32 || val < math.MinInt32 {
+ return 0, newNumberOverflowError[int64](val, 32)
+ }
+ case int:
+ if strconv.IntSize == 32 && (val > math.MaxInt32 || val < math.MinInt32) {
+ return 0, newNumberOverflowError[int64](val, 32)
+ }
+ case int64:
+ default:
+ return 0, fmt.Errorf("invalid type %T", zero)
}
- return int32(i), nil
+
+ return N(val), nil
}
diff --git a/vendor/github.com/99designs/gqlgen/graphql/introspection/introspection.go b/vendor/github.com/99designs/gqlgen/graphql/introspection/introspection.go
index 14c76c46..47028f67 100644
--- a/vendor/github.com/99designs/gqlgen/graphql/introspection/introspection.go
+++ b/vendor/github.com/99designs/gqlgen/graphql/introspection/introspection.go
@@ -1,4 +1,5 @@
-// introspection implements the spec defined in https://github.com/facebook/graphql/blob/master/spec/Section%204%20--%20Introspection.md#schema-introspection
+// introspection implements the spec defined in
+// https://github.com/facebook/graphql/blob/master/spec/Section%204%20--%20Introspection.md#schema-introspection
package introspection
import (
diff --git a/vendor/github.com/99designs/gqlgen/graphql/omittable.go b/vendor/github.com/99designs/gqlgen/graphql/omittable.go
index 58c21c8c..288252d6 100644
--- a/vendor/github.com/99designs/gqlgen/graphql/omittable.go
+++ b/vendor/github.com/99designs/gqlgen/graphql/omittable.go
@@ -46,8 +46,9 @@ func (o Omittable[T]) IsSet() bool {
}
// IsZero returns true then json.Marshal will omit this value.
-// > The "omitzero" option specifies that the field should be omitted from the encoding if the field has a zero value, according to rules:
-// > 1) If the field type has an "IsZero() bool" method, that will be used to determine whether the value is zero.
+// > The "omitzero" option specifies that the field should be omitted from the encoding if the field
+// has a zero value, according to rules: > 1) If the field type has an "IsZero() bool" method, that
+// will be used to determine whether the value is zero.
// > 2) Otherwise, the value is zero if it is the zero value for its type.
// https://pkg.go.dev/encoding/json#Marshal
func (o Omittable[T]) IsZero() bool {
diff --git a/vendor/github.com/99designs/gqlgen/graphql/playground/apollo_sandbox_playground.go b/vendor/github.com/99designs/gqlgen/graphql/playground/apollo_sandbox_playground.go
index f998b4d8..bda9fc7d 100644
--- a/vendor/github.com/99designs/gqlgen/graphql/playground/apollo_sandbox_playground.go
+++ b/vendor/github.com/99designs/gqlgen/graphql/playground/apollo_sandbox_playground.go
@@ -7,6 +7,11 @@ import (
"net/http"
)
+const (
+ apolloSandboxMainJs = "https://embeddable-sandbox.cdn.apollographql.com/02e2da0fccbe0240ef03d2396d6c98559bab5b06/embeddable-sandbox.umd.production.min.js"
+ apolloSandboxMainSri = "sha256-asj/scPAF8jmMGj1J+YwCHps3uI57AZ78cHs0bJkML4="
+)
+
// NOTE: New version available at https://embeddable-sandbox.cdn.apollographql.com/ -->
var apolloSandboxPage = template.Must(template.New("ApolloSandbox").Parse(`
@@ -26,7 +31,7 @@ var apolloSandboxPage = template.Must(template.New("ApolloSandbox").Parse(`
-
+
{{- if .EnablePluginExplorer}}
{{- end}}
-
Loading...
+
+
Loading…
+
{{- if .EnablePluginExplorer}}
@@ -168,26 +175,26 @@ var page = template.Must(template.New("graphiql").Parse(`
`))
type GraphiqlConfig struct {
- Title string
- StoragePrefix string
- Endpoint string
- FetcherHeaders map[string]string
- UiHeaders map[string]string
- EndpointIsAbsolute bool
- SubscriptionEndpoint string
- Version string
- EnablePluginExplorer bool
- PluginExplorerVersion string
- // https://www.jsdelivr.com/package/npm/@graphiql/plugin-explorer?tab=files
- PluginExplorerCssSRI string
+ Title string
+ StoragePrefix string
+ Endpoint string
+ FetcherHeaders map[string]string
+ UiHeaders map[string]string
+ EndpointIsAbsolute bool
+ SubscriptionEndpoint string
+ JsUrl template.URL
+ JsSRI string
+ CssUrl template.URL
+ CssSRI string
+ ReactUrl template.URL
+ ReactSRI string
+ ReactDOMUrl template.URL
+ ReactDOMSRI string
+ EnablePluginExplorer bool
+ PluginExplorerJsUrl template.URL
PluginExplorerJsSRI string
- // https://www.jsdelivr.com/package/npm/graphiql?tab=files
- CssSRI string
- JsSRI string
- // https://www.jsdelivr.com/package/npm/react?tab=files
- ReactSRI string
- // https://www.jsdelivr.com/package/npm/react-dom?tab=files
- ReactDOMSRI string
+ PluginExplorerCssUrl template.URL
+ PluginExplorerCssSRI string
}
type GraphiqlConfigOption func(*GraphiqlConfig)
@@ -203,6 +210,35 @@ func WithGraphiqlUiHeaders(headers map[string]string) GraphiqlConfigOption {
}
}
+func WithGraphiqlVersion(jsUrl, cssUrl, jsSri, cssSri string) GraphiqlConfigOption {
+ return func(config *GraphiqlConfig) {
+ config.JsUrl = template.URL(jsUrl)
+ config.CssUrl = template.URL(cssUrl)
+ config.JsSRI = jsSri
+ config.CssSRI = cssSri
+ }
+}
+
+func WithGraphiqlReactVersion(
+ reactJsUrl, reactDomJsUrl, reactJsSri, reactDomJsSri string,
+) GraphiqlConfigOption {
+ return func(config *GraphiqlConfig) {
+ config.ReactUrl = template.URL(reactJsUrl)
+ config.ReactDOMUrl = template.URL(reactDomJsUrl)
+ config.ReactSRI = reactJsSri
+ config.ReactDOMSRI = reactDomJsSri
+ }
+}
+
+func WithGraphiqlPluginExplorerVersion(jsUrl, cssUrl, jsSri, cssSri string) GraphiqlConfigOption {
+ return func(config *GraphiqlConfig) {
+ config.PluginExplorerJsUrl = template.URL(jsUrl)
+ config.PluginExplorerCssUrl = template.URL(cssUrl)
+ config.PluginExplorerJsSRI = jsSri
+ config.PluginExplorerCssSRI = cssSri
+ }
+}
+
func WithGraphiqlEnablePluginExplorer(enable bool) GraphiqlConfigOption {
return func(config *GraphiqlConfig) {
config.EnablePluginExplorer = enable
@@ -217,27 +253,40 @@ func WithStoragePrefix(prefix string) GraphiqlConfigOption {
// Handler responsible for setting up the playground
func Handler(title, endpoint string, opts ...GraphiqlConfigOption) http.HandlerFunc {
+ data := GraphiqlConfig{
+ Title: title,
+ Endpoint: endpoint,
+ EndpointIsAbsolute: endpointHasScheme(endpoint),
+ SubscriptionEndpoint: getSubscriptionEndpoint(endpoint),
+ // https://www.jsdelivr.com/package/npm/graphiql?tab=files
+ JsUrl: "https://cdn.jsdelivr.net/npm/graphiql@4.1.2/graphiql.min.js",
+ JsSRI: "sha256-hnImuor1znlJkD/FOTL3jayfS/xsyNoP04abi8bFJWs=",
+ CssUrl: "https://cdn.jsdelivr.net/npm/graphiql@4.1.2/graphiql.min.css",
+ CssSRI: "sha256-MEh+B2NdMSpj9kexQNN3QKc8UzMrCXW/Sx/phcpuyIU=",
+ // https://www.jsdelivr.com/package/npm/react?tab=files
+ ReactUrl: "https://cdn.jsdelivr.net/npm/react@18.2.0/umd/react.production.min.js",
+ ReactSRI: "sha256-S0lp+k7zWUMk2ixteM6HZvu8L9Eh//OVrt+ZfbCpmgY=",
+ // https://www.jsdelivr.com/package/npm/react-dom?tab=files
+ ReactDOMUrl: "https://cdn.jsdelivr.net/npm/react-dom@18.2.0/umd/react-dom.production.min.js",
+ ReactDOMSRI: "sha256-IXWO0ITNDjfnNXIu5POVfqlgYoop36bDzhodR6LW5Pc=",
+ // https://www.jsdelivr.com/package/npm/@graphiql/plugin-explorer?tab=files
+ PluginExplorerJsUrl: template.URL(
+ "https://cdn.jsdelivr.net/npm/@graphiql/plugin-explorer@4.0.6/dist/index.umd.js",
+ ),
+ PluginExplorerJsSRI: "sha256-UM8sWOS0Xa9yLY85q6Clh0pF4qpxX+TOcJ41flECqBs=",
+ PluginExplorerCssUrl: template.URL(
+ "https://cdn.jsdelivr.net/npm/@graphiql/plugin-explorer@4.0.6/dist/style.min.css",
+ ),
+ PluginExplorerCssSRI: "sha256-b0izygy8aEMY3fCLmtNkm9PKdE3kRD4Qjn6Q8gw5xKI=",
+ }
+ for _, opt := range opts {
+ opt(&data)
+ }
+
return func(w http.ResponseWriter, r *http.Request) {
w.Header().Add("Content-Type", "text/html; charset=UTF-8")
- var data = GraphiqlConfig{
- Title: title,
- Endpoint: endpoint,
- EndpointIsAbsolute: endpointHasScheme(endpoint),
- SubscriptionEndpoint: getSubscriptionEndpoint(endpoint),
- Version: "3.7.0",
- CssSRI: "sha256-Dbkv2LUWis+0H4Z+IzxLBxM2ka1J133lSjqqtSu49o8=",
- JsSRI: "sha256-qsScAZytFdTAEOM8REpljROHu8DvdvxXBK7xhoq5XD0=",
- ReactSRI: "sha256-S0lp+k7zWUMk2ixteM6HZvu8L9Eh//OVrt+ZfbCpmgY=",
- ReactDOMSRI: "sha256-IXWO0ITNDjfnNXIu5POVfqlgYoop36bDzhodR6LW5Pc=",
- PluginExplorerVersion: "3.2.5",
- PluginExplorerCssSRI: "sha256-+fdus37Qf3cEIKiD3VvTvgMdc8qOAT1NGUKEevz5l6k=",
- PluginExplorerJsSRI: "sha256-minamf9GZIDrlzoMXDvU55DKk6DC5D6pNctIDWFMxS0=",
- }
- for _, opt := range opts {
- opt(&data)
- }
- err := page.Execute(w, data)
- if err != nil {
+
+ if err := page.Execute(w, data); err != nil {
panic(err)
}
}
@@ -250,7 +299,12 @@ func HandlerWithHeaders(
title, endpoint string,
fetcherHeaders, uiHeaders map[string]string,
) http.HandlerFunc {
- return Handler(title, endpoint, WithGraphiqlFetcherHeaders(fetcherHeaders), WithGraphiqlUiHeaders(uiHeaders))
+ return Handler(
+ title,
+ endpoint,
+ WithGraphiqlFetcherHeaders(fetcherHeaders),
+ WithGraphiqlUiHeaders(uiHeaders),
+ )
}
// endpointHasScheme checks if the endpoint has a scheme.
diff --git a/vendor/github.com/99designs/gqlgen/graphql/resolve_field.go b/vendor/github.com/99designs/gqlgen/graphql/resolve_field.go
new file mode 100644
index 00000000..a96c552c
--- /dev/null
+++ b/vendor/github.com/99designs/gqlgen/graphql/resolve_field.go
@@ -0,0 +1,142 @@
+package graphql
+
+import (
+ "context"
+ "io"
+
+ "github.com/vektah/gqlparser/v2/ast"
+)
+
+func ResolveField[T any](
+ ctx context.Context,
+ oc *OperationContext,
+ field CollectedField,
+ initializeFieldContext func(ctx context.Context, field CollectedField) (*FieldContext, error),
+ fieldResolver func(ctx context.Context) (any, error),
+ middlewareChain func(ctx context.Context, next Resolver) Resolver,
+ marshal func(ctx context.Context, sel ast.SelectionSet, v T) Marshaler,
+ recoverFromPanic bool,
+ nonNull bool,
+) Marshaler {
+ return resolveField[T, Marshaler](
+ ctx,
+ oc,
+ field,
+ initializeFieldContext,
+ fieldResolver,
+ middlewareChain,
+ recoverFromPanic,
+ nonNull,
+ Null,
+ func(ctx context.Context, res T) Marshaler {
+ return marshal(ctx, field.Selections, res)
+ },
+ )
+}
+
+func ResolveFieldStream[T any](
+ ctx context.Context,
+ oc *OperationContext,
+ field CollectedField,
+ initializeFieldContext func(ctx context.Context, field CollectedField) (*FieldContext, error),
+ fieldResolver func(context.Context) (any, error),
+ middlewareChain func(ctx context.Context, next Resolver) Resolver,
+ marshal func(ctx context.Context, sel ast.SelectionSet, v T) Marshaler,
+ recoverFromPanic bool,
+ nonNull bool,
+) func(context.Context) Marshaler {
+ return resolveField(
+ ctx,
+ oc,
+ field,
+ initializeFieldContext,
+ fieldResolver,
+ middlewareChain,
+ recoverFromPanic,
+ nonNull,
+ nil,
+ func(ctx context.Context, res <-chan T) func(context.Context) Marshaler {
+ return func(ctx context.Context) Marshaler {
+ select {
+ case v, ok := <-res:
+ if !ok {
+ return nil
+ }
+ return WriterFunc(func(w io.Writer) {
+ w.Write([]byte{'{'})
+ MarshalString(field.Alias).MarshalGQL(w)
+ w.Write([]byte{':'})
+ marshal(ctx, field.Selections, v).MarshalGQL(w)
+ w.Write([]byte{'}'})
+ })
+ case <-ctx.Done():
+ return nil
+ }
+ }
+ },
+ )
+}
+
+func resolveField[T, R any](
+ ctx context.Context,
+ oc *OperationContext,
+ field CollectedField,
+ initializeFieldContext func(ctx context.Context, field CollectedField) (*FieldContext, error),
+ fieldResolver func(ctx context.Context) (any, error),
+ middlewareChain func(ctx context.Context, next Resolver) Resolver,
+ recoverFromPanic bool,
+ nonNull bool,
+ defaultResult R,
+ result func(ctx context.Context, res T) R,
+) (ret R) {
+ fc, err := initializeFieldContext(ctx, field)
+ if err != nil {
+ return defaultResult
+ }
+ ctx = WithFieldContext(ctx, fc)
+
+ if recoverFromPanic {
+ defer func() {
+ if r := recover(); r != nil {
+ oc.Error(ctx, oc.Recover(ctx, r))
+ ret = defaultResult
+ }
+ }()
+ }
+
+ next := func(rctx context.Context) (any, error) {
+ ctx = rctx // use context from middleware stack in children
+ return fieldResolver(rctx)
+ }
+
+ if middlewareChain != nil {
+ next = middlewareChain(ctx, next)
+ }
+
+ resTmp, err := oc.ResolverMiddleware(ctx, next)
+ if err != nil {
+ oc.Error(ctx, err)
+ return defaultResult
+ }
+ if resTmp == nil {
+ if nonNull {
+ if !HasFieldError(ctx, fc) {
+ oc.Errorf(ctx, "must not be null")
+ }
+ }
+ return defaultResult
+ }
+ res, ok := resTmp.(T)
+ if !ok {
+ var t T
+ oc.Errorf(
+ ctx,
+ `unexpected type %T from middleware/directive chain, should be %T`,
+ resTmp,
+ t,
+ )
+ return defaultResult
+ }
+ fc.Result = res
+ return result(ctx, res)
+}
diff --git a/vendor/github.com/99designs/gqlgen/graphql/stats.go b/vendor/github.com/99designs/gqlgen/graphql/stats.go
index 1bf2ad9e..63ab78a5 100644
--- a/vendor/github.com/99designs/gqlgen/graphql/stats.go
+++ b/vendor/github.com/99designs/gqlgen/graphql/stats.go
@@ -12,7 +12,8 @@ type Stats struct {
Parsing TraceTiming
Validation TraceTiming
- // Stats collected by handler extensions. Don't use directly, the extension should provide a type safe way to
+ // Stats collected by handler extensions. Don't use directly, the extension should provide a
+ // type safe way to
// access this.
extension map[string]any
}
@@ -24,9 +25,10 @@ type TraceTiming struct {
var ctxTraceStart key = "trace_start"
-// StartOperationTrace captures the current time and stores it in context. This will eventually be added to request
-// context but we want to grab it as soon as possible. For transports that can only handle a single graphql query
-// per http requests you don't need to call this at all, the server will do it for you. For transports that handle
+// StartOperationTrace captures the current time and stores it in context. This will eventually be
+// added to request context but we want to grab it as soon as possible. For transports that can only
+// handle a single graphql query per http requests you don't need to call this at all, the server
+// will do it for you. For transports that handle
// multiple (eg batching, subscriptions) this should be called before decoding each request.
func StartOperationTrace(ctx context.Context) context.Context {
return context.WithValue(ctx, ctxTraceStart, Now())
diff --git a/vendor/github.com/99designs/gqlgen/graphql/time.go b/vendor/github.com/99designs/gqlgen/graphql/time.go
index a5fe9030..a31096b0 100644
--- a/vendor/github.com/99designs/gqlgen/graphql/time.go
+++ b/vendor/github.com/99designs/gqlgen/graphql/time.go
@@ -18,8 +18,57 @@ func MarshalTime(t time.Time) Marshaler {
}
func UnmarshalTime(v any) (time.Time, error) {
- if tmpStr, ok := v.(string); ok {
- return time.Parse(time.RFC3339Nano, tmpStr)
+ if v == nil {
+ return time.Time{}, nil
}
+
+ if tmpStr, ok := v.(string); ok {
+ if tmpStr == "" {
+ return time.Time{}, nil
+ }
+
+ t, err := time.Parse(time.RFC3339Nano, tmpStr)
+ if err == nil {
+ return t, nil
+ }
+ t, err = time.Parse(time.RFC3339, tmpStr)
+ if err == nil {
+ return t, nil
+ }
+ t, err = time.Parse(time.DateTime, tmpStr)
+ if err == nil {
+ return t, nil
+ }
+ }
+
return time.Time{}, errors.New("time should be RFC3339Nano formatted string")
}
+
+func MarshalDate(t time.Time) Marshaler {
+ if t.IsZero() {
+ return Null
+ }
+
+ return WriterFunc(func(w io.Writer) {
+ io.WriteString(w, strconv.Quote(t.Format(time.DateOnly)))
+ })
+}
+
+func UnmarshalDate(v any) (time.Time, error) {
+ if v == nil {
+ return time.Time{}, nil
+ }
+
+ if tmpStr, ok := v.(string); ok {
+ if tmpStr == "" {
+ return time.Time{}, nil
+ }
+
+ t, err := time.Parse(time.DateOnly, tmpStr)
+ if err == nil {
+ return t, nil
+ }
+ }
+
+ return time.Time{}, errors.New("time should be DateOnly formatted string")
+}
diff --git a/vendor/github.com/99designs/gqlgen/graphql/uint.go b/vendor/github.com/99designs/gqlgen/graphql/uint.go
index 8352e39f..8a6c1c75 100644
--- a/vendor/github.com/99designs/gqlgen/graphql/uint.go
+++ b/vendor/github.com/99designs/gqlgen/graphql/uint.go
@@ -6,6 +6,7 @@ import (
"fmt"
"io"
"math"
+ "reflect"
"strconv"
)
@@ -16,87 +17,27 @@ func MarshalUint(i uint) Marshaler {
}
func UnmarshalUint(v any) (uint, error) {
- switch v := v.(type) {
- case string:
- u64, err := strconv.ParseUint(v, 10, 64)
- if err != nil {
- var strconvErr *strconv.NumError
- if errors.As(err, &strconvErr) && isSignedInteger(v) {
- return 0, newUintSignError(v)
- }
- return 0, err
- }
- return uint(u64), err
- case int:
- if v < 0 {
- return 0, newUintSignError(strconv.FormatInt(int64(v), 10))
- }
- return uint(v), nil
- case int64:
- if v < 0 {
- return 0, newUintSignError(strconv.FormatInt(v, 10))
- }
- return uint(v), nil
- case json.Number:
- u64, err := strconv.ParseUint(string(v), 10, 64)
- if err != nil {
- var strconvErr *strconv.NumError
- if errors.As(err, &strconvErr) && isSignedInteger(string(v)) {
- return 0, newUintSignError(string(v))
- }
- return 0, err
- }
- return uint(u64), err
- case nil:
- return 0, nil
- default:
- return 0, fmt.Errorf("%T is not an uint", v)
- }
+ return interfaceToUnsignedNumber[uint](v)
}
-func MarshalUint64(i uint64) Marshaler {
+func MarshalUint8(i uint8) Marshaler {
return WriterFunc(func(w io.Writer) {
- _, _ = io.WriteString(w, strconv.FormatUint(i, 10))
+ _, _ = io.WriteString(w, strconv.FormatUint(uint64(i), 10))
})
}
-func UnmarshalUint64(v any) (uint64, error) {
- switch v := v.(type) {
- case string:
- i, err := strconv.ParseUint(v, 10, 64)
- if err != nil {
- var strconvErr *strconv.NumError
- if errors.As(err, &strconvErr) && isSignedInteger(v) {
- return 0, newUintSignError(v)
- }
- return 0, err
- }
- return i, nil
- case int:
- if v < 0 {
- return 0, newUintSignError(strconv.FormatInt(int64(v), 10))
- }
- return uint64(v), nil
- case int64:
- if v < 0 {
- return 0, newUintSignError(strconv.FormatInt(v, 10))
- }
- return uint64(v), nil
- case json.Number:
- i, err := strconv.ParseUint(string(v), 10, 64)
- if err != nil {
- var strconvErr *strconv.NumError
- if errors.As(err, &strconvErr) && isSignedInteger(string(v)) {
- return 0, newUintSignError(string(v))
- }
- return 0, err
- }
- return i, nil
- case nil:
- return 0, nil
- default:
- return 0, fmt.Errorf("%T is not an uint", v)
- }
+func UnmarshalUint8(v any) (uint8, error) {
+ return interfaceToUnsignedNumber[uint8](v)
+}
+
+func MarshalUint16(i uint16) Marshaler {
+ return WriterFunc(func(w io.Writer) {
+ _, _ = io.WriteString(w, strconv.FormatUint(uint64(i), 10))
+ })
+}
+
+func UnmarshalUint16(v any) (uint16, error) {
+ return interfaceToUnsignedNumber[uint16](v)
}
func MarshalUint32(i uint32) Marshaler {
@@ -106,9 +47,30 @@ func MarshalUint32(i uint32) Marshaler {
}
func UnmarshalUint32(v any) (uint32, error) {
+ return interfaceToUnsignedNumber[uint32](v)
+}
+
+func MarshalUint64(i uint64) Marshaler {
+ return WriterFunc(func(w io.Writer) {
+ _, _ = io.WriteString(w, strconv.FormatUint(i, 10))
+ })
+}
+
+func UnmarshalUint64(v any) (uint64, error) {
+ return interfaceToUnsignedNumber[uint64](v)
+}
+
+func interfaceToUnsignedNumber[N number](v any) (N, error) {
switch v := v.(type) {
+ case int, int64:
+ if reflect.ValueOf(v).Int() < 0 {
+ return 0, newUintSignError(strconv.FormatInt(reflect.ValueOf(v).Int(), 10))
+ }
+ return safeCastUnsignedNumber[N](uint64(reflect.ValueOf(v).Int()))
+ case uint, uint8, uint16, uint32, uint64:
+ return safeCastUnsignedNumber[N](reflect.ValueOf(v).Uint())
case string:
- iv, err := strconv.ParseUint(v, 10, 64)
+ uv, err := strconv.ParseUint(v, 10, 64)
if err != nil {
var strconvErr *strconv.NumError
if errors.As(err, &strconvErr) && isSignedInteger(v) {
@@ -116,19 +78,9 @@ func UnmarshalUint32(v any) (uint32, error) {
}
return 0, err
}
- return safeCastUint32(iv)
- case int:
- if v < 0 {
- return 0, newUintSignError(strconv.FormatInt(int64(v), 10))
- }
- return safeCastUint32(uint64(v))
- case int64:
- if v < 0 {
- return 0, newUintSignError(strconv.FormatInt(v, 10))
- }
- return safeCastUint32(uint64(v))
+ return safeCastUnsignedNumber[N](uv)
case json.Number:
- iv, err := strconv.ParseUint(string(v), 10, 64)
+ uv, err := strconv.ParseUint(string(v), 10, 64)
if err != nil {
var strconvErr *strconv.NumError
if errors.As(err, &strconvErr) && isSignedInteger(string(v)) {
@@ -136,11 +88,11 @@ func UnmarshalUint32(v any) (uint32, error) {
}
return 0, err
}
- return safeCastUint32(iv)
+ return safeCastUnsignedNumber[N](uv)
case nil:
return 0, nil
default:
- return 0, fmt.Errorf("%T is not an uint", v)
+ return 0, fmt.Errorf("%T is not an %T", v, N(0))
}
}
@@ -160,6 +112,30 @@ func (e *UintSignError) Unwrap() error {
return e.IntegerError
}
+// safeCastUnsignedNumber converts an uint64 to a number of type N.
+func safeCastUnsignedNumber[N number](val uint64) (N, error) {
+ var zero N
+ switch any(zero).(type) {
+ case uint8:
+ if val > math.MaxUint8 {
+ return 0, newNumberOverflowError[uint64](val, 8)
+ }
+ case uint16:
+ if val > math.MaxUint16 {
+ return 0, newNumberOverflowError[uint64](val, 16)
+ }
+ case uint32:
+ if val > math.MaxUint32 {
+ return 0, newNumberOverflowError[uint64](val, 32)
+ }
+ case uint64, uint, int:
+ default:
+ return 0, fmt.Errorf("invalid type %T", zero)
+ }
+
+ return N(val), nil
+}
+
func isSignedInteger(v string) bool {
if v == "" {
return false
@@ -172,28 +148,3 @@ func isSignedInteger(v string) bool {
}
return false
}
-
-type Uint32OverflowError struct {
- Value uint64
- *IntegerError
-}
-
-func newUint32OverflowError(i uint64) *Uint32OverflowError {
- return &Uint32OverflowError{
- Value: i,
- IntegerError: &IntegerError{
- Message: fmt.Sprintf("%d overflows unsigned 32-bit integer", i),
- },
- }
-}
-
-func (e *Uint32OverflowError) Unwrap() error {
- return e.IntegerError
-}
-
-func safeCastUint32(i uint64) (uint32, error) {
- if i > math.MaxUint32 {
- return 0, newUint32OverflowError(i)
- }
- return uint32(i), nil
-}
diff --git a/vendor/github.com/99designs/gqlgen/graphql/version.go b/vendor/github.com/99designs/gqlgen/graphql/version.go
index 59001378..3022ccb9 100644
--- a/vendor/github.com/99designs/gqlgen/graphql/version.go
+++ b/vendor/github.com/99designs/gqlgen/graphql/version.go
@@ -1,3 +1,3 @@
package graphql
-const Version = "v0.17.76"
+const Version = "v0.17.84"
diff --git a/vendor/github.com/99designs/gqlgen/internal/code/imports.go b/vendor/github.com/99designs/gqlgen/internal/code/imports.go
index e950f1d5..c23f0ae7 100644
--- a/vendor/github.com/99designs/gqlgen/internal/code/imports.go
+++ b/vendor/github.com/99designs/gqlgen/internal/code/imports.go
@@ -21,7 +21,8 @@ func init() {
}
}
-// NameForDir manually looks for package stanzas in files located in the given directory. This can be
+// NameForDir manually looks for package stanzas in files located in the given directory. This can
+// be
// much faster than having to consult go list, because we already know exactly where to look.
func NameForDir(dir string) string {
dir, err := filepath.Abs(dir)
@@ -55,7 +56,8 @@ type goModuleSearchResult struct {
var goModuleRootCache = map[string]goModuleSearchResult{}
-// goModuleRoot returns the root of the current go module if there is a go.mod file in the directory tree
+// goModuleRoot returns the root of the current go module if there is a go.mod file in the directory
+// tree
// If not, it returns false
func goModuleRoot(dir string) (string, bool) {
dir, err := filepath.Abs(dir)
@@ -99,7 +101,8 @@ func goModuleRoot(dir string) (string, bool) {
// create a cache for each path in a tree traversed, except the top one as it is already cached
for _, d := range dirs[:len(dirs)-1] {
if result.moduleName == "" {
- // go.mod is not found in the tree, so the same sentinel value fits all the directories in a tree
+ // go.mod is not found in the tree, so the same sentinel value fits all the directories
+ // in a tree
goModuleRootCache[d] = result
} else {
relPath, err := filepath.Rel(result.goModPath, d)
diff --git a/vendor/github.com/99designs/gqlgen/internal/code/packages.go b/vendor/github.com/99designs/gqlgen/internal/code/packages.go
index 93e84fe4..f9f7624f 100644
--- a/vendor/github.com/99designs/gqlgen/internal/code/packages.go
+++ b/vendor/github.com/99designs/gqlgen/internal/code/packages.go
@@ -20,7 +20,8 @@ var mode = packages.NeedName |
packages.NeedModule
type (
- // Packages is a wrapper around x/tools/go/packages that maintains a (hopefully prewarmed) cache of packages
+ // Packages is a wrapper around x/tools/go/packages that maintains a (hopefully prewarmed) cache
+ // of packages
// that can be invalidated as writes are made and packages are known to change.
Packages struct {
packages map[string]*packages.Package
@@ -58,7 +59,8 @@ func PackagePrefixToCache(prefixPath string) func(p *Packages) {
}
// NewPackages creates a new packages cache
-// It will load all packages in the current module, and any packages that are passed to Load or LoadAll
+// It will load all packages in the current module, and any packages that are passed to Load or
+// LoadAll
func NewPackages(opts ...Option) *Packages {
p := &Packages{}
for _, opt := range opts {
@@ -169,8 +171,9 @@ func (p *Packages) Load(importPath string) *packages.Package {
return pkgs[0]
}
-// LoadWithTypes tries a standard load, which may not have enough type info (TypesInfo== nil) available if the imported package is a
-// second order dependency. Fortunately this doesnt happen very often, so we can just issue a load when we detect it.
+// LoadWithTypes tries a standard load, which may not have enough type info (TypesInfo== nil)
+// available if the imported package is a second order dependency. Fortunately this doesnt happen
+// very often, so we can just issue a load when we detect it.
func (p *Packages) LoadWithTypes(importPath string) *packages.Package {
pkg := p.Load(importPath)
if pkg == nil || pkg.TypesInfo == nil {
@@ -189,8 +192,9 @@ func (p *Packages) LoadWithTypes(importPath string) *packages.Package {
return pkg
}
-// LoadAllNames will call packages.Load with the NeedName mode only and will store the package name in a cache.
-// it does not return any package data, but after calling this you can call NameForPackage to get the package name without loading the full package data.
+// LoadAllNames will call packages.Load with the NeedName mode only and will store the package name
+// in a cache. it does not return any package data, but after calling this you can call
+// NameForPackage to get the package name without loading the full package data.
func (p *Packages) LoadAllNames(importPaths ...string) {
importPaths = dedupPackages(importPaths)
missing := make([]string, 0, len(importPaths))
@@ -228,7 +232,6 @@ func (p *Packages) LoadAllNames(importPaths ...string) {
Mode: packages.NeedName,
BuildFlags: p.buildFlags,
}, missing...)
-
if err != nil {
p.loadErrors = append(p.loadErrors, err)
}
@@ -243,7 +246,8 @@ func (p *Packages) LoadAllNames(importPaths ...string) {
}
}
-// NameForPackage looks up the package name from the package stanza in the go files at the given import path.
+// NameForPackage looks up the package name from the package stanza in the go files at the given
+// import path.
func (p *Packages) NameForPackage(importPath string) string {
p.numNameCalls++
p.LoadAllNames(importPath)
@@ -252,7 +256,8 @@ func (p *Packages) NameForPackage(importPath string) string {
return p.importToName[importPath]
}
-// Evict removes a given package import path from the cache. Further calls to Load will fetch it from disk.
+// Evict removes a given package import path from the cache. Further calls to Load will fetch it
+// from disk.
func (p *Packages) Evict(importPath string) {
delete(p.packages, importPath)
}
@@ -268,7 +273,8 @@ func (p *Packages) ModTidy() error {
return nil
}
-// Errors returns any errors that were returned by Load, either from the call itself or any of the loaded packages.
+// Errors returns any errors that were returned by Load, either from the call itself or any of the
+// loaded packages.
func (p *Packages) Errors() PkgErrors {
res := append([]error{}, p.loadErrors...)
for _, pkg := range p.packages {
diff --git a/vendor/github.com/99designs/gqlgen/internal/code/util.go b/vendor/github.com/99designs/gqlgen/internal/code/util.go
index 96c6e03f..742e9b5b 100644
--- a/vendor/github.com/99designs/gqlgen/internal/code/util.go
+++ b/vendor/github.com/99designs/gqlgen/internal/code/util.go
@@ -36,7 +36,8 @@ func NormalizeVendor(pkg string) string {
// github.com/99designs/gqlgen/graphql becomes
// github.com/foo/vendor/github.com/99designs/gqlgen/graphql
//
-// x/tools/packages only supports 'qualified package paths' so this will need to be done prior to calling it
+// x/tools/packages only supports 'qualified package paths' so this will need to be done prior to
+// calling it
// See https://github.com/golang/go/issues/30289
func QualifyPackagePath(importPath string) string {
wd, _ := os.Getwd()
diff --git a/vendor/github.com/99designs/gqlgen/internal/imports/prune.go b/vendor/github.com/99designs/gqlgen/internal/imports/prune.go
index f5fc71c6..88f56130 100644
--- a/vendor/github.com/99designs/gqlgen/internal/imports/prune.go
+++ b/vendor/github.com/99designs/gqlgen/internal/imports/prune.go
@@ -43,7 +43,11 @@ func Prune(filename string, src []byte, packages *code.Packages) ([]byte, error)
return nil, err
}
- return imports.Process(filename, buf.Bytes(), &imports.Options{FormatOnly: true, Comments: true, TabIndent: true, TabWidth: 8})
+ return imports.Process(
+ filename,
+ buf.Bytes(),
+ &imports.Options{FormatOnly: true, Comments: true, TabIndent: true, TabWidth: 8},
+ )
}
func getUnusedImports(file ast.Node, packages *code.Packages) map[string]string {
diff --git a/vendor/github.com/99designs/gqlgen/main.go b/vendor/github.com/99designs/gqlgen/main.go
index 164d1ee0..e67b583a 100644
--- a/vendor/github.com/99designs/gqlgen/main.go
+++ b/vendor/github.com/99designs/gqlgen/main.go
@@ -4,6 +4,7 @@ package main
import (
"bytes"
+ "context"
_ "embed"
"errors"
"fmt"
@@ -14,7 +15,7 @@ import (
"os"
"path/filepath"
- "github.com/urfave/cli/v2"
+ "github.com/urfave/cli/v3"
"github.com/99designs/gqlgen/api"
"github.com/99designs/gqlgen/codegen/config"
@@ -31,7 +32,8 @@ var configFileTemplate string
func getConfigFileContent(pkgName string) string {
var buf bytes.Buffer
- if err := template.Must(template.New("gqlgen.yml").Parse(configFileTemplate)).Execute(&buf, pkgName); err != nil {
+ if err := template.Must(template.New("gqlgen.yml").Parse(configFileTemplate)).
+ Execute(&buf, pkgName); err != nil {
panic(err)
}
return buf.String()
@@ -92,10 +94,10 @@ var initCmd = &cli.Command{
Value: "graph/schema.graphqls",
},
},
- Action: func(ctx *cli.Context) error {
- configFilename := ctx.String("config")
- serverFilename := ctx.String("server")
- schemaFilename := ctx.String("schema")
+ Action: func(ctx context.Context, c *cli.Command) error {
+ configFilename := c.String("config")
+ serverFilename := c.String("server")
+ schemaFilename := c.String("schema")
cwd, err := os.Getwd()
if err != nil {
@@ -167,10 +169,10 @@ var generateCmd = &cli.Command{
&cli.BoolFlag{Name: "verbose, v", Usage: "show logs"},
&cli.StringFlag{Name: "config, c", Usage: "the config filename"},
},
- Action: func(ctx *cli.Context) error {
+ Action: func(ctx context.Context, c *cli.Command) error {
var cfg *config.Config
var err error
- if configFilename := ctx.String("config"); configFilename != "" {
+ if configFilename := c.String("config"); configFilename != "" {
cfg, err = config.LoadConfig(configFilename)
if err != nil {
return err
@@ -193,27 +195,27 @@ var generateCmd = &cli.Command{
var versionCmd = &cli.Command{
Name: "version",
Usage: "print the version string",
- Action: func(ctx *cli.Context) error {
+ Action: func(ctx context.Context, c *cli.Command) error {
fmt.Println(graphql.Version)
return nil
},
}
func main() {
- app := cli.NewApp()
+ app := &cli.Command{}
app.Name = "gqlgen"
app.Usage = generateCmd.Usage
app.Description = "This is a library for quickly creating strictly typed graphql servers in golang. See https://gqlgen.com/ for a getting started guide."
app.HideVersion = true
app.Flags = generateCmd.Flags
app.Version = graphql.Version
- app.Before = func(context *cli.Context) error {
- if context.Bool("verbose") {
+ app.Before = func(ctx context.Context, c *cli.Command) (context.Context, error) {
+ if c.Bool("verbose") {
log.SetFlags(0)
} else {
log.SetOutput(io.Discard)
}
- return nil
+ return ctx, nil
}
app.Action = generateCmd.Action
@@ -223,7 +225,7 @@ func main() {
versionCmd,
}
- if err := app.Run(os.Args); err != nil {
+ if err := app.Run(context.Background(), os.Args); err != nil {
fmt.Fprint(os.Stderr, err.Error()+"\n")
os.Exit(1)
}
diff --git a/vendor/github.com/99designs/gqlgen/plugin/federation/entity.go b/vendor/github.com/99designs/gqlgen/plugin/federation/entity.go
index 562d86c5..cd934818 100644
--- a/vendor/github.com/99designs/gqlgen/plugin/federation/entity.go
+++ b/vendor/github.com/99designs/gqlgen/plugin/federation/entity.go
@@ -49,7 +49,8 @@ type Requires struct {
func (e *Entity) allFieldsAreExternal(federationVersion int) bool {
for _, field := range e.Def.Fields {
- if !e.isFieldImplicitlyExternal(field, federationVersion) && field.Directives.ForName("external") == nil {
+ if !e.isFieldImplicitlyExternal(field, federationVersion) &&
+ field.Directives.ForName("external") == nil {
return false
}
}
@@ -62,8 +63,9 @@ func (e *Entity) isFieldImplicitlyExternal(field *ast.FieldDefinition, federatio
if federationVersion != 2 {
return false
}
- // TODO: From the spec, it seems like if an entity is not resolvable then it should not only not have a resolver, but should not appear in the _Entity union.
- // The current implementation is a less drastic departure from the previous behavior, but should probably be reviewed.
+ // TODO: From the spec, it seems like if an entity is not resolvable then it should not only not
+ // have a resolver, but should not appear in the _Entity union. The current implementation is a
+ // less drastic departure from the previous behavior, but should probably be reviewed.
// See https://www.apollographql.com/docs/federation/subgraph-spec/
if e.isResolvable() {
return false
@@ -88,7 +90,8 @@ func (e *Entity) isResolvable() bool {
// If there is no resolvable argument, the entity is resolvable.
return true
}
- // only if resolvable: false has been set on the @key directive do we consider the entity non-resolvable.
+ // only if resolvable: false has been set on the @key directive do we consider the entity
+ // non-resolvable.
return resolvable.Value.Raw != "false"
}
diff --git a/vendor/github.com/99designs/gqlgen/plugin/federation/federation.go b/vendor/github.com/99designs/gqlgen/plugin/federation/federation.go
index 01c7f6d3..fbe36f47 100644
--- a/vendor/github.com/99designs/gqlgen/plugin/federation/federation.go
+++ b/vendor/github.com/99designs/gqlgen/plugin/federation/federation.go
@@ -42,6 +42,10 @@ type PackageOptions struct {
// ComputedRequires generates resolver functions to compute values for
// fields using the @required directive.
ComputedRequires bool
+ // EntityResolverMulti is default engine for entityResolver generation.
+ // This can be overriding by @entityResolver(multi: Boolean) directive.
+ // false by default.
+ EntityResolverMulti bool
}
// New returns a federation plugin that injects
@@ -64,30 +68,63 @@ func New(version int, cfg *config.Config) (*Federation, error) {
func buildPackageOptions(cfg *config.Config) (PackageOptions, error) {
packageOptions := cfg.Federation.Options
- explicitRequires := packageOptions["explicit_requires"]
- computedRequires := packageOptions["computed_requires"]
+ const (
+ optionExplicitRequires = "explicit_requires"
+ optionComputedRequires = "computed_requires"
+ optionEntityResolverMulti = "entity_resolver_multi"
+ )
+
+ var explicitRequires,
+ computedRequires,
+ entityResolverMulti bool
+
+ for k, v := range packageOptions {
+ switch k {
+ case optionExplicitRequires:
+ explicitRequires = v
+ case optionComputedRequires:
+ computedRequires = v
+ case optionEntityResolverMulti:
+ entityResolverMulti = v
+ default:
+ return PackageOptions{}, fmt.Errorf("unknown package option: %s", k)
+ }
+ }
+
if explicitRequires && computedRequires {
- return PackageOptions{}, errors.New("only one of explicit_requires or computed_requires can be set to true")
+ return PackageOptions{}, fmt.Errorf(
+ "only one of %s or %s can be set to true",
+ optionExplicitRequires,
+ optionComputedRequires,
+ )
}
if computedRequires {
if cfg.Federation.Version != 2 {
- return PackageOptions{}, errors.New("when using federation.options.computed_requires you must be using Federation 2")
+ return PackageOptions{}, fmt.Errorf(
+ "when using federation.options.%s you must be using Federation 2",
+ optionComputedRequires,
+ )
}
- // We rely on injecting a null argument with a directives for fields with @requires, so we need to ensure
+ // We rely on injecting a null argument with a directives for fields with @requires, so we
+ // need to ensure
// our directive is always called.
if !cfg.CallArgumentDirectivesWithNull {
- return PackageOptions{}, errors.New("when using federation.options.computed_requires, call_argument_directives_with_null must be set to true")
+ return PackageOptions{}, fmt.Errorf(
+ "when using federation.options.%s, call_argument_directives_with_null must be set to true",
+ optionComputedRequires,
+ )
}
}
- // We rely on injecting a null argument with a directives for fields with @requires, so we need to ensure
+ // We rely on injecting a null argument with a directives for fields with @requires, so we need
+ // to ensure
// our directive is always called.
-
return PackageOptions{
- ExplicitRequires: explicitRequires,
- ComputedRequires: computedRequires,
+ ExplicitRequires: explicitRequires,
+ ComputedRequires: computedRequires,
+ EntityResolverMulti: entityResolverMulti,
}, nil
}
@@ -100,7 +137,10 @@ func (f *Federation) Name() string {
func (f *Federation) MutateConfig(cfg *config.Config) error {
for typeName, entry := range builtins {
if cfg.Models.Exists(typeName) {
- return fmt.Errorf("%v already exists which must be reserved when Federation is enabled", typeName)
+ return fmt.Errorf(
+ "%v already exists which must be reserved when Federation is enabled",
+ typeName,
+ )
}
cfg.Models[typeName] = entry
}
@@ -127,7 +167,9 @@ func (f *Federation) MutateConfig(cfg *config.Config) error {
if f.usesRequires && f.PackageOptions.ComputedRequires {
cfg.Schema.Directives[dirPopulateFromRepresentations.Name] = dirPopulateFromRepresentations
- cfg.Directives[dirPopulateFromRepresentations.Name] = config.DirectiveConfig{Implementation: &populateFromRepresentationsImplementation}
+ cfg.Directives[dirPopulateFromRepresentations.Name] = config.DirectiveConfig{
+ Implementation: &populateFromRepresentationsImplementation,
+ }
cfg.Schema.Directives[dirEntityReference.Name] = dirEntityReference
cfg.Directives[dirEntityReference.Name] = config.DirectiveConfig{SkipRuntime: true}
@@ -142,7 +184,8 @@ func (f *Federation) MutateConfig(cfg *config.Config) error {
func (f *Federation) InjectSourcesEarly() ([]*ast.Source, error) {
input := ``
- // add version-specific changes on key directive, as well as adding the new directives for federation 2
+ // add version-specific changes on key directive, as well as adding the new directives for
+ // federation 2
switch f.version {
case 1:
input += federationVersion1Schema
@@ -157,7 +200,7 @@ func (f *Federation) InjectSourcesEarly() ([]*ast.Source, error) {
}}, nil
}
-// InjectSourceLate creates a GraphQL Entity type with all
+// InjectSourcesLate creates a GraphQL Entity type with all
// the fields that had the @key directive
func (f *Federation) InjectSourcesLate(schema *ast.Schema) ([]*ast.Source, error) {
f.Entities = f.buildEntities(schema, f.version)
@@ -178,7 +221,10 @@ func (f *Federation) InjectSourcesLate(schema *ast.Schema) ([]*ast.Source, error
resolverSDL, entityResolverInputSDL := buildResolverSDL(r, e.Multi)
resolvers = append(resolvers, resolverSDL)
if entityResolverInputSDL != "" {
- entityResolverInputDefinitions = append(entityResolverInputDefinitions, entityResolverInputSDL)
+ entityResolverInputDefinitions = append(
+ entityResolverInputDefinitions,
+ entityResolverInputSDL,
+ )
}
}
}
@@ -393,7 +439,10 @@ func (f *Federation) buildEntity(
}
if (schemaType.Kind == ast.Interface) && (len(schema.GetPossibleTypes(schemaType)) == 0) {
- fmt.Printf("@key directive found on unused \"interface %s\". Will be ignored.\n", schemaType.Name)
+ fmt.Printf(
+ "@key directive found on unused \"interface %s\". Will be ignored.\n",
+ schemaType.Name,
+ )
return nil
}
@@ -402,7 +451,7 @@ func (f *Federation) buildEntity(
Def: schemaType,
Resolvers: nil,
Requires: nil,
- Multi: isMultiEntity(schemaType),
+ Multi: f.isMultiEntity(schemaType),
}
// If our schema has a field with a type defined in
@@ -436,10 +485,12 @@ func (f *Federation) buildEntity(
return entity
}
-func isMultiEntity(schemaType *ast.Definition) bool {
+// isMultiEntity returns @entityResolver(multi) value, if directive is not defined,
+// then global configuration parameter will be used.
+func (f *Federation) isMultiEntity(schemaType *ast.Definition) bool {
dir := schemaType.Directives.ForName(dirNameEntityResolver)
if dir == nil {
- return false
+ return f.PackageOptions.EntityResolverMulti
}
if dirArg := dir.Arguments.ForName("multi"); dirArg != nil {
@@ -448,7 +499,7 @@ func isMultiEntity(schemaType *ast.Definition) bool {
}
}
- return false
+ return f.PackageOptions.EntityResolverMulti
}
func buildResolvers(
@@ -493,7 +544,8 @@ func extractFields(
) (string, error) {
var arg *ast.Argument
- // since directives are able to now have multiple arguments, we need to check both possible for a possible @key(fields="" fields="")
+ // since directives are able to now have multiple arguments, we need to check both possible for
+ // a possible @key(fields="" fields="")
for _, a := range dir.Arguments {
if a.Name == DirArgFields {
if arg != nil {
@@ -611,12 +663,22 @@ func (f *Federation) generateExplicitRequires(
Entity: entity,
}
- populator.Comment = strings.TrimSpace(strings.TrimLeft(rewriter.GetMethodComment("executionContext", populator.FuncName), `\`))
- populator.Implementation = strings.TrimSpace(rewriter.GetMethodBody("executionContext", populator.FuncName))
+ populator.Comment = strings.TrimSpace(
+ strings.TrimLeft(
+ rewriter.GetMethodComment("executionContext", populator.FuncName),
+ `\`,
+ ),
+ )
+ populator.Implementation = strings.TrimSpace(
+ rewriter.GetMethodBody("executionContext", populator.FuncName),
+ )
if populator.Implementation == "" {
populator.Exists = false
- populator.Implementation = fmt.Sprintf("panic(fmt.Errorf(\"not implemented: %v\"))", populator.FuncName)
+ populator.Implementation = fmt.Sprintf(
+ "panic(fmt.Errorf(\"not implemented: %v\"))",
+ populator.FuncName,
+ )
}
populators = append(populators, populator)
}
@@ -660,27 +722,43 @@ func buildResolverSDL(
) (resolverSDL, entityResolverInputSDL string) {
if multi {
entityResolverInputSDL = buildEntityResolverInputDefinitionSDL(resolver)
- resolverSDL := fmt.Sprintf("\t%s(reps: [%s]!): [%s]", resolver.ResolverName, resolver.InputTypeName, resolver.ReturnTypeName)
+ resolverSDL := fmt.Sprintf(
+ "\t%s(reps: [%s]!): [%s]",
+ resolver.ResolverName,
+ resolver.InputTypeName,
+ resolver.ReturnTypeName,
+ )
return resolverSDL, entityResolverInputSDL
}
resolverArgs := ""
+ var resolverArgsSb705 strings.Builder
for _, keyField := range resolver.KeyFields {
- resolverArgs += fmt.Sprintf("%s: %s,", keyField.Field.ToGoPrivate(), keyField.Definition.Type.String())
+ resolverArgsSb705.WriteString(
+ fmt.Sprintf("%s: %s,", keyField.Field.ToGoPrivate(), keyField.Definition.Type.String()),
+ )
}
- resolverSDL = fmt.Sprintf("\t%s(%s): %s!", resolver.ResolverName, resolverArgs, resolver.ReturnTypeName)
+ resolverArgs += resolverArgsSb705.String()
+ resolverSDL = fmt.Sprintf(
+ "\t%s(%s): %s!",
+ resolver.ResolverName,
+ resolverArgs,
+ resolver.ReturnTypeName,
+ )
return resolverSDL, ""
}
func buildEntityResolverInputDefinitionSDL(resolver *EntityResolver) string {
entityResolverInputDefinition := "input " + resolver.InputTypeName + " {\n"
+ var entityResolverInputDefinitionSb714 strings.Builder
for _, keyField := range resolver.KeyFields {
- entityResolverInputDefinition += fmt.Sprintf(
+ entityResolverInputDefinitionSb714.WriteString(fmt.Sprintf(
"\t%s: %s\n",
keyField.Field.ToGo(),
keyField.Definition.Type.String(),
- )
+ ))
}
+ entityResolverInputDefinition += entityResolverInputDefinitionSb714.String()
return entityResolverInputDefinition + "}"
}
diff --git a/vendor/github.com/99designs/gqlgen/plugin/federation/fieldset/fieldset.go b/vendor/github.com/99designs/gqlgen/plugin/federation/fieldset/fieldset.go
index 65b32eae..01355631 100644
--- a/vendor/github.com/99designs/gqlgen/plugin/federation/fieldset/fieldset.go
+++ b/vendor/github.com/99designs/gqlgen/plugin/federation/fieldset/fieldset.go
@@ -46,7 +46,10 @@ func New(raw string, prefix []string) Set {
}
// FieldDefinition looks up a field in the type.
-func (f Field) FieldDefinition(schemaType *ast.Definition, schema *ast.Schema) *ast.FieldDefinition {
+func (f Field) FieldDefinition(
+ schemaType *ast.Definition,
+ schema *ast.Schema,
+) *ast.FieldDefinition {
objType := schemaType
def := objType.Fields.ForName(f[0])
@@ -88,9 +91,11 @@ func (f Field) TypeReference(obj *codegen.Object, objects codegen.Objects) *code
func (f Field) ToGo() string {
var ret string
+ var retSb91 strings.Builder
for _, field := range f {
- ret += templates.ToGo(field)
+ retSb91.WriteString(templates.ToGo(field))
}
+ ret += retSb91.String()
return ret
}
@@ -98,14 +103,16 @@ func (f Field) ToGo() string {
func (f Field) ToGoPrivate() string {
var ret string
+ var retSb101 strings.Builder
for i, field := range f {
if i == 0 {
field = trimArgumentFromFieldName(field)
- ret += templates.ToGoPrivate(field)
+ retSb101.WriteString(templates.ToGoPrivate(field))
continue
}
- ret += templates.ToGo(field)
+ retSb101.WriteString(templates.ToGo(field))
}
+ ret += retSb101.String()
return ret
}
@@ -114,7 +121,8 @@ func (f Field) Join(str string) string {
return strings.Join(f, str)
}
-// JoinGo concatenates the Go name of field parts with a string separator between. Useful in templates.
+// JoinGo concatenates the Go name of field parts with a string separator between. Useful in
+// templates.
func (f Field) JoinGo(str string) string {
strs := []string{}
@@ -149,7 +157,8 @@ func parseUnnestedKeyFieldSet(raw string, prefix []string) Set {
unionField = false
}
- next := append(prefix[0:len(prefix):len(prefix)], s) //nolint:gocritic // set cap=len in order to force slice reallocation
+ next := prefix[0:len(prefix):len(prefix)]
+ next = append(next, s)
ret = append(ret, next)
}
return ret
@@ -163,7 +172,13 @@ func extractSubs(str string) (string, string, string) {
if start < 0 || end < 0 {
panic("invalid key fieldSet: " + str)
}
- return trimArgumentFromFieldName(strings.TrimSpace(str[:start])), strings.TrimSpace(str[start+1 : end]), strings.TrimSpace(str[end+1:])
+ return trimArgumentFromFieldName(
+ strings.TrimSpace(str[:start]),
+ ), strings.TrimSpace(
+ str[start+1 : end],
+ ), strings.TrimSpace(
+ str[end+1:],
+ )
}
// matchingBracketIndex returns the index of the closing bracket, assuming an open bracket at start.
diff --git a/vendor/github.com/99designs/gqlgen/plugin/modelgen/interface_graph.go b/vendor/github.com/99designs/gqlgen/plugin/modelgen/interface_graph.go
new file mode 100644
index 00000000..a3442509
--- /dev/null
+++ b/vendor/github.com/99designs/gqlgen/plugin/modelgen/interface_graph.go
@@ -0,0 +1,179 @@
+package modelgen
+
+import (
+ "errors"
+
+ "github.com/vektah/gqlparser/v2/ast"
+)
+
+// interfaceGraph tracks interface implementation relationships.
+type interfaceGraph struct {
+ schema *ast.Schema
+ parentInterfaces map[string][]string // interface -> interfaces it implements
+ childInterfaces map[string][]string // interface -> interfaces that implement it
+}
+
+func newInterfaceGraph(schema *ast.Schema) *interfaceGraph {
+ g := &interfaceGraph{
+ schema: schema,
+ parentInterfaces: make(map[string][]string),
+ childInterfaces: make(map[string][]string),
+ }
+
+ for _, schemaType := range schema.Types {
+ if schemaType.Kind != ast.Interface {
+ continue
+ }
+
+ if len(schemaType.Interfaces) == 0 {
+ g.parentInterfaces[schemaType.Name] = []string{}
+ } else {
+ g.parentInterfaces[schemaType.Name] = append([]string{}, schemaType.Interfaces...)
+ for _, parent := range schemaType.Interfaces {
+ g.childInterfaces[parent] = append(g.childInterfaces[parent], schemaType.Name)
+ }
+ }
+ }
+
+ return g
+}
+
+// topologicalSort returns interfaces ordered with parents before children.
+// Only considers relationships between interfaces in the provided list.
+func (g *interfaceGraph) topologicalSort(interfaces []string) ([]string, error) {
+ interfaceSet := make(map[string]bool)
+ for _, iface := range interfaces {
+ interfaceSet[iface] = true
+ }
+
+ inDegree := make(map[string]int)
+ for _, iface := range interfaces {
+ count := 0
+ for _, parent := range g.parentInterfaces[iface] {
+ if interfaceSet[parent] {
+ count++
+ }
+ }
+ inDegree[iface] = count
+ }
+
+ var queue []string
+ for _, iface := range interfaces {
+ if inDegree[iface] == 0 {
+ queue = append(queue, iface)
+ }
+ }
+
+ var result []string
+ for len(queue) > 0 {
+ current := queue[0]
+ queue = queue[1:]
+ result = append(result, current)
+
+ for _, child := range g.childInterfaces[current] {
+ if interfaceSet[child] {
+ inDegree[child]--
+ if inDegree[child] == 0 {
+ queue = append(queue, child)
+ }
+ }
+ }
+ }
+
+ if len(result) != len(interfaces) {
+ return nil, errors.New("cycle detected in interface implementations")
+ }
+
+ return result, nil
+}
+
+// embeddingInfo contains information about interface embedding relationships.
+type embeddingInfo struct {
+ Parents []string // embeddable parent interfaces with goEmbedInterface directive
+ SkippedFields []*ast.FieldDefinition // fields from intermediate parents without the directive
+}
+
+// getInterfaceOwnFields returns only the fields that are not inherited from parent interfaces.
+func (g *interfaceGraph) getInterfaceOwnFields(interfaceName string) []*ast.FieldDefinition {
+ schemaInterface := g.schema.Types[interfaceName]
+ if schemaInterface == nil || schemaInterface.Kind != ast.Interface {
+ return nil
+ }
+
+ parents := g.parentInterfaces[interfaceName]
+ if len(parents) == 0 {
+ return schemaInterface.Fields
+ }
+
+ parentFieldNames := make(map[string]bool)
+ for _, parentName := range parents {
+ parentInterface := g.schema.Types[parentName]
+ if parentInterface == nil {
+ continue
+ }
+ for _, field := range parentInterface.Fields {
+ parentFieldNames[field.Name] = true
+ }
+ }
+
+ ownFields := []*ast.FieldDefinition{}
+ for _, field := range schemaInterface.Fields {
+ if !parentFieldNames[field.Name] {
+ ownFields = append(ownFields, field)
+ }
+ }
+
+ return ownFields
+}
+
+// getEmbeddingInfo returns information about embeddable parent interfaces and fields
+// from intermediate parents that don't have the goEmbedInterface directive.
+func (g *interfaceGraph) getEmbeddingInfo(interfaceName string) embeddingInfo {
+ info := embeddingInfo{
+ Parents: []string{},
+ SkippedFields: []*ast.FieldDefinition{},
+ }
+ visited := make(map[string]bool)
+
+ var walkParents func(name string)
+ walkParents = func(name string) {
+ if visited[name] {
+ return
+ }
+ visited[name] = true
+
+ parentDef := g.schema.Types[name]
+ if parentDef == nil || parentDef.Kind != ast.Interface {
+ return
+ }
+
+ // Check if this parent has the directive (is embeddable)
+ if g.isEmbeddable(name) {
+ info.Parents = append(info.Parents, name)
+ } else {
+ // Not embeddable - collect its fields and walk up
+ info.SkippedFields = append(info.SkippedFields, g.getInterfaceOwnFields(name)...)
+ for _, grandparent := range parentDef.Interfaces {
+ walkParents(grandparent)
+ }
+ }
+ }
+
+ currentDef := g.schema.Types[interfaceName]
+ if currentDef != nil {
+ for _, parent := range currentDef.Interfaces {
+ walkParents(parent)
+ }
+ }
+
+ return info
+}
+
+// isEmbeddable returns true if the interface has the goEmbedInterface directive.
+func (g *interfaceGraph) isEmbeddable(interfaceName string) bool {
+ iface := g.schema.Types[interfaceName]
+ if iface == nil || iface.Kind != ast.Interface {
+ return false
+ }
+ return iface.Directives.ForName("goEmbedInterface") != nil
+}
diff --git a/vendor/github.com/99designs/gqlgen/plugin/modelgen/models.go b/vendor/github.com/99designs/gqlgen/plugin/modelgen/models.go
index 229c2261..4ae537d0 100644
--- a/vendor/github.com/99designs/gqlgen/plugin/modelgen/models.go
+++ b/vendor/github.com/99designs/gqlgen/plugin/modelgen/models.go
@@ -24,7 +24,8 @@ type (
FieldMutateHook = func(td *ast.Definition, fd *ast.FieldDefinition, f *Field) (*Field, error)
)
-// DefaultFieldMutateHook is the default hook for the Plugin which applies the GoFieldHook and GoTagFieldHook.
+// DefaultFieldMutateHook is the default hook for the Plugin which applies the GoFieldHook and
+// GoTagFieldHook.
func DefaultFieldMutateHook(td *ast.Definition, fd *ast.FieldDefinition, f *Field) (*Field, error) {
return GoTagFieldHook(td, fd, f)
}
@@ -104,73 +105,53 @@ func (m *Plugin) MutateConfig(cfg *config.Config) error {
PackageName: cfg.Model.Package,
}
+ cfg.Directives["goEmbedInterface"] = config.DirectiveConfig{SkipRuntime: true}
+
+ binder := cfg.NewBinder()
+
+ // Generate Base structs for interfaces if embedded structs are enabled
+ embedder := newEmbeddedInterfaceGenerator(cfg, binder, nil, b)
+ specs, err := embedder.generateAllInterfaceBaseStructs()
+ if err != nil {
+ return err
+ }
+
+ for _, spec := range specs {
+ obj, err := m.buildBaseObjectFromSpec(cfg, binder, spec)
+ if err != nil {
+ return err
+ }
+ if obj != nil {
+ b.Models = append(b.Models, obj)
+ }
+ }
+
+ for _, schemaType := range cfg.Schema.Types {
+ userDefined := cfg.Models.UserDefined(schemaType.Name)
+ switch schemaType.Kind {
+ case ast.Interface, ast.Union:
+ if !userDefined {
+ it, err := m.getInterface(cfg, schemaType)
+ if err != nil {
+ return err
+ }
+ b.Interfaces = append(b.Interfaces, it)
+ }
+ }
+ }
+
for _, schemaType := range cfg.Schema.Types {
if cfg.Models.UserDefined(schemaType.Name) {
continue
}
switch schemaType.Kind {
- case ast.Interface, ast.Union:
- var fields []*Field
- var err error
- if !cfg.OmitGetters {
- fields, err = m.generateFields(cfg, schemaType)
- if err != nil {
- return err
- }
- }
-
- it := &Interface{
- Description: schemaType.Description,
- Name: schemaType.Name,
- Implements: schemaType.Interfaces,
- Fields: fields,
- OmitCheck: cfg.OmitInterfaceChecks,
- }
-
- // if the interface has a key directive as an entity interface, allow it to implement _Entity
- if schemaType.Directives.ForName("key") != nil {
- it.Implements = append(it.Implements, "_Entity")
- }
-
- b.Interfaces = append(b.Interfaces, it)
case ast.Object, ast.InputObject:
- if cfg.IsRoot(schemaType) {
- if !cfg.OmitRootModels {
- b.Models = append(b.Models, &Object{
- Description: schemaType.Description,
- Name: schemaType.Name,
- })
- }
- continue
- }
-
- fields, err := m.generateFields(cfg, schemaType)
+ it, err := m.getObject(cfg, schemaType, b)
if err != nil {
return err
}
-
- it := &Object{
- Description: schemaType.Description,
- Name: schemaType.Name,
- Fields: fields,
- }
-
- // If Interface A implements interface B, and Interface C also implements interface B
- // then both A and C have methods of B.
- // The reason for checking unique is to prevent the same method B from being generated twice.
- uniqueMap := map[string]bool{}
- for _, implementor := range cfg.Schema.GetImplements(schemaType) {
- if !uniqueMap[implementor.Name] {
- it.Implements = append(it.Implements, implementor.Name)
- uniqueMap[implementor.Name] = true
- }
- // for interface implements
- for _, iface := range implementor.Interfaces {
- if !uniqueMap[iface] {
- it.Implements = append(it.Implements, iface)
- uniqueMap[iface] = true
- }
- }
+ if it == nil {
+ continue
}
b.Models = append(b.Models, it)
@@ -192,21 +173,26 @@ func (m *Plugin) MutateConfig(cfg *config.Config) error {
b.Scalars = append(b.Scalars, schemaType.Name)
}
}
+
sort.Slice(b.Enums, func(i, j int) bool { return b.Enums[i].Name < b.Enums[j].Name })
sort.Slice(b.Models, func(i, j int) bool { return b.Models[i].Name < b.Models[j].Name })
- sort.Slice(b.Interfaces, func(i, j int) bool { return b.Interfaces[i].Name < b.Interfaces[j].Name })
+ sort.Slice(
+ b.Interfaces,
+ func(i, j int) bool { return b.Interfaces[i].Name < b.Interfaces[j].Name },
+ )
- // if we are not just turning all struct-type fields in generated structs into pointers, we need to at least
+ // if we are not just turning all struct-type fields in generated structs into pointers, we need
+ // to at least
// check for cyclical relationships and recursive structs
if !cfg.StructFieldsAlwaysPointers {
findAndHandleCyclicalRelationships(b)
}
for _, it := range b.Enums {
- cfg.Models.Add(it.Name, cfg.Model.ImportPath()+"."+templates.ToGo(it.Name))
+ cfg.Models.Add(it.Name, cfg.Model.ImportPath()+"."+templates.ToGoModelName(it.Name))
}
for _, it := range b.Models {
- cfg.Models.Add(it.Name, cfg.Model.ImportPath()+"."+templates.ToGo(it.Name))
+ cfg.Models.Add(it.Name, cfg.Model.ImportPath()+"."+templates.ToGoModelName(it.Name))
}
for _, it := range b.Interfaces {
// On a given interface we want to keep a reference to all the models that implement it
@@ -221,7 +207,7 @@ func (m *Plugin) MutateConfig(cfg *config.Config) error {
}
}
}
- cfg.Models.Add(it.Name, cfg.Model.ImportPath()+"."+templates.ToGo(it.Name))
+ cfg.Models.Add(it.Name, cfg.Model.ImportPath()+"."+templates.ToGoModelName(it.Name))
}
for _, it := range b.Scalars {
cfg.Models.Add(it, "github.com/99designs/gqlgen/graphql.String")
@@ -274,10 +260,22 @@ func (m *Plugin) MutateConfig(cfg *config.Config) error {
}
goType := templates.CurrentImports.LookupType(field.Type)
if strings.HasPrefix(goType, "[]") {
- getter := fmt.Sprintf("func (this %s) Get%s() %s {\n", templates.ToGo(model.Name), field.GoName, goType)
+ getter := fmt.Sprintf(
+ "func (this %s) Get%s() %s {\n",
+ templates.ToGoModelName(model.Name),
+ field.GoName,
+ goType,
+ )
getter += fmt.Sprintf("\tif this.%s == nil { return nil }\n", field.GoName)
- getter += fmt.Sprintf("\tinterfaceSlice := make(%s, 0, len(this.%s))\n", goType, field.GoName)
- getter += fmt.Sprintf("\tfor _, concrete := range this.%s { interfaceSlice = append(interfaceSlice, ", field.GoName)
+ getter += fmt.Sprintf(
+ "\tinterfaceSlice := make(%s, 0, len(this.%s))\n",
+ goType,
+ field.GoName,
+ )
+ getter += fmt.Sprintf(
+ "\tfor _, concrete := range this.%s { interfaceSlice = append(interfaceSlice, ",
+ field.GoName,
+ )
if interfaceFieldTypeIsPointer && !structFieldTypeIsPointer {
getter += "&"
} else if !interfaceFieldTypeIsPointer && structFieldTypeIsPointer {
@@ -288,7 +286,12 @@ func (m *Plugin) MutateConfig(cfg *config.Config) error {
getter += "}"
return getter
}
- getter := fmt.Sprintf("func (this %s) Get%s() %s { return ", templates.ToGo(model.Name), field.GoName, goType)
+ getter := fmt.Sprintf(
+ "func (this %s) Get%s() %s { return ",
+ templates.ToGoModelName(model.Name),
+ field.GoName,
+ goType,
+ )
if interfaceFieldTypeIsPointer && !structFieldTypeIsPointer {
getter += "&"
@@ -308,7 +311,7 @@ func (m *Plugin) MutateConfig(cfg *config.Config) error {
newModelTemplate = readModelTemplate(cfg.Model.ModelTemplate)
}
- err := templates.Render(templates.Options{
+ err = templates.Render(templates.Options{
PackageName: cfg.Model.Package,
Filename: cfg.Model.Filename,
Data: b,
@@ -328,11 +331,28 @@ func (m *Plugin) MutateConfig(cfg *config.Config) error {
return nil
}
-func (m *Plugin) generateFields(cfg *config.Config, schemaType *ast.Definition) ([]*Field, error) {
+func (m *Plugin) generateFields(
+ cfg *config.Config,
+ schemaType *ast.Definition,
+ model *ModelBuild,
+) ([]*Field, error) {
binder := cfg.NewBinder()
+ embeddedGen := newEmbeddedInterfaceGenerator(cfg, binder, schemaType, model)
+
fields := make([]*Field, 0)
+ embeddedFieldMap := embeddedGen.generateEmbeddedFields(schemaType.Fields)
for _, field := range schemaType.Fields {
+ if embeddedField, isEmbedded := embeddedFieldMap[field.Name]; isEmbedded {
+ // First field of interface gets the embedded base struct
+ if embeddedField != nil {
+ fields = append(fields, embeddedField)
+ }
+ // Skip this field (either it's first with embedded field, or subsequent field from same
+ // interface)
+ continue
+ }
+
f, err := m.generateField(cfg, binder, schemaType, field)
if err != nil {
return nil, err
@@ -394,7 +414,7 @@ func (m *Plugin) generateField(
case ast.Object, ast.InputObject:
// no user defined model, must reference a generated struct
typ = types.NewNamed(
- types.NewTypeName(0, cfg.Model.Pkg(), templates.ToGo(field.Type.Name()), nil),
+ types.NewTypeName(0, cfg.Model.Pkg(), templates.ToGoModelName(field.Type.Name()), nil),
types.NewStruct(nil, nil),
nil,
)
@@ -428,8 +448,9 @@ func (m *Plugin) generateField(
Type: typ,
Description: field.Description,
Tag: getStructTagFromField(cfg, field),
- Omittable: cfg.NullableInputOmittable && schemaType.Kind == ast.InputObject && !field.Type.NonNull,
- IsResolver: cfg.Models[schemaType.Name].Fields[field.Name].Resolver,
+ Omittable: cfg.NullableInputOmittable && schemaType.Kind == ast.InputObject &&
+ !field.Type.NonNull,
+ IsResolver: cfg.Models[schemaType.Name].Fields[field.Name].Resolver,
}
if omittable := cfg.Models[schemaType.Name].Fields[field.Name].Omittable; omittable != nil {
@@ -441,6 +462,12 @@ func (m *Plugin) generateField(
if err != nil {
return nil, fmt.Errorf("generror: field %v.%v: %w", schemaType.Name, field.Name, err)
}
+
+ if mf == nil {
+ // the field hook wants to omit the field
+ return nil, nil
+ }
+
f = mf
}
@@ -450,10 +477,16 @@ func (m *Plugin) generateField(
if f.Omittable {
if schemaType.Kind != ast.InputObject || field.Type.NonNull {
- return nil, fmt.Errorf("generror: field %v.%v: omittable is only applicable to nullable input fields", schemaType.Name, field.Name)
+ return nil, fmt.Errorf(
+ "generror: field %v.%v: omittable is only applicable to nullable input fields",
+ schemaType.Name,
+ field.Name,
+ )
}
- omittableType, err := binder.FindTypeFromName("github.com/99designs/gqlgen/graphql.Omittable")
+ omittableType, err := binder.FindTypeFromName(
+ "github.com/99designs/gqlgen/graphql.Omittable",
+ )
if err != nil {
return nil, err
}
@@ -528,11 +561,13 @@ func getExtraFields(cfg *config.Config, modelName string) []*Field {
func getStructTagFromField(cfg *config.Config, field *ast.FieldDefinition) string {
var tags []string
- if !field.Type.NonNull && (cfg.EnableModelJsonOmitemptyTag == nil || *cfg.EnableModelJsonOmitemptyTag) {
+ if !field.Type.NonNull &&
+ (cfg.EnableModelJsonOmitemptyTag == nil || *cfg.EnableModelJsonOmitemptyTag) {
tags = append(tags, "omitempty")
}
- if !field.Type.NonNull && (cfg.EnableModelJsonOmitzeroTag == nil || *cfg.EnableModelJsonOmitzeroTag) {
+ if !field.Type.NonNull &&
+ (cfg.EnableModelJsonOmitzeroTag == nil || *cfg.EnableModelJsonOmitzeroTag) {
tags = append(tags, "omitzero")
}
@@ -634,10 +669,16 @@ func removeDuplicateTags(t string) string {
// iterate backwards through tags so appended goTag directives are prioritized
for i := len(tt) - 1; i >= 0; i-- {
ti := tt[i]
- // check if ti contains ":", and not contains any empty space. if not, tag is in wrong format
+ // check if ti contains ":", and not contains any empty space. if not, tag is in wrong
+ // format
// correct example: json:"name"
if !strings.Contains(ti, ":") {
- panic(fmt.Errorf("wrong format of tags: %s. goTag directive should be in format: @goTag(key: \"something\", value:\"value\"), ", t))
+ panic(
+ fmt.Errorf(
+ "wrong format of tags: %s. goTag directive should be in format: @goTag(key: \"something\", value:\"value\"), ",
+ t,
+ ),
+ )
}
kv := strings.Split(ti, ":")
@@ -654,7 +695,12 @@ func removeDuplicateTags(t string) string {
isContained := containsInvalidSpace(value)
if isContained {
- panic(fmt.Errorf("tag value should not contain any leading or trailing spaces: %s", value))
+ panic(
+ fmt.Errorf(
+ "tag value should not contain any leading or trailing spaces: %s",
+ value,
+ ),
+ )
}
returnTags = key + ":" + value + returnTags
@@ -674,7 +720,8 @@ func isStruct(t types.Type) bool {
return is
}
-// findAndHandleCyclicalRelationships checks for cyclical relationships between generated structs and replaces them
+// findAndHandleCyclicalRelationships checks for cyclical relationships between generated structs
+// and replaces them
// with pointers. These relationships will produce compilation errors if they are not pointers.
// Also handles recursive structs.
func findAndHandleCyclicalRelationships(b *ModelBuild) {
@@ -687,9 +734,11 @@ func findAndHandleCyclicalRelationships(b *ModelBuild) {
continue
}
- // the field Type string will be in the form "github.com/99designs/gqlgen/codegen/testserver/followschema.LoopA"
+ // the field Type string will be in the form
+ // "github.com/99designs/gqlgen/codegen/testserver/followschema.LoopA"
// we only want the part after the last dot: "LoopA"
- // this could lead to false positives, as we are only checking the name of the struct type, but these
+ // this could lead to false positives, as we are only checking the name of the struct
+ // type, but these
// should be extremely rare, if it is even possible at all.
fieldAStructNameParts := strings.Split(fieldA.Type.String(), ".")
fieldAStructName := fieldAStructNameParts[len(fieldAStructNameParts)-1]
@@ -716,7 +765,8 @@ func findAndHandleCyclicalRelationships(b *ModelBuild) {
}
}
- // if this is a recursive struct (i.e. structA == structB), ensure that we only change this field to a pointer once
+ // if this is a recursive struct (i.e. structA == structB), ensure that we only
+ // change this field to a pointer once
if cyclicalReferenceFound && ii != jj {
fieldA.Type = types.NewPointer(fieldA.Type)
break
@@ -733,3 +783,116 @@ func readModelTemplate(customModelTemplate string) string {
}
return string(contentBytes)
}
+
+func (m *Plugin) getInterface(
+ cfg *config.Config,
+ schemaType *ast.Definition,
+) (*Interface, error) {
+ var fields []*Field
+ var err error
+ if !cfg.OmitGetters {
+ fields, err = m.generateFields(cfg, schemaType, nil)
+ if err != nil {
+ return nil, err
+ }
+ }
+
+ it := &Interface{
+ Description: schemaType.Description,
+ Name: schemaType.Name,
+ Implements: schemaType.Interfaces,
+ Fields: fields,
+ OmitCheck: cfg.OmitInterfaceChecks,
+ }
+
+ // if the interface has a key directive as an entity interface, allow it to implement _Entity
+ if schemaType.Directives.ForName("key") != nil {
+ it.Implements = append(it.Implements, "_Entity")
+ }
+
+ return it, nil
+}
+
+func (m *Plugin) getObject(
+ cfg *config.Config,
+ schemaType *ast.Definition,
+ b *ModelBuild,
+) (*Object, error) {
+ if cfg.IsRoot(schemaType) {
+ if !cfg.OmitRootModels {
+ return &Object{
+ Description: schemaType.Description,
+ Name: schemaType.Name,
+ }, nil
+ }
+
+ return nil, nil
+ }
+
+ fields, err := m.generateFields(cfg, schemaType, b)
+ if err != nil {
+ return nil, err
+ }
+
+ it := &Object{
+ Description: schemaType.Description,
+ Name: schemaType.Name,
+ Fields: fields,
+ }
+
+ // If Interface A implements interface B, and Interface C also implements interface B
+ // then both A and C have methods of B.
+ // The reason for checking unique is to prevent the same method B from being generated twice.
+ uniqueMap := map[string]bool{}
+ for _, implementor := range cfg.Schema.GetImplements(schemaType) {
+ if !uniqueMap[implementor.Name] {
+ it.Implements = append(it.Implements, implementor.Name)
+ uniqueMap[implementor.Name] = true
+ }
+ // for interface implements
+ for _, iface := range implementor.Interfaces {
+ if !uniqueMap[iface] {
+ it.Implements = append(it.Implements, iface)
+ uniqueMap[iface] = true
+ }
+ }
+ }
+
+ return it, nil
+}
+
+func (m *Plugin) buildBaseObjectFromSpec(
+ cfg *config.Config,
+ binder *config.Binder,
+ spec *baseStructSpec,
+) (*Object, error) {
+ fields := make([]*Field, 0)
+
+ for _, parentType := range spec.ParentEmbeddings {
+ fields = append(fields, &Field{
+ Name: "",
+ GoName: "", // Empty GoName creates anonymous embedding
+ Type: parentType,
+ })
+ }
+
+ // Generate fields from schema definitions
+ for _, fieldDef := range spec.FieldsToGenerate {
+ f, err := m.generateField(cfg, binder, spec.SchemaType, fieldDef)
+ if err != nil {
+ return nil, err
+ }
+ if f != nil {
+ fields = append(fields, f)
+ }
+ }
+
+ fields = append(fields, getExtraFields(cfg, spec.SchemaType.Name)...)
+
+ return &Object{
+ Description: spec.SchemaType.Description,
+ Name: fmt.Sprintf("%s%s", cfg.EmbeddedStructsPrefix, spec.SchemaType.Name),
+ Fields: fields,
+ Implements: spec.ImplementsInterfaces,
+ }, nil
+}
diff --git a/vendor/github.com/99designs/gqlgen/plugin/modelgen/models.gotpl b/vendor/github.com/99designs/gqlgen/plugin/modelgen/models.gotpl
index 5ce295d4..1a3cae3b 100644
--- a/vendor/github.com/99designs/gqlgen/plugin/modelgen/models.gotpl
+++ b/vendor/github.com/99designs/gqlgen/plugin/modelgen/models.gotpl
@@ -37,7 +37,7 @@
{{- with .Description }}
{{.|prefixLines "// "}}
{{- end}}
- {{ $field.GoName }} {{$field.Type | ref}} `{{$field.Tag}}`
+ {{ if $field.GoName }}{{ $field.GoName }} {{ end }}{{$field.Type | ref}}{{ if $field.Tag }} `{{$field.Tag}}`{{ end }}
{{- end }}
}
diff --git a/vendor/github.com/99designs/gqlgen/plugin/modelgen/models_interface_embedder.go b/vendor/github.com/99designs/gqlgen/plugin/modelgen/models_interface_embedder.go
new file mode 100644
index 00000000..19f054b9
--- /dev/null
+++ b/vendor/github.com/99designs/gqlgen/plugin/modelgen/models_interface_embedder.go
@@ -0,0 +1,301 @@
+package modelgen
+
+import (
+ "fmt"
+ "go/types"
+ "log"
+ "sort"
+
+ "github.com/vektah/gqlparser/v2/ast"
+
+ "github.com/99designs/gqlgen/codegen/config"
+ "github.com/99designs/gqlgen/codegen/templates"
+ "github.com/99designs/gqlgen/internal/code"
+)
+
+// embeddedInterfaceGenerator generates Base structs for interfaces to enable embedding.
+type embeddedInterfaceGenerator struct {
+ cfg *config.Config
+ binder *config.Binder
+ schemaType *ast.Definition
+ model *ModelBuild
+ graph *interfaceGraph
+}
+
+func newEmbeddedInterfaceGenerator(
+ cfg *config.Config,
+ binder *config.Binder,
+ schemaType *ast.Definition,
+ model *ModelBuild,
+) *embeddedInterfaceGenerator {
+ return &embeddedInterfaceGenerator{
+ cfg: cfg,
+ binder: binder,
+ schemaType: schemaType,
+ model: model,
+ graph: newInterfaceGraph(cfg.Schema),
+ }
+}
+
+// generateAllInterfaceBaseStructs returns Base struct specs ordered with parents before children.
+func (g *embeddedInterfaceGenerator) generateAllInterfaceBaseStructs() ([]*baseStructSpec, error) {
+ // Filter to only embeddable interfaces (have directive) and not bound to external packages
+ var interfaceNames []string
+ for name := range g.graph.parentInterfaces {
+ // Only include interfaces with directive
+ if g.graph.isEmbeddable(name) {
+ // Skip interfaces bound to external packages - their Base structs already exist there
+ if !g.cfg.Models.UserDefined(name) {
+ interfaceNames = append(interfaceNames, name)
+ }
+ }
+ }
+
+ sorted, err := g.graph.topologicalSort(interfaceNames)
+ if err != nil {
+ return nil, fmt.Errorf("failed to sort interfaces: %w", err)
+ }
+
+ var specs []*baseStructSpec
+ for _, name := range sorted {
+ spec, err := g.generateBaseStructForInterface(g.cfg.Schema.Types[name])
+ if err != nil {
+ return nil, err
+ }
+ if spec != nil {
+ specs = append(specs, spec)
+ }
+ }
+
+ return specs, nil
+}
+
+// baseStructSpec defines Base struct structure for an interface
+type baseStructSpec struct {
+ SchemaType *ast.Definition
+ ParentEmbeddings []types.Type
+ FieldsToGenerate []*ast.FieldDefinition
+ ImplementsInterfaces []string
+}
+
+func (g *embeddedInterfaceGenerator) generateBaseStructForInterface(
+ schemaType *ast.Definition,
+) (*baseStructSpec, error) {
+ if schemaType.Kind != ast.Interface {
+ return nil, fmt.Errorf(
+ "generateBaseStructForInterface called on non-interface type: %s",
+ schemaType.Name,
+ )
+ }
+
+ spec := &baseStructSpec{
+ SchemaType: schemaType,
+ FieldsToGenerate: g.graph.getInterfaceOwnFields(schemaType.Name),
+ ImplementsInterfaces: []string{schemaType.Name},
+ }
+
+ // Get embeddable parents and fields from skipped intermediate parents
+ embedInfo := g.graph.getEmbeddingInfo(schemaType.Name)
+
+ if len(embedInfo.Parents) > 1 {
+ log.Printf(
+ "WARN: Base%s: implements %d interfaces %v (potential diamond problem)",
+ schemaType.Name,
+ len(embedInfo.Parents),
+ embedInfo.Parents,
+ )
+ }
+
+ for _, parent := range embedInfo.Parents {
+ spec.ParentEmbeddings = append(spec.ParentEmbeddings, g.createParentBaseType(parent))
+ spec.ImplementsInterfaces = append(spec.ImplementsInterfaces, parent)
+ }
+
+ // Add fields from intermediate parents without the directive
+ spec.FieldsToGenerate = append(spec.FieldsToGenerate, embedInfo.SkippedFields...)
+
+ return spec, nil
+}
+
+func (g *embeddedInterfaceGenerator) createParentBaseType(interfaceName string) types.Type {
+ baseName := templates.ToGo(fmt.Sprintf("%s%s", g.cfg.EmbeddedStructsPrefix, interfaceName))
+
+ // Check if interface is bound to external package
+ if g.cfg.Models.UserDefined(interfaceName) {
+ if models := g.cfg.Models[interfaceName]; len(models.Model) > 0 {
+ if extType, err := g.binder.FindTypeFromName(models.Model[0]); err == nil {
+ if named, ok := extType.(*types.Named); ok {
+ if pkg := named.Obj().Pkg(); pkg != nil {
+ if obj := pkg.Scope().Lookup(baseName); obj != nil {
+ if typeObj, ok := obj.(*types.TypeName); ok {
+ return typeObj.Type()
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+
+ // Default: reference local package type
+ return types.NewNamed(
+ types.NewTypeName(0, g.cfg.Model.Pkg(), baseName, nil),
+ types.NewStruct(nil, nil),
+ nil,
+ )
+}
+
+// generateEmbeddedFields returns map: field name -> embedded Base struct (or nil for subsequent
+// fields).
+// Covariant overrides prevent embedding and require explicit field generation.
+func (g *embeddedInterfaceGenerator) generateEmbeddedFields(
+ fields []*ast.FieldDefinition,
+) map[string]*Field {
+ if g.model == nil || g.schemaType.Kind != ast.Object {
+ return nil
+ }
+
+ covariantInterfaces := g.findInterfacesWithCovariantOverrides(fields)
+ result := make(map[string]*Field)
+ processed := make(map[string]bool)
+
+ for _, field := range fields {
+ interfaceName := g.findInterfaceForField(field)
+ if interfaceName == "" || covariantInterfaces[interfaceName] {
+ continue
+ }
+
+ if processed[interfaceName] {
+ result[field.Name] = nil // subsequent field from same interface
+ } else {
+ result[field.Name] = &Field{Type: g.createEmbeddedBaseType(interfaceName)}
+ processed[interfaceName] = true
+ }
+ }
+
+ return result
+}
+
+func (g *embeddedInterfaceGenerator) findInterfacesWithCovariantOverrides(
+ fields []*ast.FieldDefinition,
+) map[string]bool {
+ result := make(map[string]bool)
+
+ for _, implField := range fields {
+ for _, interfaceName := range g.schemaType.Interfaces {
+ if !g.graph.isEmbeddable(interfaceName) {
+ continue
+ }
+
+ iface := g.cfg.Schema.Types[interfaceName]
+ if iface == nil {
+ continue
+ }
+
+ for _, ifaceField := range iface.Fields {
+ if ifaceField.Name != implField.Name ||
+ typesMatch(ifaceField.Type, implField.Type) {
+ continue
+ }
+
+ if !result[interfaceName] {
+ log.Printf(
+ "WARN: %s.%s: covariant override %s -> %s (skipping Base%s embedding)",
+ g.schemaType.Name,
+ implField.Name,
+ ifaceField.Type.Name(),
+ implField.Type.Name(),
+ interfaceName,
+ )
+ }
+ result[interfaceName] = true
+ break
+ }
+ }
+ }
+
+ return result
+}
+
+// findInterfaceForField returns deepest interface containing this field with matching type.
+func (g *embeddedInterfaceGenerator) findInterfaceForField(field *ast.FieldDefinition) string {
+ interfaces := g.schemaType.Interfaces
+ if len(interfaces) == 0 {
+ return ""
+ }
+
+ // Sort deepest-first (child interfaces before parent interfaces)
+ if len(interfaces) > 1 {
+ sorted := make([]string, len(interfaces))
+ copy(sorted, interfaces)
+ sort.Slice(sorted, func(i, j int) bool {
+ depthI := len(g.cfg.Schema.Types[sorted[i]].Interfaces)
+ depthJ := len(g.cfg.Schema.Types[sorted[j]].Interfaces)
+ return depthI > depthJ
+ })
+ interfaces = sorted
+ }
+
+ for _, ifaceName := range interfaces {
+ if iface := g.cfg.Schema.Types[ifaceName]; iface != nil &&
+ (iface.Kind == ast.Interface || iface.Kind == ast.Union) {
+ if !g.graph.isEmbeddable(ifaceName) {
+ continue
+ }
+
+ for _, ifaceField := range iface.Fields {
+ if ifaceField.Name == field.Name && typesMatch(ifaceField.Type, field.Type) {
+ return ifaceName
+ }
+ }
+ }
+ }
+ return ""
+}
+
+// typesMatch checks if two GraphQL types are identical (same base type, nullability, and list
+// wrapping).
+func typesMatch(a, b *ast.Type) bool {
+ if a.Name() != b.Name() || a.NonNull != b.NonNull {
+ return false
+ }
+
+ // Base type reached
+ if a.NamedType != "" && b.NamedType != "" {
+ return true
+ }
+
+ // Both must be lists or both must not be lists
+ if (a.Elem == nil) != (b.Elem == nil) {
+ return false
+ }
+
+ // Recursively check list element types
+ if a.Elem != nil {
+ return typesMatch(a.Elem, b.Elem)
+ }
+
+ return true
+}
+
+func (g *embeddedInterfaceGenerator) createEmbeddedBaseType(interfaceName string) types.Type {
+ baseName := templates.ToGo(fmt.Sprintf("%s%s", g.cfg.EmbeddedStructsPrefix, interfaceName))
+
+ // Check if interface is bound to external package
+ if g.cfg.Models.UserDefined(interfaceName) {
+ if pkgPath, _ := code.PkgAndType(g.cfg.Models[interfaceName].Model[0]); pkgPath != "" {
+ if boundType, _ := g.binder.FindTypeFromName(
+ pkgPath + "." + baseName,
+ ); boundType != nil {
+ return boundType
+ }
+ }
+ }
+
+ // Default: reference local package type
+ return types.NewNamed(
+ types.NewTypeName(0, g.cfg.Model.Pkg(), baseName, nil),
+ types.NewStruct(nil, nil),
+ nil,
+ )
+}
diff --git a/vendor/github.com/99designs/gqlgen/plugin/plugin.go b/vendor/github.com/99designs/gqlgen/plugin/plugin.go
index f127e75e..f71bb131 100644
--- a/vendor/github.com/99designs/gqlgen/plugin/plugin.go
+++ b/vendor/github.com/99designs/gqlgen/plugin/plugin.go
@@ -29,6 +29,7 @@ type CodeGenerator interface {
}
// EarlySourceInjector is used to inject things that are required for user schema files to compile.
+//
// Deprecated: Use EarlySourcesInjector instead
type EarlySourceInjector interface {
InjectSourceEarly() *ast.Source
@@ -40,7 +41,7 @@ type EarlySourcesInjector interface {
}
// LateSourceInjector is used to inject more sources, after we have loaded the users schema.
-// Deprecated: Use LateSourcesInjector instead
+// // Deprecated: Use LateSourcesInjector instead
type LateSourceInjector interface {
InjectSourceLate(schema *ast.Schema) *ast.Source
}
diff --git a/vendor/github.com/99designs/gqlgen/plugin/resolvergen/resolver.go b/vendor/github.com/99designs/gqlgen/plugin/resolvergen/resolver.go
index 4aec3071..5074ddd9 100644
--- a/vendor/github.com/99designs/gqlgen/plugin/resolvergen/resolver.go
+++ b/vendor/github.com/99designs/gqlgen/plugin/resolvergen/resolver.go
@@ -69,7 +69,9 @@ func (m *Plugin) generateSingleFile(data *codegen.Data) error {
for _, o := range data.Objects {
if o.HasResolvers() {
caser := cases.Title(language.English, cases.NoLower)
- rewriter.MarkStructCopied(templates.LcFirst(o.Name) + templates.UcFirst(data.Config.Resolver.Type))
+ rewriter.MarkStructCopied(
+ templates.LcFirst(o.Name) + templates.UcFirst(data.Config.Resolver.Type),
+ )
rewriter.GetMethodBody(data.Config.Resolver.Type, caser.String(o.Name))
file.Objects = append(file.Objects, o)
@@ -81,10 +83,19 @@ func (m *Plugin) generateSingleFile(data *codegen.Data) error {
}
structName := templates.LcFirst(o.Name) + templates.UcFirst(data.Config.Resolver.Type)
- comment := strings.TrimSpace(strings.TrimLeft(rewriter.GetMethodComment(structName, f.GoFieldName), `\`))
+ comment := strings.TrimSpace(
+ strings.TrimLeft(rewriter.GetMethodComment(structName, f.GoFieldName), `\`),
+ )
implementation := strings.TrimSpace(rewriter.GetMethodBody(structName, f.GoFieldName))
if implementation != "" {
- resolver := Resolver{o, f, rewriter.GetPrevDecl(structName, f.GoFieldName), comment, implementation, nil}
+ resolver := Resolver{
+ o,
+ f,
+ rewriter.GetPrevDecl(structName, f.GoFieldName),
+ comment,
+ implementation,
+ nil,
+ }
file.Resolvers = append(file.Resolvers, &resolver)
} else {
resolver := Resolver{o, f, nil, "", `panic("not implemented")`, nil}
@@ -141,7 +152,11 @@ func (m *Plugin) generatePerSchema(data *codegen.Data) error {
for _, o := range objects {
if o.HasResolvers() {
- fnCase := gqlToResolverName(data.Config.Resolver.Dir(), o.Position.Src.Name, data.Config.Resolver.FilenameTemplate)
+ fnCase := gqlToResolverName(
+ data.Config.Resolver.Dir(),
+ o.Position.Src.Name,
+ data.Config.Resolver.FilenameTemplate,
+ )
fn := strings.ToLower(fnCase)
if files[fn] == nil {
files[fn] = &File{
@@ -150,7 +165,9 @@ func (m *Plugin) generatePerSchema(data *codegen.Data) error {
}
caser := cases.Title(language.English, cases.NoLower)
- rewriter.MarkStructCopied(templates.LcFirst(o.Name) + templates.UcFirst(data.Config.Resolver.Type))
+ rewriter.MarkStructCopied(
+ templates.LcFirst(o.Name) + templates.UcFirst(data.Config.Resolver.Type),
+ )
rewriter.GetMethodBody(data.Config.Resolver.Type, caser.String(o.Name))
files[fn].Objects = append(files[fn].Objects, o)
}
@@ -160,9 +177,18 @@ func (m *Plugin) generatePerSchema(data *codegen.Data) error {
}
structName := templates.LcFirst(o.Name) + templates.UcFirst(data.Config.Resolver.Type)
// TODO(steve): Why do we need to trimLeft "\" here? Some bazel thing?
- comment := strings.TrimSpace(strings.TrimLeft(rewriter.GetMethodComment(structName, f.GoFieldName), `\`))
+ comment := strings.TrimSpace(
+ strings.TrimLeft(rewriter.GetMethodComment(structName, f.GoFieldName), `\`),
+ )
implementation := strings.TrimSpace(rewriter.GetMethodBody(structName, f.GoFieldName))
- resolver := Resolver{o, f, rewriter.GetPrevDecl(structName, f.GoFieldName), comment, implementation, nil}
+ resolver := Resolver{
+ o,
+ f,
+ rewriter.GetPrevDecl(structName, f.GoFieldName),
+ comment,
+ implementation,
+ nil,
+ }
var implExists bool
for _, p := range data.Plugins {
rImpl, ok := p.(plugin.ResolverImplementer)
@@ -175,7 +201,11 @@ func (m *Plugin) generatePerSchema(data *codegen.Data) error {
implExists = true
resolver.ImplementationRender = rImpl.Implement
}
- fnCase := gqlToResolverName(data.Config.Resolver.Dir(), f.Position.Src.Name, data.Config.Resolver.FilenameTemplate)
+ fnCase := gqlToResolverName(
+ data.Config.Resolver.Dir(),
+ f.Position.Src.Name,
+ data.Config.Resolver.FilenameTemplate,
+ )
fn := strings.ToLower(fnCase)
if files[fn] == nil {
files[fn] = &File{
@@ -196,7 +226,8 @@ func (m *Plugin) generatePerSchema(data *codegen.Data) error {
allImports = append(allImports, i.ImportPath)
}
}
- data.Config.Packages.LoadAllNames(allImports...) // Preload all names in one Load call for performance reasons
+ data.Config.Packages.LoadAllNames(
+ allImports...) // Preload all names in one Load call for performance reasons
newResolverTemplate := resolverTemplate
if data.Config.Resolver.ResolverTemplate != "" {
@@ -219,7 +250,8 @@ func (m *Plugin) generatePerSchema(data *codegen.Data) error {
var fileNotice strings.Builder
if !data.Config.OmitGQLGenFileNotice {
fileNotice.WriteString(`
- // This file will be automatically regenerated based on the schema, any resolver implementations
+ // This file will be automatically regenerated based on the schema, any resolver
+ // implementations
// will be copied through when generating and any unknown code will be moved to the end.
// Code generated by github.com/99designs/gqlgen`,
)
@@ -248,7 +280,8 @@ func (m *Plugin) generatePerSchema(data *codegen.Data) error {
FileNotice: `
// This file will not be regenerated automatically.
//
- // It serves as dependency injection for your app, add any dependencies you require here.`,
+ // It serves as dependency injection for your app, add any dependencies you require
+ // here.`,
Template: `type {{.}} struct {}`,
Filename: data.Config.Resolver.Filename,
Data: data.Config.Resolver.Type,
@@ -271,8 +304,9 @@ type ResolverBuild struct {
type File struct {
name string
- // These are separated because the type definition of the resolver object may live in a different file from the
- // resolver method implementations, for example when extending a type in a different graphql schema file
+ // These are separated because the type definition of the resolver object may live in a
+ // different file from the resolver method implementations, for example when extending a type in
+ // a different graphql schema file
Objects []*codegen.Object
Resolvers []*Resolver
imports []rewrite.Import
@@ -307,7 +341,11 @@ func (r *Resolver) Implementation() string {
// if not implementation was previously used, use default implementation
if r.ImplementationStr == "" {
// use default implementation, if no implementation was previously used
- return fmt.Sprintf("panic(fmt.Errorf(\"not implemented: %v - %v\"))", r.Field.GoFieldName, r.Field.Name)
+ return fmt.Sprintf(
+ "panic(fmt.Errorf(\"not implemented: %v - %v\"))",
+ r.Field.GoFieldName,
+ r.Field.Name,
+ )
}
// use previously used implementation
return r.ImplementationStr
diff --git a/vendor/github.com/caddyserver/certmagic/README.md b/vendor/github.com/caddyserver/certmagic/README.md
index 62f0c898..8c176f44 100644
--- a/vendor/github.com/caddyserver/certmagic/README.md
+++ b/vendor/github.com/caddyserver/certmagic/README.md
@@ -113,7 +113,7 @@ CertMagic - Automatic HTTPS using Let's Encrypt
- Cross-platform support! Mac, Windows, Linux, BSD, Android...
- Scales to hundreds of thousands of names/certificates per instance
- Use in conjunction with your own certificates
-- Full support for [draft-ietf-acme-ari](https://datatracker.ietf.org/doc/draft-ietf-acme-ari/) (ACME Renewal Information; ARI) extension
+- Full support for [RFC 9773](https://datatracker.ietf.org/doc/html/rfc9773) (ACME Renewal Information; ARI) extension
## Requirements
diff --git a/vendor/github.com/caddyserver/certmagic/account.go b/vendor/github.com/caddyserver/certmagic/account.go
index 7b8efa05..3e7d0cc4 100644
--- a/vendor/github.com/caddyserver/certmagic/account.go
+++ b/vendor/github.com/caddyserver/certmagic/account.go
@@ -36,9 +36,27 @@ import (
"go.uber.org/zap"
)
-// getAccount either loads or creates a new account, depending on if
+// getAccountToUse will either load or create an account based on the configuration of the issuer.
+// It will try to get one from storage if one exists, and if not, it will create one, all the while
+// honoring the configured account key PEM (if any) to restrict which account is used.
+func (iss *ACMEIssuer) getAccountToUse(ctx context.Context, directory string) (acme.Account, error) {
+ var account acme.Account
+ var err error
+ if iss.AccountKeyPEM != "" {
+ iss.Logger.Info("using configured ACME account")
+ account, err = iss.GetAccount(ctx, []byte(iss.AccountKeyPEM))
+ } else {
+ account, err = iss.loadOrCreateAccount(ctx, directory, iss.getEmail())
+ }
+ if err != nil {
+ return acme.Account{}, fmt.Errorf("getting ACME account: %v", err)
+ }
+ return account, nil
+}
+
+// loadOrCreateAccount either loads or creates a new account, depending on if
// an account can be found in storage for the given CA + email combo.
-func (am *ACMEIssuer) getAccount(ctx context.Context, ca, email string) (acme.Account, error) {
+func (am *ACMEIssuer) loadOrCreateAccount(ctx context.Context, ca, email string) (acme.Account, error) {
acct, err := am.loadAccount(ctx, ca, email)
if errors.Is(err, fs.ErrNotExist) {
am.Logger.Info("creating new account because no account for configured email is known to us",
@@ -407,7 +425,7 @@ func (am *ACMEIssuer) mostRecentAccountEmail(ctx context.Context, caURL string)
return "", false
}
- account, err := am.getAccount(ctx, caURL, path.Base(accountList[0]))
+ account, err := am.loadOrCreateAccount(ctx, caURL, path.Base(accountList[0]))
if err != nil {
return "", false
}
diff --git a/vendor/github.com/caddyserver/certmagic/acmeclient.go b/vendor/github.com/caddyserver/certmagic/acmeclient.go
index 6e1f1f7f..5f746d96 100644
--- a/vendor/github.com/caddyserver/certmagic/acmeclient.go
+++ b/vendor/github.com/caddyserver/certmagic/acmeclient.go
@@ -55,23 +55,7 @@ func (iss *ACMEIssuer) newACMEClientWithAccount(ctx context.Context, useTestCA,
// we try loading the account from storage before a potential
// lock, and after obtaining the lock as well, to ensure we don't
// repeat work done by another instance or goroutine
- getAccount := func() (acme.Account, error) {
- // look up or create the ACME account
- var account acme.Account
- if iss.AccountKeyPEM != "" {
- iss.Logger.Info("using configured ACME account")
- account, err = iss.GetAccount(ctx, []byte(iss.AccountKeyPEM))
- } else {
- account, err = iss.getAccount(ctx, client.Directory, iss.getEmail())
- }
- if err != nil {
- return acme.Account{}, fmt.Errorf("getting ACME account: %v", err)
- }
- return account, nil
- }
-
- // first try getting the account
- account, err := getAccount()
+ account, err := iss.getAccountToUse(ctx, client.Directory)
if err != nil {
return nil, err
}
@@ -95,7 +79,7 @@ func (iss *ACMEIssuer) newACMEClientWithAccount(ctx context.Context, useTestCA,
}()
// if we're not the only one waiting for this account, then by this point it should already be registered and in storage; reload it
- account, err = getAccount()
+ account, err = iss.getAccountToUse(ctx, client.Directory)
if err != nil {
return nil, err
}
@@ -207,26 +191,34 @@ func (iss *ACMEIssuer) newACMEClient(useTestCA bool) (*acmez.Client, error) {
if iss.DNS01Solver == nil {
// enable HTTP-01 challenge
if !iss.DisableHTTPChallenge {
- client.ChallengeSolvers[acme.ChallengeTypeHTTP01] = distributedSolver{
- storage: iss.config.Storage,
- storageKeyIssuerPrefix: iss.storageKeyCAPrefix(client.Directory),
- solver: &httpSolver{
- handler: iss.HTTPChallengeHandler(http.NewServeMux()),
- address: net.JoinHostPort(iss.ListenHost, strconv.Itoa(iss.getHTTPPort())),
- },
+ var solver acmez.Solver = &httpSolver{
+ handler: iss.HTTPChallengeHandler(http.NewServeMux()),
+ address: net.JoinHostPort(iss.ListenHost, strconv.Itoa(iss.getHTTPPort())),
}
+ if !iss.DisableDistributedSolvers {
+ solver = distributedSolver{
+ storage: iss.config.Storage,
+ storageKeyIssuerPrefix: iss.storageKeyCAPrefix(client.Directory),
+ solver: solver,
+ }
+ }
+ client.ChallengeSolvers[acme.ChallengeTypeHTTP01] = solver
}
// enable TLS-ALPN-01 challenge
if !iss.DisableTLSALPNChallenge {
- client.ChallengeSolvers[acme.ChallengeTypeTLSALPN01] = distributedSolver{
- storage: iss.config.Storage,
- storageKeyIssuerPrefix: iss.storageKeyCAPrefix(client.Directory),
- solver: &tlsALPNSolver{
- config: iss.config,
- address: net.JoinHostPort(iss.ListenHost, strconv.Itoa(iss.getTLSALPNPort())),
- },
+ var solver acmez.Solver = &tlsALPNSolver{
+ config: iss.config,
+ address: net.JoinHostPort(iss.ListenHost, strconv.Itoa(iss.getTLSALPNPort())),
}
+ if !iss.DisableDistributedSolvers {
+ solver = distributedSolver{
+ storage: iss.config.Storage,
+ storageKeyIssuerPrefix: iss.storageKeyCAPrefix(client.Directory),
+ solver: solver,
+ }
+ }
+ client.ChallengeSolvers[acme.ChallengeTypeTLSALPN01] = solver
}
} else {
// use DNS challenge exclusively
diff --git a/vendor/github.com/caddyserver/certmagic/acmeissuer.go b/vendor/github.com/caddyserver/certmagic/acmeissuer.go
index 170156ea..233260f7 100644
--- a/vendor/github.com/caddyserver/certmagic/acmeissuer.go
+++ b/vendor/github.com/caddyserver/certmagic/acmeissuer.go
@@ -93,6 +93,15 @@ type ACMEIssuer struct {
// Disable all TLS-ALPN challenges
DisableTLSALPNChallenge bool
+ // Disable distributed solving; avoids writing
+ // challenge info to storage backend and will
+ // only use data in memory to solve the HTTP and
+ // TLS-ALPN challenges; will still attempt to
+ // solve distributed HTTP challenges blindly by
+ // using available account and challenge token
+ // as read from request URI
+ DisableDistributedSolvers bool
+
// The host (ONLY the host, not port) to listen
// on if necessary to start a listener to solve
// an ACME challenge
@@ -340,7 +349,7 @@ func (iss *ACMEIssuer) isAgreed() bool {
// IP certificates via ACME are defined in RFC 8738.
func (am *ACMEIssuer) PreCheck(ctx context.Context, names []string, interactive bool) error {
publicCAsAndIPCerts := map[string]bool{ // map of public CAs to whether they support IP certificates (last updated: Q1 2024)
- "api.letsencrypt.org": false, // https://community.letsencrypt.org/t/certificate-for-static-ip/84/2?u=mholt
+ "api.letsencrypt.org": true, // https://letsencrypt.org/2025/07/01/issuing-our-first-ip-address-certificate/
"acme.zerossl.com": false, // only supported via their API, not ACME endpoint
"api.pki.goog": true, // https://pki.goog/faq/#faq-IPCerts
"api.buypass.com": false, // https://community.buypass.com/t/h7hm76w/buypass-support-for-rfc-8738
diff --git a/vendor/github.com/caddyserver/certmagic/cache.go b/vendor/github.com/caddyserver/certmagic/cache.go
index ae48d25a..3b5cfb0b 100644
--- a/vendor/github.com/caddyserver/certmagic/cache.go
+++ b/vendor/github.com/caddyserver/certmagic/cache.go
@@ -247,7 +247,7 @@ func (certCache *Cache) unsyncedCacheCertificate(cert Certificate) {
rnd := weakrand.Intn(cacheSize)
i := 0
for _, randomCert := range certCache.cache {
- if i == rnd {
+ if i >= rnd && randomCert.managed { // don't evict manually-loaded certs
certCache.logger.Debug("cache full; evicting random certificate",
zap.Strings("removing_subjects", randomCert.Names),
zap.String("removing_hash", randomCert.hash),
@@ -365,6 +365,10 @@ func (certCache *Cache) getConfig(cert Certificate) (*Config, error) {
if err != nil {
return nil, err
}
+ if cfg == nil {
+ // this is bad if this happens, probably a programmer error (oops)
+ return nil, fmt.Errorf("no configuration associated with certificate: %v;", cert.Names)
+ }
if cfg.certCache == nil {
return nil, fmt.Errorf("config returned for certificate %v has nil cache; expected %p (this one)",
cert.Names, certCache)
diff --git a/vendor/github.com/caddyserver/certmagic/certificates.go b/vendor/github.com/caddyserver/certmagic/certificates.go
index 05b10140..2c20e4cb 100644
--- a/vendor/github.com/caddyserver/certmagic/certificates.go
+++ b/vendor/github.com/caddyserver/certmagic/certificates.go
@@ -19,6 +19,7 @@ import (
"crypto/tls"
"crypto/x509"
"encoding/json"
+ "errors"
"fmt"
"math/rand"
"net"
@@ -346,7 +347,11 @@ func (cfg *Config) CacheUnmanagedTLSCertificate(ctx context.Context, tlsCert tls
}
err = stapleOCSP(ctx, cfg.OCSP, cfg.Storage, &cert, nil)
if err != nil {
- cfg.Logger.Warn("stapling OCSP", zap.Error(err))
+ if errors.Is(err, ErrNoOCSPServerSpecified) {
+ cfg.Logger.Debug("stapling OCSP", zap.Error(err))
+ } else {
+ cfg.Logger.Warn("stapling OCSP", zap.Error(err))
+ }
}
cfg.emit(ctx, "cached_unmanaged_cert", map[string]any{"sans": cert.Names})
cert.Tags = tags
@@ -370,6 +375,37 @@ func (cfg *Config) CacheUnmanagedCertificatePEMBytes(ctx context.Context, certBy
return cert.hash, nil
}
+// CacheUnmanagedCertificatePEMBytesAsReplacement is the same as CacheUnmanagedCertificatePEMBytes,
+// but it also removes any other loaded certificates for the SANs on the certificate being cached.
+// This has the effect of using this certificate exclusively and immediately for its SANs. The SANs
+// for which the certificate should apply may optionally be passed in as well. By default, a cert
+// is used for any of its SANs.
+//
+// This method is safe for concurrent use.
+//
+// EXPERIMENTAL: Subject to change/removal.
+func (cfg *Config) CacheUnmanagedCertificatePEMBytesAsReplacement(ctx context.Context, certBytes, keyBytes []byte, tags, sans []string) (string, error) {
+ cert, err := cfg.makeCertificateWithOCSP(ctx, certBytes, keyBytes)
+ if err != nil {
+ return "", err
+ }
+ cert.Tags = tags
+ if len(sans) > 0 {
+ cert.Names = sans
+ }
+ cfg.certCache.mu.Lock()
+ for _, san := range cert.Names {
+ existingCerts := cfg.certCache.getAllMatchingCerts(san)
+ for _, existingCert := range existingCerts {
+ cfg.certCache.removeCertificate(existingCert)
+ }
+ }
+ cfg.certCache.unsyncedCacheCertificate(cert)
+ cfg.certCache.mu.Unlock()
+ cfg.emit(ctx, "cached_unmanaged_cert", map[string]any{"sans": cert.Names, "replacement": true})
+ return cert.hash, nil
+}
+
// makeCertificateFromDiskWithOCSP makes a Certificate by loading the
// certificate and key files. It fills out all the fields in
// the certificate except for the Managed and OnDemand flags.
@@ -394,7 +430,9 @@ func (cfg Config) makeCertificateWithOCSP(ctx context.Context, certPEMBlock, key
return cert, err
}
err = stapleOCSP(ctx, cfg.OCSP, cfg.Storage, &cert, certPEMBlock)
- if err != nil {
+ if errors.Is(err, ErrNoOCSPServerSpecified) {
+ cfg.Logger.Debug("stapling OCSP", zap.Error(err), zap.Strings("identifiers", cert.Names))
+ } else {
cfg.Logger.Warn("stapling OCSP", zap.Error(err), zap.Strings("identifiers", cert.Names))
}
return cert, nil
diff --git a/vendor/github.com/caddyserver/certmagic/config.go b/vendor/github.com/caddyserver/certmagic/config.go
index 1e1e840e..419b3dcb 100644
--- a/vendor/github.com/caddyserver/certmagic/config.go
+++ b/vendor/github.com/caddyserver/certmagic/config.go
@@ -490,6 +490,33 @@ func (cfg *Config) manageOne(ctx context.Context, domainName string, async bool)
return renew()
}
+// renewLockLease extends the lease duration on an existing lock if the storage
+// backend supports it. The lease duration is calculated based on the retry attempt
+// number and includes the certificate obtain timeout. This prevents locks from
+// expiring during long-running certificate operations with retries.
+func (cfg *Config) renewLockLease(ctx context.Context, storage Storage, lockKey string, attempt int) error {
+ l, ok := storage.(LockLeaseRenewer)
+ if !ok {
+ return nil
+ }
+
+ leaseDuration := maxRetryDuration
+ if attempt < len(retryIntervals) && attempt >= 0 {
+ leaseDuration = retryIntervals[attempt]
+ }
+ leaseDuration = leaseDuration + DefaultACME.CertObtainTimeout
+ log := cfg.Logger.Named("renewLockLease")
+ log.Debug("renewing lock lease", zap.String("lockKey", lockKey), zap.Int("attempt", attempt))
+
+ err := l.RenewLockLease(ctx, lockKey, leaseDuration)
+ if err == nil {
+ locksMu.Lock()
+ locks[lockKey] = storage
+ locksMu.Unlock()
+ }
+ return err
+}
+
// ObtainCertSync generates a new private key and obtains a certificate for
// name using cfg in the foreground; i.e. interactively and without retries.
// It stows the renewed certificate and its assets in storage if successful.
@@ -546,6 +573,15 @@ func (cfg *Config) obtainCert(ctx context.Context, name string, interactive bool
log.Info("lock acquired", zap.String("identifier", name))
f := func(ctx context.Context) error {
+ // renew lease on the lock if the certificate store supports it
+ attempt, ok := ctx.Value(AttemptsCtxKey).(*int)
+ if ok {
+ err = cfg.renewLockLease(ctx, cfg.Storage, lockKey, *attempt)
+ if err != nil {
+ return fmt.Errorf("unable to renew lock lease '%s': %v", lockKey, err)
+ }
+ }
+
// check if obtain is still needed -- might have been obtained during lock
if cfg.storageHasCertResourcesAnyIssuer(ctx, name) {
log.Info("certificate already exists in storage", zap.String("identifier", name))
@@ -805,6 +841,16 @@ func (cfg *Config) renewCert(ctx context.Context, name string, force, interactiv
log.Info("lock acquired", zap.String("identifier", name))
f := func(ctx context.Context) error {
+ // renew lease on the certificate store lock if the store implementation supports it;
+ // prevents the lock from being acquired by another process/instance while we're renewing
+ attempt, ok := ctx.Value(AttemptsCtxKey).(*int)
+ if ok {
+ err = cfg.renewLockLease(ctx, cfg.Storage, lockKey, *attempt)
+ if err != nil {
+ return fmt.Errorf("unable to renew lock lease '%s': %v", lockKey, err)
+ }
+ }
+
// prepare for renewal (load PEM cert, key, and meta)
certRes, err := cfg.loadCertResourceAnyIssuer(ctx, name)
if err != nil {
@@ -1112,20 +1158,29 @@ func (cfg *Config) TLSConfig() *tls.Config {
}
}
-// getChallengeInfo loads the challenge info from either the internal challenge memory
+// getACMEChallengeInfo loads the challenge info from either the internal challenge memory
// or the external storage (implying distributed solving). The second return value
// indicates whether challenge info was loaded from external storage. If true, the
// challenge is being solved in a distributed fashion; if false, from internal memory.
// If no matching challenge information can be found, an error is returned.
-func (cfg *Config) getChallengeInfo(ctx context.Context, identifier string) (Challenge, bool, error) {
+func (cfg *Config) getACMEChallengeInfo(ctx context.Context, identifier string, allowDistributed bool) (Challenge, bool, error) {
// first, check if our process initiated this challenge; if so, just return it
chalData, ok := GetACMEChallenge(identifier)
if ok {
return chalData, false, nil
}
+ // if distributed solving is disabled, and we don't have it in memory, return an error
+ if !allowDistributed {
+ return Challenge{}, false, fmt.Errorf("distributed solving disabled and no challenge information found internally for identifier: %s", identifier)
+ }
+
// otherwise, perhaps another instance in the cluster initiated it; check
- // the configured storage to retrieve challenge data
+ // the configured storage to retrieve challenge data (requires storage)
+
+ if cfg.Storage == nil {
+ return Challenge{}, false, errors.New("challenge was not initiated internally and no storage is configured for distributed solving")
+ }
var chalInfo acme.Challenge
var chalInfoBytes []byte
diff --git a/vendor/github.com/caddyserver/certmagic/filestorage.go b/vendor/github.com/caddyserver/certmagic/filestorage.go
index d3df9cf7..78ba2393 100644
--- a/vendor/github.com/caddyserver/certmagic/filestorage.go
+++ b/vendor/github.com/caddyserver/certmagic/filestorage.go
@@ -21,7 +21,6 @@ import (
"fmt"
"io"
"io/fs"
- "log"
"os"
"path"
"path/filepath"
@@ -213,7 +212,7 @@ func (s *FileStorage) Lock(ctx context.Context, name string) error {
// the previous acquirer either crashed or had some sort of failure that
// caused them to be unable to fully acquire or retain the lock, therefore
// we should treat it as if the lockfile did not exist
- log.Printf("[INFO][%s] %s: Empty lockfile (%v) - likely previous process crashed or storage medium failure; treating as stale", s, filename, err2)
+ defaultLogger.Sugar().Infof("[%s] %s: Empty lockfile (%v) - likely previous process crashed or storage medium failure; treating as stale", s, filename, err2)
}
} else if err2 != nil {
return fmt.Errorf("decoding lockfile contents: %w", err2)
@@ -235,8 +234,7 @@ func (s *FileStorage) Lock(ctx context.Context, name string) error {
// either have potential to cause infinite loops, as in caddyserver/caddy#4448,
// or must give up on perfect mutual exclusivity; however, these cases are rare,
// so we prefer the simpler solution that avoids infinite loops)
- log.Printf("[INFO][%s] Lock for '%s' is stale (created: %s, last update: %s); removing then retrying: %s",
- s, name, meta.Created, meta.Updated, filename)
+ defaultLogger.Sugar().Infof("[%s] Lock for '%s' is stale (created: %s, last update: %s); removing then retrying: %s", s, name, meta.Created, meta.Updated, filename)
if err = os.Remove(filename); err != nil { // hopefully we can replace the lock file quickly!
if !errors.Is(err, fs.ErrNotExist) {
return fmt.Errorf("unable to delete stale lockfile; deadlocked: %w", err)
@@ -311,7 +309,7 @@ func keepLockfileFresh(filename string) {
if err := recover(); err != nil {
buf := make([]byte, stackTraceBufferSize)
buf = buf[:runtime.Stack(buf, false)]
- log.Printf("panic: active locking: %v\n%s", err, buf)
+ defaultLogger.Sugar().Errorf("active locking: %v\n%s", err, buf)
}
}()
@@ -319,7 +317,7 @@ func keepLockfileFresh(filename string) {
time.Sleep(lockFreshnessInterval)
done, err := updateLockfileFreshness(filename)
if err != nil {
- log.Printf("[ERROR] Keeping lock file fresh: %v - terminating lock maintenance (lockfile: %s)", err, filename)
+ defaultLogger.Sugar().Errorf("Keeping lock file fresh: %v - terminating lock maintenance (lockfile: %s)", err, filename)
return
}
if done {
diff --git a/vendor/github.com/caddyserver/certmagic/handshake.go b/vendor/github.com/caddyserver/certmagic/handshake.go
index c8418446..d14c1382 100644
--- a/vendor/github.com/caddyserver/certmagic/handshake.go
+++ b/vendor/github.com/caddyserver/certmagic/handshake.go
@@ -599,7 +599,11 @@ func (cfg *Config) handshakeMaintenance(ctx context.Context, hello *tls.ClientHe
if err != nil {
// An error with OCSP stapling is not the end of the world, and in fact, is
// quite common considering not all certs have issuer URLs that support it.
- logger.Warn("stapling OCSP", zap.Error(err))
+ if errors.Is(err, ErrNoOCSPServerSpecified) {
+ logger.Debug("stapling OCSP", zap.Error(err))
+ } else {
+ logger.Warn("stapling OCSP", zap.Error(err))
+ }
} else {
logger.Debug("successfully stapled new OCSP response",
zap.Int("ocsp_status", cert.ocsp.Status),
@@ -849,7 +853,7 @@ func (cfg *Config) getCertFromAnyCertManager(ctx context.Context, hello *tls.Cli
// solving). True is returned if the challenge is being solved distributed (there
// is no semantic difference with distributed solving; it is mainly for logging).
func (cfg *Config) getTLSALPNChallengeCert(clientHello *tls.ClientHelloInfo) (*tls.Certificate, bool, error) {
- chalData, distributed, err := cfg.getChallengeInfo(clientHello.Context(), clientHello.ServerName)
+ chalData, distributed, err := cfg.getACMEChallengeInfo(clientHello.Context(), clientHello.ServerName, true)
if err != nil {
return nil, distributed, err
}
diff --git a/vendor/github.com/caddyserver/certmagic/httphandlers.go b/vendor/github.com/caddyserver/certmagic/httphandlers.go
index ffbda834..0e04fa48 100644
--- a/vendor/github.com/caddyserver/certmagic/httphandlers.go
+++ b/vendor/github.com/caddyserver/certmagic/httphandlers.go
@@ -15,6 +15,7 @@
package certmagic
import (
+ "fmt"
"net/http"
"net/url"
"strings"
@@ -72,18 +73,104 @@ func (am *ACMEIssuer) distributedHTTPChallengeSolver(w http.ResponseWriter, r *h
return false
}
host := hostOnly(r.Host)
- chalInfo, distributed, err := am.config.getChallengeInfo(r.Context(), host)
+ chalInfo, distributed, err := am.config.getACMEChallengeInfo(r.Context(), host, !am.DisableDistributedSolvers)
if err != nil {
+ if am.DisableDistributedSolvers {
+ // Distributed solvers are disabled, so the only way an error can be returned is if
+ // this instance didn't initiate the challenge (or if the process exited after, but
+ // either way, we don't have the challenge info). Assuming this is a legitimate
+ // challenge request, we may still be able to solve it if we can present the correct
+ // account thumbprint with the token, since the token is given to us in the URL path.
+ //
+ // NOTE: About doing this, RFC 8555 section 8.3 says:
+ //
+ // Note that because the token appears both in the request sent by the
+ // ACME server and in the key authorization in the response, it is
+ // possible to build clients that copy the token from request to
+ // response. Clients should avoid this behavior because it can lead to
+ // cross-site scripting vulnerabilities; instead, clients should be
+ // explicitly configured on a per-challenge basis. A client that does
+ // copy tokens from requests to responses MUST validate that the token
+ // in the request matches the token syntax above (e.g., that it includes
+ // only characters from the base64url alphabet).
+ //
+ // Also, since we're just blindly solving a challenge, we're unable to mitigate DNS
+ // rebinding attacks, because we don't know what host to expect in the URL. So this
+ // is not ideal, but we do at least validate the copied token is in the base64url set.
+ if strings.HasPrefix(r.URL.Path, acmeHTTPChallengeBasePath) &&
+ strings.Count(r.URL.Path, "/") == 3 &&
+ r.Method == http.MethodGet {
+ tokenStart := strings.LastIndex(r.URL.Path, "/") + 1
+ token := r.URL.Path[tokenStart:]
+ if allBase64URL(token) {
+ if err := am.solveHTTPChallengeBlindly(w, r); err != nil {
+ am.Logger.Error("solving http-01 challenge blindly",
+ zap.String("identifier", host),
+ zap.Error(err))
+ }
+ return true
+ }
+ }
+ }
+
+ // couldn't get challenge info even with distributed solver
am.Logger.Warn("looking up info for HTTP challenge",
- zap.String("host", host),
+ zap.String("uri", r.RequestURI),
+ zap.String("identifier", host),
zap.String("remote_addr", r.RemoteAddr),
zap.String("user_agent", r.Header.Get("User-Agent")),
zap.Error(err))
return false
}
+
return solveHTTPChallenge(am.Logger, w, r, chalInfo.Challenge, distributed)
}
+// solveHTTPChallengeBlindly will try to respond correctly with an http-01 challenge response.
+// The request must be an http-01 challenge request. We cannot know for sure the ACME CA that
+// is requesting this, so we have to guess as we load the account to use for a thumbprint as
+// part of the response body. It is a no-op if the last component of the URL path contains
+// characters outside of the base64url alphabet.
+func (am *ACMEIssuer) solveHTTPChallengeBlindly(w http.ResponseWriter, r *http.Request) error {
+ tokenStart := strings.LastIndex(r.URL.Path, "/") + 1
+ token := r.URL.Path[tokenStart:]
+ if allBase64URL(token) {
+ acct, err := am.getAccountToUse(r.Context(), am.CA) // assume production CA, I guess
+ if err != nil {
+ return fmt.Errorf("getting an account to use: %v", err)
+ }
+ thumbprint, err := acct.Thumbprint()
+ if err != nil {
+ return fmt.Errorf("could not encode account thumbprint: %v", err)
+ }
+ w.Header().Add("Content-Type", "text/plain")
+ _, _ = w.Write([]byte(token + "." + thumbprint))
+ r.Close = true
+ am.Logger.Info("served key authentication",
+ zap.String("identifier", hostOnly(r.Host)),
+ zap.String("challenge", "http-01"),
+ zap.String("remote", r.RemoteAddr),
+ zap.Bool("distributed", false),
+ zap.Bool("blind", true),
+ zap.String("ca", am.CA))
+ }
+ return nil
+}
+
+// allBase64URL returns true if all characters of s are in the base64url alphabet.
+func allBase64URL(s string) bool {
+ for _, c := range s {
+ if (c >= 'A' && c <= 'Z') ||
+ (c >= 'a' && c <= 'z') ||
+ (c >= '0' && c <= '9') ||
+ c == '-' || c == '_' {
+ continue
+ }
+ return false
+ }
+ return true
+}
+
// solveHTTPChallenge solves the HTTP challenge using the given challenge information.
// If the challenge is being solved in a distributed fahsion, set distributed to true for logging purposes.
// It returns true the properties of the request check out in relation to the HTTP challenge.
diff --git a/vendor/github.com/caddyserver/certmagic/maintain.go b/vendor/github.com/caddyserver/certmagic/maintain.go
index ed32ec09..a20a07f5 100644
--- a/vendor/github.com/caddyserver/certmagic/maintain.go
+++ b/vendor/github.com/caddyserver/certmagic/maintain.go
@@ -111,7 +111,7 @@ func (certCache *Cache) RenewManagedCertificates(ctx context.Context) error {
}
// the list of names on this cert should never be empty... programmer error?
- if cert.Names == nil || len(cert.Names) == 0 {
+ if len(cert.Names) == 0 {
log.Warn("certificate has no names; removing from cache", zap.String("cert_key", certKey))
deleteQueue = append(deleteQueue, cert)
continue
@@ -125,12 +125,6 @@ func (certCache *Cache) RenewManagedCertificates(ctx context.Context) error {
zap.Error(err))
continue
}
- if cfg == nil {
- // this is bad if this happens, probably a programmer error (oops)
- log.Error("no configuration associated with certificate; unable to manage",
- zap.Strings("identifiers", cert.Names))
- continue
- }
if cfg.OnDemand != nil {
continue
}
diff --git a/vendor/github.com/caddyserver/certmagic/storage.go b/vendor/github.com/caddyserver/certmagic/storage.go
index faf73153..fcff7c02 100644
--- a/vendor/github.com/caddyserver/certmagic/storage.go
+++ b/vendor/github.com/caddyserver/certmagic/storage.go
@@ -149,6 +149,16 @@ type Locker interface {
Unlock(ctx context.Context, name string) error
}
+// LockLeaseRenewer is an optional interface that can be implemented by a Storage
+// implementation to support renewing the lease on a lock. This is useful for
+// long-running operations that need to be synchronized across a cluster.
+type LockLeaseRenewer interface {
+ // RenewLockLease renews the lease on the lock for the given lockKey for the
+ // given leaseDuration. This is used to prevent the lock from being acquired
+ // by another process.
+ RenewLockLease(ctx context.Context, lockKey string, leaseDuration time.Duration) error
+}
+
// KeyInfo holds information about a key in storage.
// Key and IsTerminal are required; Modified and Size
// are optional if the storage implementation is not
diff --git a/vendor/github.com/cpuguy83/go-md2man/v2/LICENSE.md b/vendor/github.com/cpuguy83/go-md2man/v2/LICENSE.md
deleted file mode 100644
index 1cade6ce..00000000
--- a/vendor/github.com/cpuguy83/go-md2man/v2/LICENSE.md
+++ /dev/null
@@ -1,21 +0,0 @@
-The MIT License (MIT)
-
-Copyright (c) 2014 Brian Goff
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
diff --git a/vendor/github.com/cpuguy83/go-md2man/v2/md2man/debug.go b/vendor/github.com/cpuguy83/go-md2man/v2/md2man/debug.go
deleted file mode 100644
index 0ec4b12c..00000000
--- a/vendor/github.com/cpuguy83/go-md2man/v2/md2man/debug.go
+++ /dev/null
@@ -1,62 +0,0 @@
-package md2man
-
-import (
- "fmt"
- "io"
- "os"
- "strings"
-
- "github.com/russross/blackfriday/v2"
-)
-
-func fmtListFlags(flags blackfriday.ListType) string {
- knownFlags := []struct {
- name string
- flag blackfriday.ListType
- }{
- {"ListTypeOrdered", blackfriday.ListTypeOrdered},
- {"ListTypeDefinition", blackfriday.ListTypeDefinition},
- {"ListTypeTerm", blackfriday.ListTypeTerm},
- {"ListItemContainsBlock", blackfriday.ListItemContainsBlock},
- {"ListItemBeginningOfList", blackfriday.ListItemBeginningOfList},
- {"ListItemEndOfList", blackfriday.ListItemEndOfList},
- }
-
- var f []string
- for _, kf := range knownFlags {
- if flags&kf.flag != 0 {
- f = append(f, kf.name)
- flags &^= kf.flag
- }
- }
- if flags != 0 {
- f = append(f, fmt.Sprintf("Unknown(%#x)", flags))
- }
- return strings.Join(f, "|")
-}
-
-type debugDecorator struct {
- blackfriday.Renderer
-}
-
-func depth(node *blackfriday.Node) int {
- d := 0
- for n := node.Parent; n != nil; n = n.Parent {
- d++
- }
- return d
-}
-
-func (d *debugDecorator) RenderNode(w io.Writer, node *blackfriday.Node, entering bool) blackfriday.WalkStatus {
- fmt.Fprintf(os.Stderr, "%s%s %v %v\n",
- strings.Repeat(" ", depth(node)),
- map[bool]string{true: "+", false: "-"}[entering],
- node,
- fmtListFlags(node.ListFlags))
- var b strings.Builder
- status := d.Renderer.RenderNode(io.MultiWriter(&b, w), node, entering)
- if b.Len() > 0 {
- fmt.Fprintf(os.Stderr, ">> %q\n", b.String())
- }
- return status
-}
diff --git a/vendor/github.com/cpuguy83/go-md2man/v2/md2man/md2man.go b/vendor/github.com/cpuguy83/go-md2man/v2/md2man/md2man.go
deleted file mode 100644
index 5673f5c0..00000000
--- a/vendor/github.com/cpuguy83/go-md2man/v2/md2man/md2man.go
+++ /dev/null
@@ -1,24 +0,0 @@
-// Package md2man aims in converting markdown into roff (man pages).
-package md2man
-
-import (
- "os"
- "strconv"
-
- "github.com/russross/blackfriday/v2"
-)
-
-// Render converts a markdown document into a roff formatted document.
-func Render(doc []byte) []byte {
- renderer := NewRoffRenderer()
- var r blackfriday.Renderer = renderer
- if v, _ := strconv.ParseBool(os.Getenv("MD2MAN_DEBUG")); v {
- r = &debugDecorator{Renderer: r}
- }
-
- return blackfriday.Run(doc,
- []blackfriday.Option{
- blackfriday.WithRenderer(r),
- blackfriday.WithExtensions(renderer.GetExtensions()),
- }...)
-}
diff --git a/vendor/github.com/cpuguy83/go-md2man/v2/md2man/roff.go b/vendor/github.com/cpuguy83/go-md2man/v2/md2man/roff.go
deleted file mode 100644
index 4f1070fc..00000000
--- a/vendor/github.com/cpuguy83/go-md2man/v2/md2man/roff.go
+++ /dev/null
@@ -1,416 +0,0 @@
-package md2man
-
-import (
- "bufio"
- "bytes"
- "fmt"
- "io"
- "os"
- "strings"
-
- "github.com/russross/blackfriday/v2"
-)
-
-// roffRenderer implements the blackfriday.Renderer interface for creating
-// roff format (manpages) from markdown text
-type roffRenderer struct {
- listCounters []int
- firstHeader bool
- listDepth int
-}
-
-const (
- titleHeader = ".TH "
- topLevelHeader = "\n\n.SH "
- secondLevelHdr = "\n.SH "
- otherHeader = "\n.SS "
- crTag = "\n"
- emphTag = "\\fI"
- emphCloseTag = "\\fP"
- strongTag = "\\fB"
- strongCloseTag = "\\fP"
- breakTag = "\n.br\n"
- paraTag = "\n.PP\n"
- hruleTag = "\n.ti 0\n\\l'\\n(.lu'\n"
- linkTag = "\n\\[la]"
- linkCloseTag = "\\[ra]"
- codespanTag = "\\fB"
- codespanCloseTag = "\\fR"
- codeTag = "\n.EX\n"
- codeCloseTag = ".EE\n" // Do not prepend a newline character since code blocks, by definition, include a newline already (or at least as how blackfriday gives us on).
- quoteTag = "\n.PP\n.RS\n"
- quoteCloseTag = "\n.RE\n"
- listTag = "\n.RS\n"
- listCloseTag = ".RE\n"
- dtTag = "\n.TP\n"
- dd2Tag = "\n"
- tableStart = "\n.TS\nallbox;\n"
- tableEnd = ".TE\n"
- tableCellStart = "T{\n"
- tableCellEnd = "\nT}"
- tablePreprocessor = `'\" t`
-)
-
-// NewRoffRenderer creates a new blackfriday Renderer for generating roff documents
-// from markdown
-func NewRoffRenderer() *roffRenderer {
- return &roffRenderer{}
-}
-
-// GetExtensions returns the list of extensions used by this renderer implementation
-func (*roffRenderer) GetExtensions() blackfriday.Extensions {
- return blackfriday.NoIntraEmphasis |
- blackfriday.Tables |
- blackfriday.FencedCode |
- blackfriday.SpaceHeadings |
- blackfriday.Footnotes |
- blackfriday.Titleblock |
- blackfriday.DefinitionLists
-}
-
-// RenderHeader handles outputting the header at document start
-func (r *roffRenderer) RenderHeader(w io.Writer, ast *blackfriday.Node) {
- // We need to walk the tree to check if there are any tables.
- // If there are, we need to enable the roff table preprocessor.
- ast.Walk(func(node *blackfriday.Node, entering bool) blackfriday.WalkStatus {
- if node.Type == blackfriday.Table {
- out(w, tablePreprocessor+"\n")
- return blackfriday.Terminate
- }
- return blackfriday.GoToNext
- })
-
- // disable hyphenation
- out(w, ".nh\n")
-}
-
-// RenderFooter handles outputting the footer at the document end; the roff
-// renderer has no footer information
-func (r *roffRenderer) RenderFooter(w io.Writer, ast *blackfriday.Node) {
-}
-
-// RenderNode is called for each node in a markdown document; based on the node
-// type the equivalent roff output is sent to the writer
-func (r *roffRenderer) RenderNode(w io.Writer, node *blackfriday.Node, entering bool) blackfriday.WalkStatus {
- walkAction := blackfriday.GoToNext
-
- switch node.Type {
- case blackfriday.Text:
- // Special case: format the NAME section as required for proper whatis parsing.
- // Refer to the lexgrog(1) and groff_man(7) manual pages for details.
- if node.Parent != nil &&
- node.Parent.Type == blackfriday.Paragraph &&
- node.Parent.Prev != nil &&
- node.Parent.Prev.Type == blackfriday.Heading &&
- node.Parent.Prev.FirstChild != nil &&
- bytes.EqualFold(node.Parent.Prev.FirstChild.Literal, []byte("NAME")) {
- before, after, found := bytesCut(node.Literal, []byte(" - "))
- escapeSpecialChars(w, before)
- if found {
- out(w, ` \- `)
- escapeSpecialChars(w, after)
- }
- } else {
- escapeSpecialChars(w, node.Literal)
- }
- case blackfriday.Softbreak:
- out(w, crTag)
- case blackfriday.Hardbreak:
- out(w, breakTag)
- case blackfriday.Emph:
- if entering {
- out(w, emphTag)
- } else {
- out(w, emphCloseTag)
- }
- case blackfriday.Strong:
- if entering {
- out(w, strongTag)
- } else {
- out(w, strongCloseTag)
- }
- case blackfriday.Link:
- // Don't render the link text for automatic links, because this
- // will only duplicate the URL in the roff output.
- // See https://daringfireball.net/projects/markdown/syntax#autolink
- if !bytes.Equal(node.LinkData.Destination, node.FirstChild.Literal) {
- out(w, string(node.FirstChild.Literal))
- }
- // Hyphens in a link must be escaped to avoid word-wrap in the rendered man page.
- escapedLink := strings.ReplaceAll(string(node.LinkData.Destination), "-", "\\-")
- out(w, linkTag+escapedLink+linkCloseTag)
- walkAction = blackfriday.SkipChildren
- case blackfriday.Image:
- // ignore images
- walkAction = blackfriday.SkipChildren
- case blackfriday.Code:
- out(w, codespanTag)
- escapeSpecialChars(w, node.Literal)
- out(w, codespanCloseTag)
- case blackfriday.Document:
- break
- case blackfriday.Paragraph:
- if entering {
- if r.listDepth > 0 {
- // roff .PP markers break lists
- if node.Prev != nil { // continued paragraph
- if node.Prev.Type == blackfriday.List && node.Prev.ListFlags&blackfriday.ListTypeDefinition == 0 {
- out(w, ".IP\n")
- } else {
- out(w, crTag)
- }
- }
- } else if node.Prev != nil && node.Prev.Type == blackfriday.Heading {
- out(w, crTag)
- } else {
- out(w, paraTag)
- }
- } else {
- if node.Next == nil || node.Next.Type != blackfriday.List {
- out(w, crTag)
- }
- }
- case blackfriday.BlockQuote:
- if entering {
- out(w, quoteTag)
- } else {
- out(w, quoteCloseTag)
- }
- case blackfriday.Heading:
- r.handleHeading(w, node, entering)
- case blackfriday.HorizontalRule:
- out(w, hruleTag)
- case blackfriday.List:
- r.handleList(w, node, entering)
- case blackfriday.Item:
- r.handleItem(w, node, entering)
- case blackfriday.CodeBlock:
- out(w, codeTag)
- escapeSpecialChars(w, node.Literal)
- out(w, codeCloseTag)
- case blackfriday.Table:
- r.handleTable(w, node, entering)
- case blackfriday.TableHead:
- case blackfriday.TableBody:
- case blackfriday.TableRow:
- // no action as cell entries do all the nroff formatting
- return blackfriday.GoToNext
- case blackfriday.TableCell:
- r.handleTableCell(w, node, entering)
- case blackfriday.HTMLSpan:
- // ignore other HTML tags
- case blackfriday.HTMLBlock:
- if bytes.HasPrefix(node.Literal, []byte("
+//
+func svgWithoutXMLDeclaration(s scan.Bytes) bool {
+ for scan.ByteIsWS(s.Peek()) {
+ s.Advance(1)
+ }
+ for mkup.SkipAComment(&s) {
+ }
+ if !bytes.HasPrefix(s, []byte("
+//
+func svgWithXMLDeclaration(s scan.Bytes) bool {
+ for scan.ByteIsWS(s.Peek()) {
+ s.Advance(1)
+ }
+ if !bytes.HasPrefix(s, []byte(" 4096 {
+ s = s[:4096]
+ }
+ return hasVersion && bytes.Contains(s, []byte(" 00:02:19,376) limits second line
// length to exactly 29 characters.
if len(line) != 29 {
@@ -266,7 +507,7 @@ func Srt(raw []byte, _ uint32) bool {
return false
}
- line, _ = scanLine(raw)
+ line = s.Line()
// A third line must exist and not be empty. This is the actual subtitle text.
return len(line) != 0
}
@@ -295,15 +536,3 @@ func Vtt(raw []byte, limit uint32) bool {
return bytes.Equal(raw, []byte{0xEF, 0xBB, 0xBF, 0x57, 0x45, 0x42, 0x56, 0x54, 0x54}) || // UTF-8 BOM and "WEBVTT"
bytes.Equal(raw, []byte{0x57, 0x45, 0x42, 0x56, 0x54, 0x54}) // "WEBVTT"
}
-
-// dropCR drops a terminal \r from the data.
-func dropCR(data []byte) []byte {
- if len(data) > 0 && data[len(data)-1] == '\r' {
- return data[0 : len(data)-1]
- }
- return data
-}
-func scanLine(b []byte) (line, remainder []byte) {
- line, remainder, _ = bytes.Cut(b, []byte("\n"))
- return dropCR(line), remainder
-}
diff --git a/vendor/github.com/gabriel-vasile/mimetype/internal/magic/text_csv.go b/vendor/github.com/gabriel-vasile/mimetype/internal/magic/text_csv.go
index 6083ba8c..020b5ee7 100644
--- a/vendor/github.com/gabriel-vasile/mimetype/internal/magic/text_csv.go
+++ b/vendor/github.com/gabriel-vasile/mimetype/internal/magic/text_csv.go
@@ -1,77 +1,43 @@
package magic
import (
- "bufio"
- "bytes"
- "encoding/csv"
- "errors"
- "io"
- "sync"
+ "github.com/gabriel-vasile/mimetype/internal/csv"
+ "github.com/gabriel-vasile/mimetype/internal/scan"
)
-// A bufio.Reader pool to alleviate problems with memory allocations.
-var readerPool = sync.Pool{
- New: func() any {
- // Initiate with empty source reader.
- return bufio.NewReader(nil)
- },
-}
-
-func newReader(r io.Reader) *bufio.Reader {
- br := readerPool.Get().(*bufio.Reader)
- br.Reset(r)
- return br
-}
-
-// Csv matches a comma-separated values file.
-func Csv(raw []byte, limit uint32) bool {
+// CSV matches a comma-separated values file.
+func CSV(raw []byte, limit uint32) bool {
return sv(raw, ',', limit)
}
-// Tsv matches a tab-separated values file.
-func Tsv(raw []byte, limit uint32) bool {
+// TSV matches a tab-separated values file.
+func TSV(raw []byte, limit uint32) bool {
return sv(raw, '\t', limit)
}
-func sv(in []byte, comma rune, limit uint32) bool {
- in = dropLastLine(in, limit)
+func sv(in []byte, comma byte, limit uint32) bool {
+ s := scan.Bytes(in)
+ s.DropLastLine(limit)
+ r := csv.NewParser(comma, '#', s)
- br := newReader(bytes.NewReader(in))
- defer readerPool.Put(br)
- r := csv.NewReader(br)
- r.Comma = comma
- r.ReuseRecord = true
- r.LazyQuotes = true
- r.Comment = '#'
-
- lines := 0
+ headerFields, _, hasMore := r.CountFields(false)
+ if headerFields < 2 || !hasMore {
+ return false
+ }
+ csvLines := 1 // 1 for header
for {
- _, err := r.Read()
- if errors.Is(err, io.EOF) {
+ fields, _, hasMore := r.CountFields(false)
+ if !hasMore && fields == 0 {
break
}
- if err != nil {
+ csvLines++
+ if fields != headerFields {
return false
}
- lines++
- }
-
- return r.FieldsPerRecord > 1 && lines > 1
-}
-
-// dropLastLine drops the last incomplete line from b.
-//
-// mimetype limits itself to ReadLimit bytes when performing a detection.
-// This means, for file formats like CSV for NDJSON, the last line of the input
-// can be an incomplete line.
-func dropLastLine(b []byte, readLimit uint32) []byte {
- if readLimit == 0 || uint32(len(b)) < readLimit {
- return b
- }
- for i := len(b) - 1; i > 0; i-- {
- if b[i] == '\n' {
- return b[:i]
+ if csvLines >= 10 {
+ return true
}
}
- return b
+
+ return csvLines >= 2
}
diff --git a/vendor/github.com/gabriel-vasile/mimetype/internal/magic/video.go b/vendor/github.com/gabriel-vasile/mimetype/internal/magic/video.go
index 9caf5553..830c5ed2 100644
--- a/vendor/github.com/gabriel-vasile/mimetype/internal/magic/video.go
+++ b/vendor/github.com/gabriel-vasile/mimetype/internal/magic/video.go
@@ -4,17 +4,23 @@ import (
"bytes"
)
-var (
- // Flv matches a Flash video file.
- Flv = prefix([]byte("\x46\x4C\x56\x01"))
- // Asf matches an Advanced Systems Format file.
- Asf = prefix([]byte{
+// Flv matches a Flash video file.
+func Flv(raw []byte, _ uint32) bool {
+ return bytes.HasPrefix(raw, []byte("\x46\x4C\x56\x01"))
+}
+
+// Asf matches an Advanced Systems Format file.
+func Asf(raw []byte, _ uint32) bool {
+ return bytes.HasPrefix(raw, []byte{
0x30, 0x26, 0xB2, 0x75, 0x8E, 0x66, 0xCF, 0x11,
0xA6, 0xD9, 0x00, 0xAA, 0x00, 0x62, 0xCE, 0x6C,
})
- // Rmvb matches a RealMedia Variable Bitrate file.
- Rmvb = prefix([]byte{0x2E, 0x52, 0x4D, 0x46})
-)
+}
+
+// Rmvb matches a RealMedia Variable Bitrate file.
+func Rmvb(raw []byte, _ uint32) bool {
+ return bytes.HasPrefix(raw, []byte{0x2E, 0x52, 0x4D, 0x46})
+}
// WebM matches a WebM file.
func WebM(raw []byte, limit uint32) bool {
diff --git a/vendor/github.com/gabriel-vasile/mimetype/internal/magic/zip.go b/vendor/github.com/gabriel-vasile/mimetype/internal/magic/zip.go
index f6c64829..31f42482 100644
--- a/vendor/github.com/gabriel-vasile/mimetype/internal/magic/zip.go
+++ b/vendor/github.com/gabriel-vasile/mimetype/internal/magic/zip.go
@@ -2,35 +2,69 @@ package magic
import (
"bytes"
- "encoding/binary"
+
+ "github.com/gabriel-vasile/mimetype/internal/scan"
)
-var (
- // Odt matches an OpenDocument Text file.
- Odt = offset([]byte("mimetypeapplication/vnd.oasis.opendocument.text"), 30)
- // Ott matches an OpenDocument Text Template file.
- Ott = offset([]byte("mimetypeapplication/vnd.oasis.opendocument.text-template"), 30)
- // Ods matches an OpenDocument Spreadsheet file.
- Ods = offset([]byte("mimetypeapplication/vnd.oasis.opendocument.spreadsheet"), 30)
- // Ots matches an OpenDocument Spreadsheet Template file.
- Ots = offset([]byte("mimetypeapplication/vnd.oasis.opendocument.spreadsheet-template"), 30)
- // Odp matches an OpenDocument Presentation file.
- Odp = offset([]byte("mimetypeapplication/vnd.oasis.opendocument.presentation"), 30)
- // Otp matches an OpenDocument Presentation Template file.
- Otp = offset([]byte("mimetypeapplication/vnd.oasis.opendocument.presentation-template"), 30)
- // Odg matches an OpenDocument Drawing file.
- Odg = offset([]byte("mimetypeapplication/vnd.oasis.opendocument.graphics"), 30)
- // Otg matches an OpenDocument Drawing Template file.
- Otg = offset([]byte("mimetypeapplication/vnd.oasis.opendocument.graphics-template"), 30)
- // Odf matches an OpenDocument Formula file.
- Odf = offset([]byte("mimetypeapplication/vnd.oasis.opendocument.formula"), 30)
- // Odc matches an OpenDocument Chart file.
- Odc = offset([]byte("mimetypeapplication/vnd.oasis.opendocument.chart"), 30)
- // Epub matches an EPUB file.
- Epub = offset([]byte("mimetypeapplication/epub+zip"), 30)
- // Sxc matches an OpenOffice Spreadsheet file.
- Sxc = offset([]byte("mimetypeapplication/vnd.sun.xml.calc"), 30)
-)
+// Odt matches an OpenDocument Text file.
+func Odt(raw []byte, _ uint32) bool {
+ return offset(raw, []byte("mimetypeapplication/vnd.oasis.opendocument.text"), 30)
+}
+
+// Ott matches an OpenDocument Text Template file.
+func Ott(raw []byte, _ uint32) bool {
+ return offset(raw, []byte("mimetypeapplication/vnd.oasis.opendocument.text-template"), 30)
+}
+
+// Ods matches an OpenDocument Spreadsheet file.
+func Ods(raw []byte, _ uint32) bool {
+ return offset(raw, []byte("mimetypeapplication/vnd.oasis.opendocument.spreadsheet"), 30)
+}
+
+// Ots matches an OpenDocument Spreadsheet Template file.
+func Ots(raw []byte, _ uint32) bool {
+ return offset(raw, []byte("mimetypeapplication/vnd.oasis.opendocument.spreadsheet-template"), 30)
+}
+
+// Odp matches an OpenDocument Presentation file.
+func Odp(raw []byte, _ uint32) bool {
+ return offset(raw, []byte("mimetypeapplication/vnd.oasis.opendocument.presentation"), 30)
+}
+
+// Otp matches an OpenDocument Presentation Template file.
+func Otp(raw []byte, _ uint32) bool {
+ return offset(raw, []byte("mimetypeapplication/vnd.oasis.opendocument.presentation-template"), 30)
+}
+
+// Odg matches an OpenDocument Drawing file.
+func Odg(raw []byte, _ uint32) bool {
+ return offset(raw, []byte("mimetypeapplication/vnd.oasis.opendocument.graphics"), 30)
+}
+
+// Otg matches an OpenDocument Drawing Template file.
+func Otg(raw []byte, _ uint32) bool {
+ return offset(raw, []byte("mimetypeapplication/vnd.oasis.opendocument.graphics-template"), 30)
+}
+
+// Odf matches an OpenDocument Formula file.
+func Odf(raw []byte, _ uint32) bool {
+ return offset(raw, []byte("mimetypeapplication/vnd.oasis.opendocument.formula"), 30)
+}
+
+// Odc matches an OpenDocument Chart file.
+func Odc(raw []byte, _ uint32) bool {
+ return offset(raw, []byte("mimetypeapplication/vnd.oasis.opendocument.chart"), 30)
+}
+
+// Epub matches an EPUB file.
+func Epub(raw []byte, _ uint32) bool {
+ return offset(raw, []byte("mimetypeapplication/epub+zip"), 30)
+}
+
+// Sxc matches an OpenOffice Spreadsheet file.
+func Sxc(raw []byte, _ uint32) bool {
+ return offset(raw, []byte("mimetypeapplication/vnd.sun.xml.calc"), 30)
+}
// Zip matches a zip archive.
func Zip(raw []byte, limit uint32) bool {
@@ -40,92 +74,149 @@ func Zip(raw []byte, limit uint32) bool {
(raw[3] == 0x4 || raw[3] == 0x6 || raw[3] == 0x8)
}
-// Jar matches a Java archive file.
+// Jar matches a Java archive file. There are two types of Jar files:
+// 1. the ones that can be opened with jexec and have 0xCAFE optional flag
+// https://stackoverflow.com/tags/executable-jar/info
+// 2. regular jars, same as above, just without the executable flag
+// https://bugs.freebsd.org/bugzilla/show_bug.cgi?id=262278#c0
+// There is an argument to only check for manifest, since it's the common nominator
+// for both executable and non-executable versions. But the traversing zip entries
+// is unreliable because it does linear search for signatures
+// (instead of relying on offsets told by the file.)
func Jar(raw []byte, limit uint32) bool {
- return zipContains(raw, []byte("META-INF/MANIFEST.MF"), false)
+ return executableJar(raw) ||
+ zipHas(raw, zipEntries{{
+ name: []byte("META-INF/MANIFEST.MF"),
+ }, {
+ name: []byte("META-INF/"),
+ }}, 1)
}
-func zipContains(raw, sig []byte, msoCheck bool) bool {
- b := readBuf(raw)
- pk := []byte("PK\003\004")
- if len(b) < 0x1E {
+// KMZ matches a zipped KML file, which is "doc.kml" by convention.
+func KMZ(raw []byte, _ uint32) bool {
+ return zipHas(raw, zipEntries{{
+ name: []byte("doc.kml"),
+ }}, 100)
+}
+
+// An executable Jar has a 0xCAFE flag enabled in the first zip entry.
+// The rule from file/file is:
+// >(26.s+30) leshort 0xcafe Java archive data (JAR)
+func executableJar(b scan.Bytes) bool {
+ b.Advance(0x1A)
+ offset, ok := b.Uint16()
+ if !ok {
return false
}
+ b.Advance(int(offset) + 2)
- if !b.advance(0x1E) {
- return false
- }
- if bytes.HasPrefix(b, sig) {
- return true
- }
+ cafe, ok := b.Uint16()
+ return ok && cafe == 0xCAFE
+}
- if msoCheck {
- skipFiles := [][]byte{
- []byte("[Content_Types].xml"),
- []byte("_rels/.rels"),
- []byte("docProps"),
- []byte("customXml"),
- []byte("[trash]"),
- }
+// zipIterator iterates over a zip file returning the name of the zip entries
+// in that file.
+type zipIterator struct {
+ b scan.Bytes
+}
- hasSkipFile := false
- for _, sf := range skipFiles {
- if bytes.HasPrefix(b, sf) {
- hasSkipFile = true
- break
- }
- }
- if !hasSkipFile {
- return false
- }
- }
+type zipEntries []struct {
+ name []byte
+ dir bool // dir means checking just the prefix of the entry, not the whole path
+}
- searchOffset := binary.LittleEndian.Uint32(raw[18:]) + 49
- if !b.advance(int(searchOffset)) {
- return false
- }
-
- nextHeader := bytes.Index(raw[searchOffset:], pk)
- if !b.advance(nextHeader) {
- return false
- }
- if bytes.HasPrefix(b, sig) {
- return true
- }
-
- for i := 0; i < 4; i++ {
- if !b.advance(0x1A) {
- return false
+func (z zipEntries) match(file []byte) bool {
+ for i := range z {
+ if z[i].dir && bytes.HasPrefix(file, z[i].name) {
+ return true
}
- nextHeader = bytes.Index(b, pk)
- if nextHeader == -1 {
- return false
- }
- if !b.advance(nextHeader + 0x1E) {
- return false
- }
- if bytes.HasPrefix(b, sig) {
+ if bytes.Equal(file, z[i].name) {
return true
}
}
return false
}
+func zipHas(raw scan.Bytes, searchFor zipEntries, stopAfter int) bool {
+ iter := zipIterator{raw}
+ for i := 0; i < stopAfter; i++ {
+ f := iter.next()
+ if len(f) == 0 {
+ break
+ }
+ if searchFor.match(f) {
+ return true
+ }
+ }
+
+ return false
+}
+
+// msoxml behaves like zipHas, but it puts restrictions on what the first zip
+// entry can be.
+func msoxml(raw scan.Bytes, searchFor zipEntries, stopAfter int) bool {
+ iter := zipIterator{raw}
+ for i := 0; i < stopAfter; i++ {
+ f := iter.next()
+ if len(f) == 0 {
+ break
+ }
+ if searchFor.match(f) {
+ return true
+ }
+ // If the first is not one of the next usually expected entries,
+ // then abort this check.
+ if i == 0 {
+ if !bytes.Equal(f, []byte("[Content_Types].xml")) && // this is a file
+ !bytes.HasPrefix(f, []byte("_rels/")) && // these are directories
+ !bytes.HasPrefix(f, []byte("docProps/")) &&
+ !bytes.HasPrefix(f, []byte("customXml/")) &&
+ !bytes.HasPrefix(f, []byte("[trash]/")) {
+ return false
+ }
+ }
+ }
+
+ return false
+}
+
+// next extracts the name of the next zip entry.
+func (i *zipIterator) next() []byte {
+ pk := []byte("PK\003\004")
+
+ n := bytes.Index(i.b, pk)
+ if n == -1 {
+ return nil
+ }
+ i.b.Advance(n)
+ if !i.b.Advance(0x1A) {
+ return nil
+ }
+ l, ok := i.b.Uint16()
+ if !ok {
+ return nil
+ }
+ if !i.b.Advance(0x02) {
+ return nil
+ }
+ if len(i.b) < int(l) {
+ return nil
+ }
+ return i.b[:l]
+}
+
// APK matches an Android Package Archive.
// The source of signatures is https://github.com/file/file/blob/1778642b8ba3d947a779a36fcd81f8e807220a19/magic/Magdir/archive#L1820-L1887
func APK(raw []byte, _ uint32) bool {
- apkSignatures := [][]byte{
- []byte("AndroidManifest.xml"),
- []byte("META-INF/com/android/build/gradle/app-metadata.properties"),
- []byte("classes.dex"),
- []byte("resources.arsc"),
- []byte("res/drawable"),
- }
- for _, sig := range apkSignatures {
- if zipContains(raw, sig, false) {
- return true
- }
- }
-
- return false
+ return zipHas(raw, zipEntries{{
+ name: []byte("AndroidManifest.xml"),
+ }, {
+ name: []byte("META-INF/com/android/build/gradle/app-metadata.properties"),
+ }, {
+ name: []byte("classes.dex"),
+ }, {
+ name: []byte("resources.arsc"),
+ }, {
+ name: []byte("res/drawable"),
+ }}, 100)
}
diff --git a/vendor/github.com/gabriel-vasile/mimetype/internal/markup/markup.go b/vendor/github.com/gabriel-vasile/mimetype/internal/markup/markup.go
new file mode 100644
index 00000000..b9abc6da
--- /dev/null
+++ b/vendor/github.com/gabriel-vasile/mimetype/internal/markup/markup.go
@@ -0,0 +1,105 @@
+// Package markup implements functions for extracting info from
+// HTML and XML documents.
+package markup
+
+import (
+ "bytes"
+
+ "github.com/gabriel-vasile/mimetype/internal/scan"
+)
+
+// GetAnAttribute assumes we passed over an SGML tag and extracts first
+// attribute and its value.
+//
+// Initially, this code existed inside charset/charset.go, because it was part of
+// implementing the https://html.spec.whatwg.org/multipage/parsing.html#prescan-a-byte-stream-to-determine-its-encoding
+// algorithm. But because extracting an attribute from a tag is the same for
+// both HTML and XML, then the code was moved here.
+func GetAnAttribute(s *scan.Bytes) (name, val []byte, hasMore bool) {
+ for scan.ByteIsWS(s.Peek()) || s.Peek() == '/' {
+ s.Advance(1)
+ }
+ if s.Peek() == '>' {
+ return nil, nil, false
+ }
+ origS, end := *s, 0
+ // step 4 and 5
+ for {
+ // bap means byte at position in the specification.
+ bap := s.Pop()
+ if bap == 0 {
+ return nil, nil, false
+ }
+ if bap == '=' && end > 0 {
+ val, hasMore := getAValue(s)
+ return origS[:end], val, hasMore
+ } else if scan.ByteIsWS(bap) {
+ for scan.ByteIsWS(s.Peek()) {
+ s.Advance(1)
+ }
+ if s.Peek() != '=' {
+ return origS[:end], nil, true
+ }
+ s.Advance(1)
+ for scan.ByteIsWS(s.Peek()) {
+ s.Advance(1)
+ }
+ val, hasMore := getAValue(s)
+ return origS[:end], val, hasMore
+ } else if bap == '/' || bap == '>' {
+ return origS[:end], nil, false
+ } else { // for any ASCII, non-ASCII, just advance
+ end++
+ }
+ }
+}
+
+func getAValue(s *scan.Bytes) (_ []byte, hasMore bool) {
+ for scan.ByteIsWS(s.Peek()) {
+ s.Advance(1)
+ }
+ origS, end := *s, 0
+ bap := s.Pop()
+ if bap == 0 {
+ return nil, false
+ }
+ end++
+ // Step 10
+ switch bap {
+ case '"', '\'':
+ val := s.PopUntil(bap)
+ if s.Pop() != bap {
+ return nil, false
+ }
+ return val, s.Peek() != 0 && s.Peek() != '>'
+ case '>':
+ return nil, false
+ }
+
+ // Step 11
+ for {
+ bap = s.Pop()
+ if bap == 0 {
+ return nil, false
+ }
+ switch {
+ case scan.ByteIsWS(bap):
+ return origS[:end], true
+ case bap == '>':
+ return origS[:end], false
+ default:
+ end++
+ }
+ }
+}
+
+func SkipAComment(s *scan.Bytes) (skipped bool) {
+ if bytes.HasPrefix(*s, []byte("")); i != -1 {
+ s.Advance(i + 2 + 3) // 2 comes from len().
+ return true
+ }
+ }
+ return false
+}
diff --git a/vendor/github.com/gabriel-vasile/mimetype/internal/scan/bytes.go b/vendor/github.com/gabriel-vasile/mimetype/internal/scan/bytes.go
new file mode 100644
index 00000000..b19a9492
--- /dev/null
+++ b/vendor/github.com/gabriel-vasile/mimetype/internal/scan/bytes.go
@@ -0,0 +1,262 @@
+// Package scan has functions for scanning byte slices.
+package scan
+
+import (
+ "bytes"
+ "encoding/binary"
+)
+
+// Bytes is a byte slice with helper methods for easier scanning.
+type Bytes []byte
+
+func (b *Bytes) Advance(n int) bool {
+ if n < 0 || len(*b) < n {
+ return false
+ }
+ *b = (*b)[n:]
+ return true
+}
+
+// TrimLWS trims whitespace from beginning of the bytes.
+func (b *Bytes) TrimLWS() {
+ firstNonWS := 0
+ for ; firstNonWS < len(*b) && ByteIsWS((*b)[firstNonWS]); firstNonWS++ {
+ }
+
+ *b = (*b)[firstNonWS:]
+}
+
+// TrimRWS trims whitespace from the end of the bytes.
+func (b *Bytes) TrimRWS() {
+ lb := len(*b)
+ for lb > 0 && ByteIsWS((*b)[lb-1]) {
+ *b = (*b)[:lb-1]
+ lb--
+ }
+}
+
+// Peek one byte from b or 0x00 if b is empty.
+func (b *Bytes) Peek() byte {
+ if len(*b) > 0 {
+ return (*b)[0]
+ }
+ return 0
+}
+
+// Pop one byte from b or 0x00 if b is empty.
+func (b *Bytes) Pop() byte {
+ if len(*b) > 0 {
+ ret := (*b)[0]
+ *b = (*b)[1:]
+ return ret
+ }
+ return 0
+}
+
+// PopN pops n bytes from b or nil if b is empty.
+func (b *Bytes) PopN(n int) []byte {
+ if len(*b) >= n {
+ ret := (*b)[:n]
+ *b = (*b)[n:]
+ return ret
+ }
+ return nil
+}
+
+// PopUntil will advance b until, but not including, the first occurence of stopAt
+// character. If no occurence is found, then it will advance until the end of b.
+// The returned Bytes is a slice of all the bytes that we're advanced over.
+func (b *Bytes) PopUntil(stopAt ...byte) Bytes {
+ if len(*b) == 0 {
+ return Bytes{}
+ }
+ i := bytes.IndexAny(*b, string(stopAt))
+ if i == -1 {
+ i = len(*b)
+ }
+
+ prefix := (*b)[:i]
+ *b = (*b)[i:]
+ return Bytes(prefix)
+}
+
+// ReadSlice is the same as PopUntil, but the returned value includes stopAt as well.
+func (b *Bytes) ReadSlice(stopAt byte) Bytes {
+ if len(*b) == 0 {
+ return Bytes{}
+ }
+ i := bytes.IndexByte(*b, stopAt)
+ if i == -1 {
+ i = len(*b)
+ } else {
+ i++
+ }
+
+ prefix := (*b)[:i]
+ *b = (*b)[i:]
+ return Bytes(prefix)
+}
+
+// Line returns the first line from b and advances b with the length of the
+// line. One new line character is trimmed after the line if it exists.
+func (b *Bytes) Line() Bytes {
+ line := b.PopUntil('\n')
+ lline := len(line)
+ if lline > 0 && line[lline-1] == '\r' {
+ line = line[:lline-1]
+ }
+ b.Advance(1)
+ return line
+}
+
+// DropLastLine drops the last incomplete line from b.
+//
+// mimetype limits itself to ReadLimit bytes when performing a detection.
+// This means, for file formats like CSV for NDJSON, the last line of the input
+// can be an incomplete line.
+// If b length is less than readLimit, it means we received an incomplete file
+// and proceed with dropping the last line.
+func (b *Bytes) DropLastLine(readLimit uint32) {
+ if readLimit == 0 || uint32(len(*b)) < readLimit {
+ return
+ }
+
+ for i := len(*b) - 1; i > 0; i-- {
+ if (*b)[i] == '\n' {
+ *b = (*b)[:i]
+ return
+ }
+ }
+}
+
+func (b *Bytes) Uint16() (uint16, bool) {
+ if len(*b) < 2 {
+ return 0, false
+ }
+ v := binary.LittleEndian.Uint16(*b)
+ *b = (*b)[2:]
+ return v, true
+}
+
+type Flags int
+
+const (
+ // CompactWS will make one whitespace from pattern to match one or more spaces from input.
+ CompactWS Flags = 1 << iota
+ // IgnoreCase will match lower case from pattern with lower case from input.
+ // IgnoreCase will match upper case from pattern with both lower and upper case from input.
+ // This flag is not really well named,
+ IgnoreCase
+ // FullWord ensures the input ends with a full word (it's followed by spaces.)
+ FullWord
+)
+
+// Search for occurences of pattern p inside b at any index.
+// It returns the index where p was found in b and how many bytes were needed
+// for matching the pattern.
+func (b Bytes) Search(p []byte, flags Flags) (i int, l int) {
+ lb, lp := len(b), len(p)
+ if lp == 0 {
+ return 0, 0
+ }
+ if lb == 0 {
+ return -1, 0
+ }
+ if flags == 0 {
+ if i = bytes.Index(b, p); i == -1 {
+ return -1, 0
+ } else {
+ return i, lp
+ }
+ }
+
+ for i := range b {
+ if lb-i < lp {
+ return -1, 0
+ }
+ if l = b[i:].Match(p, flags); l != -1 {
+ return i, l
+ }
+ }
+
+ return -1, 0
+}
+
+// Match returns how many bytes were needed to match pattern p.
+// It returns -1 if p does not match b.
+func (b Bytes) Match(p []byte, flags Flags) int {
+ l := len(b)
+ if len(p) == 0 {
+ return 0
+ }
+ if l == 0 {
+ return -1
+ }
+ // If no flags, or scanning for full word at the end of pattern then
+ // do a fast HasPrefix check.
+ // For other flags it's not possible to use HasPrefix.
+ if flags == 0 || flags&FullWord > 0 {
+ if bytes.HasPrefix(b, p) {
+ b = b[len(p):]
+ p = p[len(p):]
+ goto out
+ }
+ return -1
+ }
+ for len(b) > 0 {
+ // If we finished all we were looking for from p.
+ if len(p) == 0 {
+ goto out
+ }
+ if flags&IgnoreCase > 0 && isUpper(p[0]) {
+ if upper(b[0]) != p[0] {
+ return -1
+ }
+ b, p = b[1:], p[1:]
+ } else if flags&CompactWS > 0 && ByteIsWS(p[0]) {
+ p = p[1:]
+ if !ByteIsWS(b[0]) {
+ return -1
+ }
+ b = b[1:]
+ if !ByteIsWS(p[0]) {
+ b.TrimLWS()
+ }
+ } else {
+ if b[0] != p[0] {
+ return -1
+ }
+ b, p = b[1:], p[1:]
+ }
+ }
+out:
+ // If p still has leftover characters, it means it didn't fully match b.
+ if len(p) > 0 {
+ return -1
+ }
+ if flags&FullWord > 0 {
+ if len(b) > 0 && !ByteIsWS(b[0]) {
+ return -1
+ }
+ }
+ return l - len(b)
+}
+
+func isUpper(c byte) bool {
+ return c >= 'A' && c <= 'Z'
+}
+func upper(c byte) byte {
+ if c >= 'a' && c <= 'z' {
+ return c - ('a' - 'A')
+ }
+ return c
+}
+
+func ByteIsWS(b byte) bool {
+ return b == '\t' || b == '\n' || b == '\x0c' || b == '\r' || b == ' '
+}
+
+var (
+ ASCIISpaces = []byte{' ', '\r', '\n', '\x0c', '\t'}
+ ASCIIDigits = []byte{'0', '1', '2', '3', '4', '5', '6', '7', '8', '9'}
+)
diff --git a/vendor/github.com/gabriel-vasile/mimetype/mime.go b/vendor/github.com/gabriel-vasile/mimetype/mime.go
index 62cb15f5..ec2bc5bf 100644
--- a/vendor/github.com/gabriel-vasile/mimetype/mime.go
+++ b/vendor/github.com/gabriel-vasile/mimetype/mime.go
@@ -2,6 +2,7 @@ package mimetype
import (
"mime"
+ "strings"
"github.com/gabriel-vasile/mimetype/internal/charset"
"github.com/gabriel-vasile/mimetype/internal/magic"
@@ -103,15 +104,17 @@ func (m *MIME) match(in []byte, readLimit uint32) *MIME {
"text/html": charset.FromHTML,
"text/xml": charset.FromXML,
}
- // ps holds optional MIME parameters.
- ps := map[string]string{}
+ charset := ""
if f, ok := needsCharset[m.mime]; ok {
- if cset := f(in); cset != "" {
- ps["charset"] = cset
- }
+ // The charset comes from BOM, from HTML headers, from XML headers.
+ // Limit the number of bytes searched for to 1024.
+ charset = f(in[:min(len(in), 1024)])
+ }
+ if m == root || charset == "" {
+ return m
}
- return m.cloneHierarchy(ps)
+ return m.cloneHierarchy(charset)
}
// flatten transforms an hierarchy of MIMEs into a slice of MIMEs.
@@ -124,11 +127,32 @@ func (m *MIME) flatten() []*MIME {
return out
}
+// hierarchy returns an easy to read list of ancestors for m.
+// For example, application/json would return json>txt>root.
+func (m *MIME) hierarchy() string {
+ h := ""
+ for m := m; m != nil; m = m.Parent() {
+ e := strings.TrimPrefix(m.Extension(), ".")
+ if e == "" {
+ // There are some MIME without extensions. When generating the hierarchy,
+ // it would be confusing to use empty string as extension.
+ // Use the subtype instead; ex: application/x-executable -> x-executable.
+ e = strings.Split(m.String(), "/")[1]
+ if m.Is("application/octet-stream") {
+ // for octet-stream use root, because it's short and used in many places
+ e = "root"
+ }
+ }
+ h += ">" + e
+ }
+ return strings.TrimPrefix(h, ">")
+}
+
// clone creates a new MIME with the provided optional MIME parameters.
-func (m *MIME) clone(ps map[string]string) *MIME {
+func (m *MIME) clone(charset string) *MIME {
clonedMIME := m.mime
- if len(ps) > 0 {
- clonedMIME = mime.FormatMediaType(m.mime, ps)
+ if charset != "" {
+ clonedMIME = m.mime + "; charset=" + charset
}
return &MIME{
@@ -140,11 +164,11 @@ func (m *MIME) clone(ps map[string]string) *MIME {
// cloneHierarchy creates a clone of m and all its ancestors. The optional MIME
// parameters are set on the last child of the hierarchy.
-func (m *MIME) cloneHierarchy(ps map[string]string) *MIME {
- ret := m.clone(ps)
+func (m *MIME) cloneHierarchy(charset string) *MIME {
+ ret := m.clone(charset)
lastChild := ret
for p := m.Parent(); p != nil; p = p.Parent() {
- pClone := p.clone(nil)
+ pClone := p.clone("")
lastChild.parent = pClone
lastChild = pClone
}
@@ -153,7 +177,10 @@ func (m *MIME) cloneHierarchy(ps map[string]string) *MIME {
}
func (m *MIME) lookup(mime string) *MIME {
- for _, n := range append(m.aliases, m.mime) {
+ if mime == m.mime {
+ return m
+ }
+ for _, n := range m.aliases {
if n == mime {
return m
}
diff --git a/vendor/github.com/gabriel-vasile/mimetype/mimetype.go b/vendor/github.com/gabriel-vasile/mimetype/mimetype.go
index d8d512b8..79274173 100644
--- a/vendor/github.com/gabriel-vasile/mimetype/mimetype.go
+++ b/vendor/github.com/gabriel-vasile/mimetype/mimetype.go
@@ -12,7 +12,7 @@ import (
"sync/atomic"
)
-var defaultLimit uint32 = 3072
+const defaultLimit uint32 = 3072
// readLimit is the maximum number of bytes from the input used when detecting.
var readLimit uint32 = defaultLimit
@@ -112,15 +112,18 @@ func SetLimit(limit uint32) {
}
// Extend adds detection for other file formats.
-// It is equivalent to calling Extend() on the root mime type "application/octet-stream".
+// It is equivalent to calling Extend() on the root MIME type "application/octet-stream".
func Extend(detector func(raw []byte, limit uint32) bool, mime, extension string, aliases ...string) {
root.Extend(detector, mime, extension, aliases...)
}
// Lookup finds a MIME object by its string representation.
-// The representation can be the main mime type, or any of its aliases.
-func Lookup(mime string) *MIME {
+// The representation can be the main MIME type, or any of its aliases.
+func Lookup(m string) *MIME {
+ // We store the MIME types without optional params, so
+ // perform parsing to extract the target MIME type without optional params.
+ m, _, _ = mime.ParseMediaType(m)
mu.RLock()
defer mu.RUnlock()
- return root.lookup(mime)
+ return root.lookup(m)
}
diff --git a/vendor/github.com/gabriel-vasile/mimetype/supported_mimes.md b/vendor/github.com/gabriel-vasile/mimetype/supported_mimes.md
index 6f45bfbb..241a81f4 100644
--- a/vendor/github.com/gabriel-vasile/mimetype/supported_mimes.md
+++ b/vendor/github.com/gabriel-vasile/mimetype/supported_mimes.md
@@ -1,184 +1,197 @@
-## 179 Supported MIME types
+## 192 Supported MIME types
This file is automatically generated when running tests. Do not edit manually.
-Extension | MIME type | Aliases
---------- | --------- | -------
-**n/a** | application/octet-stream | -
-**.xpm** | image/x-xpixmap | -
-**.7z** | application/x-7z-compressed | -
-**.zip** | application/zip | application/x-zip, application/x-zip-compressed
-**.xlsx** | application/vnd.openxmlformats-officedocument.spreadsheetml.sheet | -
-**.docx** | application/vnd.openxmlformats-officedocument.wordprocessingml.document | -
-**.pptx** | application/vnd.openxmlformats-officedocument.presentationml.presentation | -
-**.epub** | application/epub+zip | -
-**.apk** | application/vnd.android.package-archive | -
-**.jar** | application/jar | -
-**.odt** | application/vnd.oasis.opendocument.text | application/x-vnd.oasis.opendocument.text
-**.ott** | application/vnd.oasis.opendocument.text-template | application/x-vnd.oasis.opendocument.text-template
-**.ods** | application/vnd.oasis.opendocument.spreadsheet | application/x-vnd.oasis.opendocument.spreadsheet
-**.ots** | application/vnd.oasis.opendocument.spreadsheet-template | application/x-vnd.oasis.opendocument.spreadsheet-template
-**.odp** | application/vnd.oasis.opendocument.presentation | application/x-vnd.oasis.opendocument.presentation
-**.otp** | application/vnd.oasis.opendocument.presentation-template | application/x-vnd.oasis.opendocument.presentation-template
-**.odg** | application/vnd.oasis.opendocument.graphics | application/x-vnd.oasis.opendocument.graphics
-**.otg** | application/vnd.oasis.opendocument.graphics-template | application/x-vnd.oasis.opendocument.graphics-template
-**.odf** | application/vnd.oasis.opendocument.formula | application/x-vnd.oasis.opendocument.formula
-**.odc** | application/vnd.oasis.opendocument.chart | application/x-vnd.oasis.opendocument.chart
-**.sxc** | application/vnd.sun.xml.calc | -
-**.pdf** | application/pdf | application/x-pdf
-**.fdf** | application/vnd.fdf | -
-**n/a** | application/x-ole-storage | -
-**.msi** | application/x-ms-installer | application/x-windows-installer, application/x-msi
-**.aaf** | application/octet-stream | -
-**.msg** | application/vnd.ms-outlook | -
-**.xls** | application/vnd.ms-excel | application/msexcel
-**.pub** | application/vnd.ms-publisher | -
-**.ppt** | application/vnd.ms-powerpoint | application/mspowerpoint
-**.doc** | application/msword | application/vnd.ms-word
-**.ps** | application/postscript | -
-**.psd** | image/vnd.adobe.photoshop | image/x-psd, application/photoshop
-**.p7s** | application/pkcs7-signature | -
-**.ogg** | application/ogg | application/x-ogg
-**.oga** | audio/ogg | -
-**.ogv** | video/ogg | -
-**.png** | image/png | -
-**.png** | image/vnd.mozilla.apng | -
-**.jpg** | image/jpeg | -
-**.jxl** | image/jxl | -
-**.jp2** | image/jp2 | -
-**.jpf** | image/jpx | -
-**.jpm** | image/jpm | video/jpm
-**.jxs** | image/jxs | -
-**.gif** | image/gif | -
-**.webp** | image/webp | -
-**.exe** | application/vnd.microsoft.portable-executable | -
-**n/a** | application/x-elf | -
-**n/a** | application/x-object | -
-**n/a** | application/x-executable | -
-**.so** | application/x-sharedlib | -
-**n/a** | application/x-coredump | -
-**.a** | application/x-archive | application/x-unix-archive
-**.deb** | application/vnd.debian.binary-package | -
-**.tar** | application/x-tar | -
-**.xar** | application/x-xar | -
-**.bz2** | application/x-bzip2 | -
-**.fits** | application/fits | -
-**.tiff** | image/tiff | -
-**.bmp** | image/bmp | image/x-bmp, image/x-ms-bmp
-**.ico** | image/x-icon | -
-**.mp3** | audio/mpeg | audio/x-mpeg, audio/mp3
-**.flac** | audio/flac | -
-**.midi** | audio/midi | audio/mid, audio/sp-midi, audio/x-mid, audio/x-midi
-**.ape** | audio/ape | -
-**.mpc** | audio/musepack | -
-**.amr** | audio/amr | audio/amr-nb
-**.wav** | audio/wav | audio/x-wav, audio/vnd.wave, audio/wave
-**.aiff** | audio/aiff | audio/x-aiff
-**.au** | audio/basic | -
-**.mpeg** | video/mpeg | -
-**.mov** | video/quicktime | -
-**.mp4** | video/mp4 | -
-**.avif** | image/avif | -
-**.3gp** | video/3gpp | video/3gp, audio/3gpp
-**.3g2** | video/3gpp2 | video/3g2, audio/3gpp2
-**.mp4** | audio/mp4 | audio/x-mp4a
-**.mqv** | video/quicktime | -
-**.m4a** | audio/x-m4a | -
-**.m4v** | video/x-m4v | -
-**.heic** | image/heic | -
-**.heic** | image/heic-sequence | -
-**.heif** | image/heif | -
-**.heif** | image/heif-sequence | -
-**.mj2** | video/mj2 | -
-**.dvb** | video/vnd.dvb.file | -
-**.webm** | video/webm | audio/webm
-**.avi** | video/x-msvideo | video/avi, video/msvideo
-**.flv** | video/x-flv | -
-**.mkv** | video/x-matroska | -
-**.asf** | video/x-ms-asf | video/asf, video/x-ms-wmv
-**.aac** | audio/aac | -
-**.voc** | audio/x-unknown | -
-**.m3u** | application/vnd.apple.mpegurl | audio/mpegurl
-**.rmvb** | application/vnd.rn-realmedia-vbr | -
-**.gz** | application/gzip | application/x-gzip, application/x-gunzip, application/gzipped, application/gzip-compressed, application/x-gzip-compressed, gzip/document
-**.class** | application/x-java-applet | -
-**.swf** | application/x-shockwave-flash | -
-**.crx** | application/x-chrome-extension | -
-**.ttf** | font/ttf | font/sfnt, application/x-font-ttf, application/font-sfnt
-**.woff** | font/woff | -
-**.woff2** | font/woff2 | -
-**.otf** | font/otf | -
-**.ttc** | font/collection | -
-**.eot** | application/vnd.ms-fontobject | -
-**.wasm** | application/wasm | -
-**.shx** | application/vnd.shx | -
-**.shp** | application/vnd.shp | -
-**.dbf** | application/x-dbf | -
-**.dcm** | application/dicom | -
-**.rar** | application/x-rar-compressed | application/x-rar
-**.djvu** | image/vnd.djvu | -
-**.mobi** | application/x-mobipocket-ebook | -
-**.lit** | application/x-ms-reader | -
-**.bpg** | image/bpg | -
-**.cbor** | application/cbor | -
-**.sqlite** | application/vnd.sqlite3 | application/x-sqlite3
-**.dwg** | image/vnd.dwg | image/x-dwg, application/acad, application/x-acad, application/autocad_dwg, application/dwg, application/x-dwg, application/x-autocad, drawing/dwg
-**.nes** | application/vnd.nintendo.snes.rom | -
-**.lnk** | application/x-ms-shortcut | -
-**.macho** | application/x-mach-binary | -
-**.qcp** | audio/qcelp | -
-**.icns** | image/x-icns | -
-**.hdr** | image/vnd.radiance | -
-**.mrc** | application/marc | -
-**.mdb** | application/x-msaccess | -
-**.accdb** | application/x-msaccess | -
-**.zst** | application/zstd | -
-**.cab** | application/vnd.ms-cab-compressed | -
-**.rpm** | application/x-rpm | -
-**.xz** | application/x-xz | -
-**.lz** | application/lzip | application/x-lzip
-**.torrent** | application/x-bittorrent | -
-**.cpio** | application/x-cpio | -
-**n/a** | application/tzif | -
-**.xcf** | image/x-xcf | -
-**.pat** | image/x-gimp-pat | -
-**.gbr** | image/x-gimp-gbr | -
-**.glb** | model/gltf-binary | -
-**.cab** | application/x-installshield | -
-**.jxr** | image/jxr | image/vnd.ms-photo
-**.parquet** | application/vnd.apache.parquet | application/x-parquet
-**.txt** | text/plain | -
-**.html** | text/html | -
-**.svg** | image/svg+xml | -
-**.xml** | text/xml | application/xml
-**.rss** | application/rss+xml | text/rss
-**.atom** | application/atom+xml | -
-**.x3d** | model/x3d+xml | -
-**.kml** | application/vnd.google-earth.kml+xml | -
-**.xlf** | application/x-xliff+xml | -
-**.dae** | model/vnd.collada+xml | -
-**.gml** | application/gml+xml | -
-**.gpx** | application/gpx+xml | -
-**.tcx** | application/vnd.garmin.tcx+xml | -
-**.amf** | application/x-amf | -
-**.3mf** | application/vnd.ms-package.3dmanufacturing-3dmodel+xml | -
-**.xfdf** | application/vnd.adobe.xfdf | -
-**.owl** | application/owl+xml | -
-**.php** | text/x-php | -
-**.js** | text/javascript | application/x-javascript, application/javascript
-**.lua** | text/x-lua | -
-**.pl** | text/x-perl | -
-**.py** | text/x-python | text/x-script.python, application/x-python
-**.json** | application/json | -
-**.geojson** | application/geo+json | -
-**.har** | application/json | -
-**.gltf** | model/gltf+json | -
-**.ndjson** | application/x-ndjson | -
-**.rtf** | text/rtf | application/rtf
-**.srt** | application/x-subrip | application/x-srt, text/x-srt
-**.tcl** | text/x-tcl | application/x-tcl
-**.csv** | text/csv | -
-**.tsv** | text/tab-separated-values | -
-**.vcf** | text/vcard | -
-**.ics** | text/calendar | -
-**.warc** | application/warc | -
-**.vtt** | text/vtt | -
+Extension | MIME type Aliases | Hierarchy
+--------- | ---------------------- | ---------
+**n/a** | **application/octet-stream** | root
+**.xpm** | **image/x-xpixmap** | xpm>root
+**.7z** | **application/x-7z-compressed** | 7z>root
+**.zip** | **application/zip** application/x-zip, application/x-zip-compressed | zip>root
+**.docx** | **application/vnd.openxmlformats-officedocument.wordprocessingml.document** | docx>zip>root
+**.pptx** | **application/vnd.openxmlformats-officedocument.presentationml.presentation** | pptx>zip>root
+**.xlsx** | **application/vnd.openxmlformats-officedocument.spreadsheetml.sheet** | xlsx>zip>root
+**.epub** | **application/epub+zip** | epub>zip>root
+**.apk** | **application/vnd.android.package-archive** | apk>zip>root
+**.jar** | **application/java-archive** application/jar, application/jar-archive, application/x-java-archive | jar>zip>root
+**.odt** | **application/vnd.oasis.opendocument.text** application/x-vnd.oasis.opendocument.text | odt>zip>root
+**.ott** | **application/vnd.oasis.opendocument.text-template** application/x-vnd.oasis.opendocument.text-template | ott>odt>zip>root
+**.ods** | **application/vnd.oasis.opendocument.spreadsheet** application/x-vnd.oasis.opendocument.spreadsheet | ods>zip>root
+**.ots** | **application/vnd.oasis.opendocument.spreadsheet-template** application/x-vnd.oasis.opendocument.spreadsheet-template | ots>ods>zip>root
+**.odp** | **application/vnd.oasis.opendocument.presentation** application/x-vnd.oasis.opendocument.presentation | odp>zip>root
+**.otp** | **application/vnd.oasis.opendocument.presentation-template** application/x-vnd.oasis.opendocument.presentation-template | otp>odp>zip>root
+**.odg** | **application/vnd.oasis.opendocument.graphics** application/x-vnd.oasis.opendocument.graphics | odg>zip>root
+**.otg** | **application/vnd.oasis.opendocument.graphics-template** application/x-vnd.oasis.opendocument.graphics-template | otg>odg>zip>root
+**.odf** | **application/vnd.oasis.opendocument.formula** application/x-vnd.oasis.opendocument.formula | odf>zip>root
+**.odc** | **application/vnd.oasis.opendocument.chart** application/x-vnd.oasis.opendocument.chart | odc>zip>root
+**.sxc** | **application/vnd.sun.xml.calc** | sxc>zip>root
+**.kmz** | **application/vnd.google-earth.kmz** | kmz>zip>root
+**.vsdx** | **application/vnd.ms-visio.drawing.main+xml** | vsdx>zip>root
+**.pdf** | **application/pdf** application/x-pdf | pdf>root
+**.fdf** | **application/vnd.fdf** | fdf>root
+**n/a** | **application/x-ole-storage** | x-ole-storage>root
+**.msi** | **application/x-ms-installer** application/x-windows-installer, application/x-msi | msi>x-ole-storage>root
+**.msg** | **application/vnd.ms-outlook** | msg>x-ole-storage>root
+**.xls** | **application/vnd.ms-excel** application/msexcel | xls>x-ole-storage>root
+**.pub** | **application/vnd.ms-publisher** | pub>x-ole-storage>root
+**.ppt** | **application/vnd.ms-powerpoint** application/mspowerpoint | ppt>x-ole-storage>root
+**.doc** | **application/msword** application/vnd.ms-word | doc>x-ole-storage>root
+**.ps** | **application/postscript** | ps>root
+**.psd** | **image/vnd.adobe.photoshop** image/x-psd, application/photoshop | psd>root
+**.p7s** | **application/pkcs7-signature** | p7s>root
+**.ogg** | **application/ogg** application/x-ogg | ogg>root
+**.oga** | **audio/ogg** | oga>ogg>root
+**.ogv** | **video/ogg** | ogv>ogg>root
+**.png** | **image/png** | png>root
+**.png** | **image/vnd.mozilla.apng** | png>png>root
+**.jpg** | **image/jpeg** | jpg>root
+**.jxl** | **image/jxl** | jxl>root
+**.jp2** | **image/jp2** | jp2>root
+**.jpf** | **image/jpx** | jpf>root
+**.jpm** | **image/jpm** video/jpm | jpm>root
+**.jxs** | **image/jxs** | jxs>root
+**.gif** | **image/gif** | gif>root
+**.webp** | **image/webp** | webp>root
+**.exe** | **application/vnd.microsoft.portable-executable** | exe>root
+**n/a** | **application/x-elf** | x-elf>root
+**n/a** | **application/x-object** | x-object>x-elf>root
+**n/a** | **application/x-executable** | x-executable>x-elf>root
+**.so** | **application/x-sharedlib** | so>x-elf>root
+**n/a** | **application/x-coredump** | x-coredump>x-elf>root
+**.a** | **application/x-archive** application/x-unix-archive | a>root
+**.deb** | **application/vnd.debian.binary-package** | deb>a>root
+**.tar** | **application/x-tar** | tar>root
+**.xar** | **application/x-xar** | xar>root
+**.bz2** | **application/x-bzip2** | bz2>root
+**.fits** | **application/fits** image/fits | fits>root
+**.tiff** | **image/tiff** | tiff>root
+**.bmp** | **image/bmp** image/x-bmp, image/x-ms-bmp | bmp>root
+**.123** | **application/vnd.lotus-1-2-3** | 123>root
+**.ico** | **image/x-icon** | ico>root
+**.mp3** | **audio/mpeg** audio/x-mpeg, audio/mp3 | mp3>root
+**.flac** | **audio/flac** | flac>root
+**.midi** | **audio/midi** audio/mid, audio/sp-midi, audio/x-mid, audio/x-midi | midi>root
+**.ape** | **audio/ape** | ape>root
+**.mpc** | **audio/musepack** | mpc>root
+**.amr** | **audio/amr** audio/amr-nb | amr>root
+**.wav** | **audio/wav** audio/x-wav, audio/vnd.wave, audio/wave | wav>root
+**.aiff** | **audio/aiff** audio/x-aiff | aiff>root
+**.au** | **audio/basic** | au>root
+**.mpeg** | **video/mpeg** | mpeg>root
+**.mov** | **video/quicktime** | mov>root
+**.mp4** | **video/mp4** | mp4>root
+**.avif** | **image/avif** | avif>mp4>root
+**.3gp** | **video/3gpp** video/3gp, audio/3gpp | 3gp>mp4>root
+**.3g2** | **video/3gpp2** video/3g2, audio/3gpp2 | 3g2>mp4>root
+**.mp4** | **audio/mp4** audio/x-mp4a | mp4>mp4>root
+**.mqv** | **video/quicktime** | mqv>mp4>root
+**.m4a** | **audio/x-m4a** | m4a>mp4>root
+**.m4v** | **video/x-m4v** | m4v>mp4>root
+**.heic** | **image/heic** | heic>mp4>root
+**.heic** | **image/heic-sequence** | heic>mp4>root
+**.heif** | **image/heif** | heif>mp4>root
+**.heif** | **image/heif-sequence** | heif>mp4>root
+**.mj2** | **video/mj2** | mj2>mp4>root
+**.dvb** | **video/vnd.dvb.file** | dvb>mp4>root
+**.webm** | **video/webm** audio/webm | webm>root
+**.avi** | **video/x-msvideo** video/avi, video/msvideo | avi>root
+**.flv** | **video/x-flv** | flv>root
+**.mkv** | **video/x-matroska** | mkv>root
+**.asf** | **video/x-ms-asf** video/asf, video/x-ms-wmv | asf>root
+**.aac** | **audio/aac** | aac>root
+**.voc** | **audio/x-unknown** | voc>root
+**.m3u** | **application/vnd.apple.mpegurl** audio/mpegurl | m3u>root
+**.rmvb** | **application/vnd.rn-realmedia-vbr** | rmvb>root
+**.gz** | **application/gzip** application/x-gzip, application/x-gunzip, application/gzipped, application/gzip-compressed, application/x-gzip-compressed, gzip/document | gz>root
+**.class** | **application/x-java-applet** | class>root
+**.swf** | **application/x-shockwave-flash** | swf>root
+**.crx** | **application/x-chrome-extension** | crx>root
+**.ttf** | **font/ttf** font/sfnt, application/x-font-ttf, application/font-sfnt | ttf>root
+**.woff** | **font/woff** | woff>root
+**.woff2** | **font/woff2** | woff2>root
+**.otf** | **font/otf** | otf>root
+**.ttc** | **font/collection** | ttc>root
+**.eot** | **application/vnd.ms-fontobject** | eot>root
+**.wasm** | **application/wasm** | wasm>root
+**.shx** | **application/vnd.shx** | shx>root
+**.shp** | **application/vnd.shp** | shp>shx>root
+**.dbf** | **application/x-dbf** | dbf>root
+**.dcm** | **application/dicom** | dcm>root
+**.rar** | **application/x-rar-compressed** application/x-rar | rar>root
+**.djvu** | **image/vnd.djvu** | djvu>root
+**.mobi** | **application/x-mobipocket-ebook** | mobi>root
+**.lit** | **application/x-ms-reader** | lit>root
+**.bpg** | **image/bpg** | bpg>root
+**.cbor** | **application/cbor** | cbor>root
+**.sqlite** | **application/vnd.sqlite3** application/x-sqlite3 | sqlite>root
+**.dwg** | **image/vnd.dwg** image/x-dwg, application/acad, application/x-acad, application/autocad_dwg, application/dwg, application/x-dwg, application/x-autocad, drawing/dwg | dwg>root
+**.nes** | **application/vnd.nintendo.snes.rom** | nes>root
+**.lnk** | **application/x-ms-shortcut** | lnk>root
+**.macho** | **application/x-mach-binary** | macho>root
+**.qcp** | **audio/qcelp** | qcp>root
+**.icns** | **image/x-icns** | icns>root
+**.hdr** | **image/vnd.radiance** | hdr>root
+**.mrc** | **application/marc** | mrc>root
+**.mdb** | **application/x-msaccess** | mdb>root
+**.accdb** | **application/x-msaccess** | accdb>root
+**.zst** | **application/zstd** | zst>root
+**.cab** | **application/vnd.ms-cab-compressed** | cab>root
+**.rpm** | **application/x-rpm** | rpm>root
+**.xz** | **application/x-xz** | xz>root
+**.lz** | **application/lzip** application/x-lzip | lz>root
+**.torrent** | **application/x-bittorrent** | torrent>root
+**.cpio** | **application/x-cpio** | cpio>root
+**n/a** | **application/tzif** | tzif>root
+**.xcf** | **image/x-xcf** | xcf>root
+**.pat** | **image/x-gimp-pat** | pat>root
+**.gbr** | **image/x-gimp-gbr** | gbr>root
+**.glb** | **model/gltf-binary** | glb>root
+**.cab** | **application/x-installshield** | cab>root
+**.jxr** | **image/jxr** image/vnd.ms-photo | jxr>root
+**.parquet** | **application/vnd.apache.parquet** application/x-parquet | parquet>root
+**.one** | **application/onenote** | one>root
+**.chm** | **application/vnd.ms-htmlhelp** | chm>root
+**.wpd** | **application/vnd.wordperfect** | wpd>root
+**.dxf** | **image/vnd.dxf** | dxf>root
+**.txt** | **text/plain** | txt>root
+**.svg** | **image/svg+xml** | svg>txt>root
+**.html** | **text/html** | html>txt>root
+**.xml** | **text/xml** application/xml | xml>txt>root
+**.rss** | **application/rss+xml** text/rss | rss>xml>txt>root
+**.atom** | **application/atom+xml** | atom>xml>txt>root
+**.x3d** | **model/x3d+xml** | x3d>xml>txt>root
+**.kml** | **application/vnd.google-earth.kml+xml** | kml>xml>txt>root
+**.xlf** | **application/x-xliff+xml** | xlf>xml>txt>root
+**.dae** | **model/vnd.collada+xml** | dae>xml>txt>root
+**.gml** | **application/gml+xml** | gml>xml>txt>root
+**.gpx** | **application/gpx+xml** | gpx>xml>txt>root
+**.tcx** | **application/vnd.garmin.tcx+xml** | tcx>xml>txt>root
+**.amf** | **application/x-amf** | amf>xml>txt>root
+**.3mf** | **application/vnd.ms-package.3dmanufacturing-3dmodel+xml** | 3mf>xml>txt>root
+**.xfdf** | **application/vnd.adobe.xfdf** | xfdf>xml>txt>root
+**.owl** | **application/owl+xml** | owl>xml>txt>root
+**.html** | **application/xhtml+xml** | html>xml>txt>root
+**.php** | **text/x-php** | php>txt>root
+**.js** | **text/javascript** application/x-javascript, application/javascript | js>txt>root
+**.lua** | **text/x-lua** | lua>txt>root
+**.pl** | **text/x-perl** | pl>txt>root
+**.py** | **text/x-python** text/x-script.python, application/x-python | py>txt>root
+**.rb** | **text/x-ruby** application/x-ruby | rb>txt>root
+**.json** | **application/json** | json>txt>root
+**.geojson** | **application/geo+json** | geojson>json>txt>root
+**.har** | **application/json** | har>json>txt>root
+**.gltf** | **model/gltf+json** | gltf>json>txt>root
+**.ndjson** | **application/x-ndjson** | ndjson>txt>root
+**.rtf** | **text/rtf** application/rtf | rtf>txt>root
+**.srt** | **application/x-subrip** application/x-srt, text/x-srt | srt>txt>root
+**.tcl** | **text/x-tcl** application/x-tcl | tcl>txt>root
+**.csv** | **text/csv** | csv>txt>root
+**.tsv** | **text/tab-separated-values** | tsv>txt>root
+**.vcf** | **text/vcard** | vcf>txt>root
+**.ics** | **text/calendar** | ics>txt>root
+**.warc** | **application/warc** | warc>txt>root
+**.vtt** | **text/vtt** | vtt>txt>root
+**.sh** | **text/x-shellscript** text/x-sh, application/x-shellscript, application/x-sh | sh>txt>root
+**.pbm** | **image/x-portable-bitmap** | pbm>txt>root
+**.pgm** | **image/x-portable-graymap** | pgm>txt>root
+**.ppm** | **image/x-portable-pixmap** | ppm>txt>root
+**.pam** | **image/x-portable-arbitrarymap** | pam>txt>root
diff --git a/vendor/github.com/gabriel-vasile/mimetype/tree.go b/vendor/github.com/gabriel-vasile/mimetype/tree.go
index 63a2093a..21b70d5c 100644
--- a/vendor/github.com/gabriel-vasile/mimetype/tree.go
+++ b/vendor/github.com/gabriel-vasile/mimetype/tree.go
@@ -18,12 +18,13 @@ import (
var root = newMIME("application/octet-stream", "",
func([]byte, uint32) bool { return true },
xpm, sevenZ, zip, pdf, fdf, ole, ps, psd, p7s, ogg, png, jpg, jxl, jp2, jpx,
- jpm, jxs, gif, webp, exe, elf, ar, tar, xar, bz2, fits, tiff, bmp, ico, mp3,
- flac, midi, ape, musePack, amr, wav, aiff, au, mpeg, quickTime, mp4, webM,
+ jpm, jxs, gif, webp, exe, elf, ar, tar, xar, bz2, fits, tiff, bmp, lotus, ico,
+ mp3, flac, midi, ape, musePack, amr, wav, aiff, au, mpeg, quickTime, mp4, webM,
avi, flv, mkv, asf, aac, voc, m3u, rmvb, gzip, class, swf, crx, ttf, woff,
woff2, otf, ttc, eot, wasm, shx, dbf, dcm, rar, djvu, mobi, lit, bpg, cbor,
sqlite3, dwg, nes, lnk, macho, qcp, icns, hdr, mrc, mdb, accdb, zstd, cab,
rpm, xz, lzip, torrent, cpio, tzif, xcf, pat, gbr, glb, cabIS, jxr, parquet,
+ oneNote, chm, wpd, dxf,
// Keep text last because it is the slowest check.
text,
)
@@ -48,24 +49,25 @@ var (
// This means APK should be a child of JAR detector, but in practice,
// the decisive signature for JAR might be located at the end of the file
// and not reachable because of library readLimit.
- zip = newMIME("application/zip", ".zip", magic.Zip, xlsx, docx, pptx, epub, apk, jar, odt, ods, odp, odg, odf, odc, sxc).
+ zip = newMIME("application/zip", ".zip", magic.Zip, docx, pptx, xlsx, epub, apk, jar, odt, ods, odp, odg, odf, odc, sxc, kmz, visio).
alias("application/x-zip", "application/x-zip-compressed")
tar = newMIME("application/x-tar", ".tar", magic.Tar)
xar = newMIME("application/x-xar", ".xar", magic.Xar)
bz2 = newMIME("application/x-bzip2", ".bz2", magic.Bz2)
- pdf = newMIME("application/pdf", ".pdf", magic.Pdf).
+ pdf = newMIME("application/pdf", ".pdf", magic.PDF).
alias("application/x-pdf")
- fdf = newMIME("application/vnd.fdf", ".fdf", magic.Fdf)
- xlsx = newMIME("application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", ".xlsx", magic.Xlsx)
- docx = newMIME("application/vnd.openxmlformats-officedocument.wordprocessingml.document", ".docx", magic.Docx)
- pptx = newMIME("application/vnd.openxmlformats-officedocument.presentationml.presentation", ".pptx", magic.Pptx)
- epub = newMIME("application/epub+zip", ".epub", magic.Epub)
- jar = newMIME("application/jar", ".jar", magic.Jar)
- apk = newMIME("application/vnd.android.package-archive", ".apk", magic.APK)
- ole = newMIME("application/x-ole-storage", "", magic.Ole, msi, aaf, msg, xls, pub, ppt, doc)
- msi = newMIME("application/x-ms-installer", ".msi", magic.Msi).
+ fdf = newMIME("application/vnd.fdf", ".fdf", magic.Fdf)
+ xlsx = newMIME("application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", ".xlsx", magic.Xlsx)
+ docx = newMIME("application/vnd.openxmlformats-officedocument.wordprocessingml.document", ".docx", magic.Docx)
+ pptx = newMIME("application/vnd.openxmlformats-officedocument.presentationml.presentation", ".pptx", magic.Pptx)
+ visio = newMIME("application/vnd.ms-visio.drawing.main+xml", ".vsdx", magic.Visio)
+ epub = newMIME("application/epub+zip", ".epub", magic.Epub)
+ jar = newMIME("application/java-archive", ".jar", magic.Jar).
+ alias("application/jar", "application/jar-archive", "application/x-java-archive")
+ apk = newMIME("application/vnd.android.package-archive", ".apk", magic.APK)
+ ole = newMIME("application/x-ole-storage", "", magic.Ole, msi, msg, xls, pub, ppt, doc)
+ msi = newMIME("application/x-ms-installer", ".msi", magic.Msi).
alias("application/x-windows-installer", "application/x-msi")
- aaf = newMIME("application/octet-stream", ".aaf", magic.Aaf)
doc = newMIME("application/msword", ".doc", magic.Doc).
alias("application/vnd.ms-word")
ppt = newMIME("application/vnd.ms-powerpoint", ".ppt", magic.Ppt).
@@ -75,18 +77,19 @@ var (
alias("application/msexcel")
msg = newMIME("application/vnd.ms-outlook", ".msg", magic.Msg)
ps = newMIME("application/postscript", ".ps", magic.Ps)
- fits = newMIME("application/fits", ".fits", magic.Fits)
+ fits = newMIME("application/fits", ".fits", magic.Fits).alias("image/fits")
ogg = newMIME("application/ogg", ".ogg", magic.Ogg, oggAudio, oggVideo).
alias("application/x-ogg")
oggAudio = newMIME("audio/ogg", ".oga", magic.OggAudio)
oggVideo = newMIME("video/ogg", ".ogv", magic.OggVideo)
- text = newMIME("text/plain", ".txt", magic.Text, html, svg, xml, php, js, lua, perl, python, json, ndJSON, rtf, srt, tcl, csv, tsv, vCard, iCalendar, warc, vtt)
- xml = newMIME("text/xml", ".xml", magic.XML, rss, atom, x3d, kml, xliff, collada, gml, gpx, tcx, amf, threemf, xfdf, owl2).
+ text = newMIME("text/plain", ".txt", magic.Text, svg, html, xml, php, js, lua, perl, python, ruby, json, ndJSON, rtf, srt, tcl, csv, tsv, vCard, iCalendar, warc, vtt, shell, netpbm, netpgm, netppm, netpam)
+ xml = newMIME("text/xml", ".xml", magic.XML, rss, atom, x3d, kml, xliff, collada, gml, gpx, tcx, amf, threemf, xfdf, owl2, xhtml).
alias("application/xml")
+ xhtml = newMIME("application/xhtml+xml", ".html", magic.XHTML)
json = newMIME("application/json", ".json", magic.JSON, geoJSON, har, gltf)
har = newMIME("application/json", ".har", magic.HAR)
- csv = newMIME("text/csv", ".csv", magic.Csv)
- tsv = newMIME("text/tab-separated-values", ".tsv", magic.Tsv)
+ csv = newMIME("text/csv", ".csv", magic.CSV)
+ tsv = newMIME("text/tab-separated-values", ".tsv", magic.TSV)
geoJSON = newMIME("application/geo+json", ".geojson", magic.GeoJSON)
ndJSON = newMIME("application/x-ndjson", ".ndjson", magic.NdJSON)
html = newMIME("text/html", ".html", magic.HTML)
@@ -101,6 +104,10 @@ var (
perl = newMIME("text/x-perl", ".pl", magic.Perl)
python = newMIME("text/x-python", ".py", magic.Python).
alias("text/x-script.python", "application/x-python")
+ ruby = newMIME("text/x-ruby", ".rb", magic.Ruby).
+ alias("application/x-ruby")
+ shell = newMIME("text/x-shellscript", ".sh", magic.Shell).
+ alias("text/x-sh", "application/x-shellscript", "application/x-sh")
tcl = newMIME("text/x-tcl", ".tcl", magic.Tcl).
alias("application/x-tcl")
vCard = newMIME("text/vcard", ".vcf", magic.VCard)
@@ -112,6 +119,7 @@ var (
atom = newMIME("application/atom+xml", ".atom", magic.Atom)
x3d = newMIME("model/x3d+xml", ".x3d", magic.X3d)
kml = newMIME("application/vnd.google-earth.kml+xml", ".kml", magic.Kml)
+ kmz = newMIME("application/vnd.google-earth.kmz", ".kmz", magic.KMZ)
xliff = newMIME("application/x-xliff+xml", ".xlf", magic.Xliff)
collada = newMIME("model/vnd.collada+xml", ".dae", magic.Collada)
gml = newMIME("application/gml+xml", ".gml", magic.Gml)
@@ -135,9 +143,12 @@ var (
tiff = newMIME("image/tiff", ".tiff", magic.Tiff)
bmp = newMIME("image/bmp", ".bmp", magic.Bmp).
alias("image/x-bmp", "image/x-ms-bmp")
- ico = newMIME("image/x-icon", ".ico", magic.Ico)
- icns = newMIME("image/x-icns", ".icns", magic.Icns)
- psd = newMIME("image/vnd.adobe.photoshop", ".psd", magic.Psd).
+ // lotus check must be done before ico because some ico detection is a bit
+ // relaxed and some lotus files are wrongfully identified as ico otherwise.
+ lotus = newMIME("application/vnd.lotus-1-2-3", ".123", magic.Lotus123)
+ ico = newMIME("image/x-icon", ".ico", magic.Ico)
+ icns = newMIME("image/x-icns", ".icns", magic.Icns)
+ psd = newMIME("image/vnd.adobe.photoshop", ".psd", magic.Psd).
alias("image/x-psd", "application/photoshop")
heic = newMIME("image/heic", ".heic", magic.Heic)
heicSeq = newMIME("image/heic-sequence", ".heic", magic.HeicSequence)
@@ -267,5 +278,13 @@ var (
jxr = newMIME("image/jxr", ".jxr", magic.Jxr).alias("image/vnd.ms-photo")
parquet = newMIME("application/vnd.apache.parquet", ".parquet", magic.Par1).
alias("application/x-parquet")
- cbor = newMIME("application/cbor", ".cbor", magic.CBOR)
+ netpbm = newMIME("image/x-portable-bitmap", ".pbm", magic.NetPBM)
+ netpgm = newMIME("image/x-portable-graymap", ".pgm", magic.NetPGM)
+ netppm = newMIME("image/x-portable-pixmap", ".ppm", magic.NetPPM)
+ netpam = newMIME("image/x-portable-arbitrarymap", ".pam", magic.NetPAM)
+ cbor = newMIME("application/cbor", ".cbor", magic.CBOR)
+ oneNote = newMIME("application/onenote", ".one", magic.One)
+ chm = newMIME("application/vnd.ms-htmlhelp", ".chm", magic.CHM)
+ wpd = newMIME("application/vnd.wordperfect", ".wpd", magic.WPD)
+ dxf = newMIME("image/vnd.dxf", ".dxf", magic.DXF)
)
diff --git a/vendor/github.com/go-openapi/jsonpointer/.cliff.toml b/vendor/github.com/go-openapi/jsonpointer/.cliff.toml
new file mode 100644
index 00000000..ae70028b
--- /dev/null
+++ b/vendor/github.com/go-openapi/jsonpointer/.cliff.toml
@@ -0,0 +1,181 @@
+# git-cliff ~ configuration file
+# https://git-cliff.org/docs/configuration
+
+[changelog]
+header = """
+"""
+
+footer = """
+
+-----
+
+**[{{ remote.github.repo }}]({{ self::remote_url() }}) license terms**
+
+[![License][license-badge]][license-url]
+
+[license-badge]: http://img.shields.io/badge/license-Apache%20v2-orange.svg
+[license-url]: {{ self::remote_url() }}/?tab=Apache-2.0-1-ov-file#readme
+
+{%- macro remote_url() -%}
+ https://github.com/{{ remote.github.owner }}/{{ remote.github.repo }}
+{%- endmacro -%}
+"""
+
+body = """
+{%- if version %}
+## [{{ version | trim_start_matches(pat="v") }}]({{ self::remote_url() }}/tree/{{ version }}) - {{ timestamp | date(format="%Y-%m-%d") }}
+{%- else %}
+## [unreleased]
+{%- endif %}
+{%- if message %}
+ {%- raw %}\n{% endraw %}
+{{ message }}
+ {%- raw %}\n{% endraw %}
+{%- endif %}
+{%- if version %}
+ {%- if previous.version %}
+
+**Full Changelog**: <{{ self::remote_url() }}/compare/{{ previous.version }}...{{ version }}>
+ {%- endif %}
+{%- else %}
+ {%- raw %}\n{% endraw %}
+{%- endif %}
+
+{%- if statistics %}{% if statistics.commit_count %}
+ {%- raw %}\n{% endraw %}
+{{ statistics.commit_count }} commits in this release.
+ {%- raw %}\n{% endraw %}
+{%- endif %}{% endif %}
+-----
+
+{%- for group, commits in commits | group_by(attribute="group") %}
+ {%- raw %}\n{% endraw %}
+### {{ group | upper_first }}
+ {%- raw %}\n{% endraw %}
+ {%- for commit in commits %}
+ {%- if commit.remote.pr_title %}
+ {%- set commit_message = commit.remote.pr_title %}
+ {%- else %}
+ {%- set commit_message = commit.message %}
+ {%- endif %}
+* {{ commit_message | split(pat="\n") | first | trim }}
+ {%- if commit.remote.username %}
+{%- raw %} {% endraw %}by [@{{ commit.remote.username }}](https://github.com/{{ commit.remote.username }})
+ {%- endif %}
+ {%- if commit.remote.pr_number %}
+{%- raw %} {% endraw %}in [#{{ commit.remote.pr_number }}]({{ self::remote_url() }}/pull/{{ commit.remote.pr_number }})
+ {%- endif %}
+{%- raw %} {% endraw %}[...]({{ self::remote_url() }}/commit/{{ commit.id }})
+ {%- endfor %}
+{%- endfor %}
+
+{%- if github %}
+{%- raw %}\n{% endraw -%}
+ {%- set all_contributors = github.contributors | length %}
+ {%- if github.contributors | filter(attribute="username", value="dependabot[bot]") | length < all_contributors %}
+-----
+
+### People who contributed to this release
+ {% endif %}
+ {%- for contributor in github.contributors | filter(attribute="username") | sort(attribute="username") %}
+ {%- if contributor.username != "dependabot[bot]" %}
+* [@{{ contributor.username }}](https://github.com/{{ contributor.username }})
+ {%- endif %}
+ {%- endfor %}
+
+ {% if github.contributors | filter(attribute="is_first_time", value=true) | length != 0 %}
+-----
+ {%- raw %}\n{% endraw %}
+
+### New Contributors
+ {%- endif %}
+
+ {%- for contributor in github.contributors | filter(attribute="is_first_time", value=true) %}
+ {%- if contributor.username != "dependabot[bot]" %}
+* @{{ contributor.username }} made their first contribution
+ {%- if contributor.pr_number %}
+ in [#{{ contributor.pr_number }}]({{ self::remote_url() }}/pull/{{ contributor.pr_number }}) \
+ {%- endif %}
+ {%- endif %}
+ {%- endfor %}
+{%- endif %}
+
+{%- raw %}\n{% endraw %}
+
+{%- macro remote_url() -%}
+ https://github.com/{{ remote.github.owner }}/{{ remote.github.repo }}
+{%- endmacro -%}
+"""
+# Remove leading and trailing whitespaces from the changelog's body.
+trim = true
+# Render body even when there are no releases to process.
+render_always = true
+# An array of regex based postprocessors to modify the changelog.
+postprocessors = [
+ # Replace the placeholder with a URL.
+ #{ pattern = '', replace = "https://github.com/orhun/git-cliff" },
+]
+# output file path
+# output = "test.md"
+
+[git]
+# Parse commits according to the conventional commits specification.
+# See https://www.conventionalcommits.org
+conventional_commits = false
+# Exclude commits that do not match the conventional commits specification.
+filter_unconventional = false
+# Require all commits to be conventional.
+# Takes precedence over filter_unconventional.
+require_conventional = false
+# Split commits on newlines, treating each line as an individual commit.
+split_commits = false
+# An array of regex based parsers to modify commit messages prior to further processing.
+commit_preprocessors = [
+ # Replace issue numbers with link templates to be updated in `changelog.postprocessors`.
+ #{ pattern = '\((\w+\s)?#([0-9]+)\)', replace = "([#${2}](/issues/${2}))"},
+ # Check spelling of the commit message using https://github.com/crate-ci/typos.
+ # If the spelling is incorrect, it will be fixed automatically.
+ #{ pattern = '.*', replace_command = 'typos --write-changes -' }
+]
+# Prevent commits that are breaking from being excluded by commit parsers.
+protect_breaking_commits = false
+# An array of regex based parsers for extracting data from the commit message.
+# Assigns commits to groups.
+# Optionally sets the commit's scope and can decide to exclude commits from further processing.
+commit_parsers = [
+ { message = "^[Cc]hore\\([Rr]elease\\): prepare for", skip = true },
+ { message = "(^[Mm]erge)|([Mm]erge conflict)", skip = true },
+ { field = "author.name", pattern = "dependabot*", group = "Updates" },
+ { message = "([Ss]ecurity)|([Vv]uln)", group = "Security" },
+ { body = "(.*[Ss]ecurity)|([Vv]uln)", group = "Security" },
+ { message = "([Cc]hore\\(lint\\))|(style)|(lint)|(codeql)|(golangci)", group = "Code quality" },
+ { message = "(^[Dd]oc)|((?i)readme)|(badge)|(typo)|(documentation)", group = "Documentation" },
+ { message = "(^[Ff]eat)|(^[Ee]nhancement)", group = "Implemented enhancements" },
+ { message = "(^ci)|(\\(ci\\))|(fixup\\s+ci)|(fix\\s+ci)|(license)|(example)", group = "Miscellaneous tasks" },
+ { message = "^test", group = "Testing" },
+ { message = "(^fix)|(panic)", group = "Fixed bugs" },
+ { message = "(^refact)|(rework)", group = "Refactor" },
+ { message = "(^[Pp]erf)|(performance)", group = "Performance" },
+ { message = "(^[Cc]hore)", group = "Miscellaneous tasks" },
+ { message = "^[Rr]evert", group = "Reverted changes" },
+ { message = "(upgrade.*?go)|(go\\s+version)", group = "Updates" },
+ { message = ".*", group = "Other" },
+]
+# Exclude commits that are not matched by any commit parser.
+filter_commits = false
+# An array of link parsers for extracting external references, and turning them into URLs, using regex.
+link_parsers = []
+# Include only the tags that belong to the current branch.
+use_branch_tags = false
+# Order releases topologically instead of chronologically.
+topo_order = false
+# Order releases topologically instead of chronologically.
+topo_order_commits = true
+# Order of commits in each group/release within the changelog.
+# Allowed values: newest, oldest
+sort_commits = "newest"
+# Process submodules commits
+recurse_submodules = false
+
+#[remote.github]
+#owner = "go-openapi"
diff --git a/vendor/github.com/go-openapi/jsonpointer/.gitignore b/vendor/github.com/go-openapi/jsonpointer/.gitignore
index 769c2440..59cd2948 100644
--- a/vendor/github.com/go-openapi/jsonpointer/.gitignore
+++ b/vendor/github.com/go-openapi/jsonpointer/.gitignore
@@ -1 +1,4 @@
-secrets.yml
+*.out
+*.cov
+.idea
+.env
diff --git a/vendor/github.com/go-openapi/jsonpointer/.golangci.yml b/vendor/github.com/go-openapi/jsonpointer/.golangci.yml
index d2fafb8a..fdae591b 100644
--- a/vendor/github.com/go-openapi/jsonpointer/.golangci.yml
+++ b/vendor/github.com/go-openapi/jsonpointer/.golangci.yml
@@ -1,56 +1,66 @@
-linters-settings:
- gocyclo:
- min-complexity: 45
- dupl:
- threshold: 200
- goconst:
- min-len: 2
- min-occurrences: 3
-
+version: "2"
linters:
- enable-all: true
+ default: all
disable:
- - recvcheck
- - unparam
- - lll
- - gochecknoinits
- - gochecknoglobals
+ - depguard
- funlen
- godox
- - gocognit
- - whitespace
- - wsl
- - wrapcheck
- - testpackage
- - nlreturn
- - errorlint
- - nestif
- - godot
- - gofumpt
- - paralleltest
- - tparallel
- - thelper
- exhaustruct
- - varnamelen
- - gci
- - depguard
- - errchkjson
- - inamedparam
+ - nlreturn
- nonamedreturns
- - musttag
- - ireturn
- - forcetypeassert
- - cyclop
- # deprecated linters
- #- deadcode
- #- interfacer
- #- scopelint
- #- varcheck
- #- structcheck
- #- golint
- #- nosnakecase
- #- maligned
- #- goerr113
- #- ifshort
- #- gomnd
- #- exhaustivestruct
+ - noinlineerr
+ - paralleltest
+ - recvcheck
+ - testpackage
+ - tparallel
+ - varnamelen
+ - whitespace
+ - wrapcheck
+ - wsl
+ - wsl_v5
+ settings:
+ dupl:
+ threshold: 200
+ goconst:
+ min-len: 2
+ min-occurrences: 3
+ cyclop:
+ max-complexity: 20
+ gocyclo:
+ min-complexity: 20
+ exhaustive:
+ default-signifies-exhaustive: true
+ default-case-required: true
+ lll:
+ line-length: 180
+ exclusions:
+ generated: lax
+ presets:
+ - comments
+ - common-false-positives
+ - legacy
+ - std-error-handling
+ paths:
+ - third_party$
+ - builtin$
+ - examples$
+formatters:
+ enable:
+ - gofmt
+ - goimports
+ - gofumpt
+ exclusions:
+ generated: lax
+ paths:
+ - third_party$
+ - builtin$
+ - examples$
+issues:
+ # Maximum issues count per one linter.
+ # Set to 0 to disable.
+ # Default: 50
+ max-issues-per-linter: 0
+ # Maximum count of issues with the same text.
+ # Set to 0 to disable.
+ # Default: 3
+ max-same-issues: 0
diff --git a/vendor/github.com/go-openapi/jsonpointer/CONTRIBUTORS.md b/vendor/github.com/go-openapi/jsonpointer/CONTRIBUTORS.md
new file mode 100644
index 00000000..aace4fcf
--- /dev/null
+++ b/vendor/github.com/go-openapi/jsonpointer/CONTRIBUTORS.md
@@ -0,0 +1,24 @@
+# Contributors
+
+- Repository: ['go-openapi/jsonpointer']
+
+| Total Contributors | Total Contributions |
+| --- | --- |
+| 12 | 90 |
+
+| Username | All Time Contribution Count | All Commits |
+| --- | --- | --- |
+| @fredbi | 43 | https://github.com/go-openapi/jsonpointer/commits?author=fredbi |
+| @casualjim | 33 | https://github.com/go-openapi/jsonpointer/commits?author=casualjim |
+| @magodo | 3 | https://github.com/go-openapi/jsonpointer/commits?author=magodo |
+| @youyuanwu | 3 | https://github.com/go-openapi/jsonpointer/commits?author=youyuanwu |
+| @gaiaz-iusipov | 1 | https://github.com/go-openapi/jsonpointer/commits?author=gaiaz-iusipov |
+| @gbjk | 1 | https://github.com/go-openapi/jsonpointer/commits?author=gbjk |
+| @gordallott | 1 | https://github.com/go-openapi/jsonpointer/commits?author=gordallott |
+| @ianlancetaylor | 1 | https://github.com/go-openapi/jsonpointer/commits?author=ianlancetaylor |
+| @mfleader | 1 | https://github.com/go-openapi/jsonpointer/commits?author=mfleader |
+| @Neo2308 | 1 | https://github.com/go-openapi/jsonpointer/commits?author=Neo2308 |
+| @olivierlemasle | 1 | https://github.com/go-openapi/jsonpointer/commits?author=olivierlemasle |
+| @testwill | 1 | https://github.com/go-openapi/jsonpointer/commits?author=testwill |
+
+ _this file was generated by the [Contributors GitHub Action](https://github.com/github/contributors)_
diff --git a/vendor/github.com/go-openapi/jsonpointer/LICENSE b/vendor/github.com/go-openapi/jsonpointer/LICENSE
index d6456956..261eeb9e 100644
--- a/vendor/github.com/go-openapi/jsonpointer/LICENSE
+++ b/vendor/github.com/go-openapi/jsonpointer/LICENSE
@@ -1,4 +1,3 @@
-
Apache License
Version 2.0, January 2004
http://www.apache.org/licenses/
diff --git a/vendor/github.com/go-openapi/jsonpointer/NOTICE b/vendor/github.com/go-openapi/jsonpointer/NOTICE
new file mode 100644
index 00000000..f3b51939
--- /dev/null
+++ b/vendor/github.com/go-openapi/jsonpointer/NOTICE
@@ -0,0 +1,39 @@
+Copyright 2015-2025 go-swagger maintainers
+
+// SPDX-FileCopyrightText: Copyright 2015-2025 go-swagger maintainers
+// SPDX-License-Identifier: Apache-2.0
+
+This software library, github.com/go-openapi/jsonpointer, includes software developed
+by the go-swagger and go-openapi maintainers ("go-swagger maintainers").
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this software except in compliance with the License.
+
+You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0.
+
+This software is copied from, derived from, and inspired by other original software products.
+It ships with copies of other software which license terms are recalled below.
+
+The original software was authored on 25-02-2013 by sigu-399 (https://github.com/sigu-399, sigu.399@gmail.com).
+
+github.com/sigh-399/jsonpointer
+===========================
+
+// SPDX-FileCopyrightText: Copyright 2013 sigu-399 ( https://github.com/sigu-399 )
+// SPDX-License-Identifier: Apache-2.0
+
+Copyright 2013 sigu-399 ( https://github.com/sigu-399 )
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
diff --git a/vendor/github.com/go-openapi/jsonpointer/README.md b/vendor/github.com/go-openapi/jsonpointer/README.md
index 0108f1d5..00cbfd74 100644
--- a/vendor/github.com/go-openapi/jsonpointer/README.md
+++ b/vendor/github.com/go-openapi/jsonpointer/README.md
@@ -1,19 +1,138 @@
-# gojsonpointer [](https://github.com/go-openapi/jsonpointer/actions?query=workflow%3A"go+test") [](https://codecov.io/gh/go-openapi/jsonpointer)
+# jsonpointer
-[](https://slackin.goswagger.io)
-[](https://raw.githubusercontent.com/go-openapi/jsonpointer/master/LICENSE)
-[](https://pkg.go.dev/github.com/go-openapi/jsonpointer)
-[](https://goreportcard.com/report/github.com/go-openapi/jsonpointer)
+
+[![Tests][test-badge]][test-url] [![Coverage][cov-badge]][cov-url] [![CI vuln scan][vuln-scan-badge]][vuln-scan-url] [![CodeQL][codeql-badge]][codeql-url]
+
+
+
+[![Release][release-badge]][release-url] [![Go Report Card][gocard-badge]][gocard-url] [![CodeFactor Grade][codefactor-badge]][codefactor-url] [![License][license-badge]][license-url]
+
+
+
+[![GoDoc][godoc-badge]][godoc-url] [![go version][goversion-badge]][goversion-url] ![Top language][top-badge] ![Commits since latest release][commits-badge]
-An implementation of JSON Pointer - Go language
+---
+
+An implementation of JSON Pointer for golang, which supports go `struct`.
## Status
-Completed YES
-Tested YES
+API is stable.
+
+## Import this library in your project
+
+```cmd
+go get github.com/go-openapi/jsonpointer
+```
+
+## Basic usage
+
+See also some [examples](./examples_test.go)
+
+### Retrieving a value
+
+```go
+ import (
+ "github.com/go-openapi/jsonpointer"
+ )
+
+
+ var doc any
+
+ ...
+
+ pointer, err := jsonpointer.New("/foo/1")
+ if err != nil {
+ ... // error: e.g. invalid JSON pointer specification
+ }
+
+ value, kind, err := pointer.Get(doc)
+ if err != nil {
+ ... // error: e.g. key not found, index out of bounds, etc.
+ }
+
+ ...
+```
+
+### Setting a value
+
+```go
+ ...
+ var doc any
+ ...
+ pointer, err := jsonpointer.New("/foo/1")
+ if err != nil {
+ ... // error: e.g. invalid JSON pointer specification
+ }
+
+ doc, err = p.Set(doc, "value")
+ if err != nil {
+ ... // error: e.g. key not found, index out of bounds, etc.
+ }
+```
+
+## Change log
+
+See
## References
-http://tools.ietf.org/html/draft-ietf-appsawg-json-pointer-07
-### Note
-The 4.Evaluation part of the previous reference, starting with 'If the currently referenced value is a JSON array, the reference token MUST contain either...' is not implemented.
+
+
+also known as [RFC6901](https://www.rfc-editor.org/rfc/rfc6901)
+
+## Licensing
+
+This library ships under the [SPDX-License-Identifier: Apache-2.0](./LICENSE).
+
+See the license [NOTICE](./NOTICE), which recalls the licensing terms of all the pieces of software
+on top of which it has been built.
+
+## Limitations
+
+The 4.Evaluation part of the previous reference, starting with 'If the currently referenced value is a JSON array,
+the reference token MUST contain either...' is not implemented.
+
+That is because our implementation of the JSON pointer only supports explicit references to array elements:
+the provision in the spec to resolve non-existent members as "the last element in the array",
+using the special trailing character "-" is not implemented.
+
+## Other documentation
+
+* [All-time contributors](./CONTRIBUTORS.md)
+* [Contributing guidelines](.github/CONTRIBUTING.md)
+* [Maintainers documentation](docs/MAINTAINERS.md)
+* [Code style](docs/STYLE.md)
+
+
+[test-badge]: https://github.com/go-openapi/jsonpointer/actions/workflows/go-test.yml/badge.svg
+[test-url]: https://github.com/go-openapi/jsonpointer/actions/workflows/go-test.yml
+[cov-badge]: https://codecov.io/gh/go-openapi/jsonpointer/branch/master/graph/badge.svg
+[cov-url]: https://codecov.io/gh/go-openapi/jsonpointer
+[vuln-scan-badge]: https://github.com/go-openapi/jsonpointer/actions/workflows/scanner.yml/badge.svg
+[vuln-scan-url]: https://github.com/go-openapi/jsonpointer/actions/workflows/scanner.yml
+[codeql-badge]: https://github.com/go-openapi/jsonpointer/actions/workflows/codeql.yml/badge.svg
+[codeql-url]: https://github.com/go-openapi/jsonpointer/actions/workflows/codeql.yml
+
+[release-badge]: https://badge.fury.io/go/github.com%2Fgo-openapi%2Fjsonpointer.svg
+[release-url]: https://badge.fury.io/go/github.com%2Fgo-openapi%2Fjsonpointer
+
+[gocard-badge]: https://goreportcard.com/badge/github.com/go-openapi/jsonpointer
+[gocard-url]: https://goreportcard.com/report/github.com/go-openapi/jsonpointer
+[codefactor-badge]: https://img.shields.io/codefactor/grade/github/go-openapi/jsonpointer
+[codefactor-url]: https://www.codefactor.io/repository/github/go-openapi/jsonpointer
+
+[doc-badge]: https://img.shields.io/badge/doc-site-blue?link=https%3A%2F%2Fgoswagger.io%2Fgo-openapi%2F
+[doc-url]: https://goswagger.io/go-openapi
+[godoc-badge]: https://pkg.go.dev/badge/github.com/go-openapi/jsonpointer
+[godoc-url]: http://pkg.go.dev/github.com/go-openapi/jsonpointer
+[slack-badge]: https://slackin.goswagger.io/badge.svg
+[slack-url]: https://slackin.goswagger.io
+
+[license-badge]: http://img.shields.io/badge/license-Apache%20v2-orange.svg
+[license-url]: https://github.com/go-openapi/jsonpointer/?tab=Apache-2.0-1-ov-file#readme
+
+[goversion-badge]: https://img.shields.io/github/go-mod/go-version/go-openapi/jsonpointer
+[goversion-url]: https://github.com/go-openapi/jsonpointer/blob/master/go.mod
+[top-badge]: https://img.shields.io/github/languages/top/go-openapi/jsonpointer
+[commits-badge]: https://img.shields.io/github/commits-since/go-openapi/jsonpointer/latest
diff --git a/vendor/github.com/go-openapi/jsonpointer/SECURITY.md b/vendor/github.com/go-openapi/jsonpointer/SECURITY.md
new file mode 100644
index 00000000..2a7b6f09
--- /dev/null
+++ b/vendor/github.com/go-openapi/jsonpointer/SECURITY.md
@@ -0,0 +1,19 @@
+# Security Policy
+
+This policy outlines the commitment and practices of the go-openapi maintainers regarding security.
+
+## Supported Versions
+
+| Version | Supported |
+| ------- | ------------------ |
+| 0.22.x | :white_check_mark: |
+
+## Reporting a vulnerability
+
+If you become aware of a security vulnerability that affects the current repository,
+please report it privately to the maintainers.
+
+Please follow the instructions provided by github to
+[Privately report a security vulnerability](https://docs.github.com/en/code-security/security-advisories/guidance-on-reporting-and-writing-information-about-vulnerabilities/privately-reporting-a-security-vulnerability#privately-reporting-a-security-vulnerability).
+
+TL;DR: on Github, navigate to the project's "Security" tab then click on "Report a vulnerability".
diff --git a/vendor/github.com/go-openapi/jsonpointer/errors.go b/vendor/github.com/go-openapi/jsonpointer/errors.go
index b84343d9..8c50dde8 100644
--- a/vendor/github.com/go-openapi/jsonpointer/errors.go
+++ b/vendor/github.com/go-openapi/jsonpointer/errors.go
@@ -1,5 +1,10 @@
+// SPDX-FileCopyrightText: Copyright (c) 2015-2025 go-swagger maintainers
+// SPDX-License-Identifier: Apache-2.0
+
package jsonpointer
+import "fmt"
+
type pointerError string
func (e pointerError) Error() string {
@@ -7,12 +12,24 @@ func (e pointerError) Error() string {
}
const (
- // ErrPointer is an error raised by the jsonpointer package
+ // ErrPointer is a sentinel error raised by all errors from this package.
ErrPointer pointerError = "JSON pointer error"
- // ErrInvalidStart states that a JSON pointer must start with a separator ("/")
+ // ErrInvalidStart states that a JSON pointer must start with a separator ("/").
ErrInvalidStart pointerError = `JSON pointer must be empty or start with a "` + pointerSeparator
- // ErrUnsupportedValueType indicates that a value of the wrong type is being set
+ // ErrUnsupportedValueType indicates that a value of the wrong type is being set.
ErrUnsupportedValueType pointerError = "only structs, pointers, maps and slices are supported for setting values"
)
+
+func errNoKey(key string) error {
+ return fmt.Errorf("object has no key %q: %w", key, ErrPointer)
+}
+
+func errOutOfBounds(length, idx int) error {
+ return fmt.Errorf("index out of bounds array[0,%d] index '%d': %w", length-1, idx, ErrPointer)
+}
+
+func errInvalidReference(token string) error {
+ return fmt.Errorf("invalid token reference %q: %w", token, ErrPointer)
+}
diff --git a/vendor/github.com/go-openapi/jsonpointer/pointer.go b/vendor/github.com/go-openapi/jsonpointer/pointer.go
index a08cd68a..7df49af3 100644
--- a/vendor/github.com/go-openapi/jsonpointer/pointer.go
+++ b/vendor/github.com/go-openapi/jsonpointer/pointer.go
@@ -1,28 +1,7 @@
-// Copyright 2013 sigu-399 ( https://github.com/sigu-399 )
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-// author sigu-399
-// author-github https://github.com/sigu-399
-// author-mail sigu.399@gmail.com
-//
-// repository-name jsonpointer
-// repository-desc An implementation of JSON Pointer - Go language
-//
-// description Main and unique file.
-//
-// created 25-02-2013
+// SPDX-FileCopyrightText: Copyright (c) 2015-2025 go-swagger maintainers
+// SPDX-License-Identifier: Apache-2.0
+// Package jsonpointer provides a golang implementation for json pointers.
package jsonpointer
import (
@@ -33,7 +12,7 @@ import (
"strconv"
"strings"
- "github.com/go-openapi/swag"
+ "github.com/go-openapi/swag/jsonname"
)
const (
@@ -41,344 +20,93 @@ const (
pointerSeparator = `/`
)
-var jsonPointableType = reflect.TypeOf(new(JSONPointable)).Elem()
-var jsonSetableType = reflect.TypeOf(new(JSONSetable)).Elem()
-
-// JSONPointable is an interface for structs to implement when they need to customize the
-// json pointer process
+// JSONPointable is an interface for structs to implement,
+// when they need to customize the json pointer process or want to avoid the use of reflection.
type JSONPointable interface {
- JSONLookup(string) (any, error)
+ // JSONLookup returns a value pointed at this (unescaped) key.
+ JSONLookup(key string) (any, error)
}
-// JSONSetable is an interface for structs to implement when they need to customize the
-// json pointer process
+// JSONSetable is an interface for structs to implement,
+// when they need to customize the json pointer process or want to avoid the use of reflection.
type JSONSetable interface {
- JSONSet(string, any) error
+ // JSONSet sets the value pointed at the (unescaped) key.
+ JSONSet(key string, value any) error
}
-// New creates a new json pointer for the given string
-func New(jsonPointerString string) (Pointer, error) {
-
- var p Pointer
- err := p.parse(jsonPointerString)
- return p, err
-
-}
-
-// Pointer the json pointer reprsentation
+// Pointer is a representation of a json pointer.
+//
+// Use [Pointer.Get] to retrieve a value or [Pointer.Set] to set a value.
+//
+// It works with any go type interpreted as a JSON document, which means:
+//
+// - if a type implements [JSONPointable], its [JSONPointable.JSONLookup] method is used to resolve [Pointer.Get]
+// - if a type implements [JSONSetable], its [JSONPointable.JSONSet] method is used to resolve [Pointer.Set]
+// - a go map[K]V is interpreted as an object, with type K assignable to a string
+// - a go slice []T is interpreted as an array
+// - a go struct is interpreted as an object, with exported fields interpreted as keys
+// - promoted fields from an embedded struct are traversed
+// - scalars (e.g. int, float64 ...), channels, functions and go arrays cannot be traversed
+//
+// For struct s resolved by reflection, key mappings honor the conventional struct tag `json`.
+//
+// Fields that do not specify a `json` tag, or specify an empty one, or are tagged as `json:"-"` are ignored.
+//
+// # Limitations
+//
+// - Unlike go standard marshaling, untagged fields do not default to the go field name and are ignored.
+// - anonymous fields are not traversed if untagged
type Pointer struct {
referenceTokens []string
}
-// "Constructor", parses the given string JSON pointer
-func (p *Pointer) parse(jsonPointerString string) error {
+// New creates a new json pointer from its string representation.
+func New(jsonPointerString string) (Pointer, error) {
+ var p Pointer
+ err := p.parse(jsonPointerString)
- var err error
-
- if jsonPointerString != emptyPointer {
- if !strings.HasPrefix(jsonPointerString, pointerSeparator) {
- err = errors.Join(ErrInvalidStart, ErrPointer)
- } else {
- referenceTokens := strings.Split(jsonPointerString, pointerSeparator)
- p.referenceTokens = append(p.referenceTokens, referenceTokens[1:]...)
- }
- }
-
- return err
+ return p, err
}
-// Get uses the pointer to retrieve a value from a JSON document
+// Get uses the pointer to retrieve a value from a JSON document.
+//
+// It returns the value with its type as a [reflect.Kind] or an error.
func (p *Pointer) Get(document any) (any, reflect.Kind, error) {
- return p.get(document, swag.DefaultJSONNameProvider)
+ return p.get(document, jsonname.DefaultJSONNameProvider)
}
-// Set uses the pointer to set a value from a JSON document
+// Set uses the pointer to set a value from a data type
+// that represent a JSON document.
+//
+// It returns the updated document.
func (p *Pointer) Set(document any, value any) (any, error) {
- return document, p.set(document, value, swag.DefaultJSONNameProvider)
+ return document, p.set(document, value, jsonname.DefaultJSONNameProvider)
}
-// GetForToken gets a value for a json pointer token 1 level deep
-func GetForToken(document any, decodedToken string) (any, reflect.Kind, error) {
- return getSingleImpl(document, decodedToken, swag.DefaultJSONNameProvider)
-}
-
-// SetForToken gets a value for a json pointer token 1 level deep
-func SetForToken(document any, decodedToken string, value any) (any, error) {
- return document, setSingleImpl(document, value, decodedToken, swag.DefaultJSONNameProvider)
-}
-
-func isNil(input any) bool {
- if input == nil {
- return true
- }
-
- kind := reflect.TypeOf(input).Kind()
- switch kind { //nolint:exhaustive
- case reflect.Ptr, reflect.Map, reflect.Slice, reflect.Chan:
- return reflect.ValueOf(input).IsNil()
- default:
- return false
- }
-}
-
-func getSingleImpl(node any, decodedToken string, nameProvider *swag.NameProvider) (any, reflect.Kind, error) {
- rValue := reflect.Indirect(reflect.ValueOf(node))
- kind := rValue.Kind()
- if isNil(node) {
- return nil, kind, fmt.Errorf("nil value has no field %q: %w", decodedToken, ErrPointer)
- }
-
- switch typed := node.(type) {
- case JSONPointable:
- r, err := typed.JSONLookup(decodedToken)
- if err != nil {
- return nil, kind, err
- }
- return r, kind, nil
- case *any: // case of a pointer to interface, that is not resolved by reflect.Indirect
- return getSingleImpl(*typed, decodedToken, nameProvider)
- }
-
- switch kind { //nolint:exhaustive
- case reflect.Struct:
- nm, ok := nameProvider.GetGoNameForType(rValue.Type(), decodedToken)
- if !ok {
- return nil, kind, fmt.Errorf("object has no field %q: %w", decodedToken, ErrPointer)
- }
- fld := rValue.FieldByName(nm)
- return fld.Interface(), kind, nil
-
- case reflect.Map:
- kv := reflect.ValueOf(decodedToken)
- mv := rValue.MapIndex(kv)
-
- if mv.IsValid() {
- return mv.Interface(), kind, nil
- }
- return nil, kind, fmt.Errorf("object has no key %q: %w", decodedToken, ErrPointer)
-
- case reflect.Slice:
- tokenIndex, err := strconv.Atoi(decodedToken)
- if err != nil {
- return nil, kind, err
- }
- sLength := rValue.Len()
- if tokenIndex < 0 || tokenIndex >= sLength {
- return nil, kind, fmt.Errorf("index out of bounds array[0,%d] index '%d': %w", sLength-1, tokenIndex, ErrPointer)
- }
-
- elem := rValue.Index(tokenIndex)
- return elem.Interface(), kind, nil
-
- default:
- return nil, kind, fmt.Errorf("invalid token reference %q: %w", decodedToken, ErrPointer)
- }
-
-}
-
-func setSingleImpl(node, data any, decodedToken string, nameProvider *swag.NameProvider) error {
- rValue := reflect.Indirect(reflect.ValueOf(node))
-
- if ns, ok := node.(JSONSetable); ok { // pointer impl
- return ns.JSONSet(decodedToken, data)
- }
-
- if rValue.Type().Implements(jsonSetableType) {
- return node.(JSONSetable).JSONSet(decodedToken, data)
- }
-
- switch rValue.Kind() { //nolint:exhaustive
- case reflect.Struct:
- nm, ok := nameProvider.GetGoNameForType(rValue.Type(), decodedToken)
- if !ok {
- return fmt.Errorf("object has no field %q: %w", decodedToken, ErrPointer)
- }
- fld := rValue.FieldByName(nm)
- if fld.IsValid() {
- fld.Set(reflect.ValueOf(data))
- }
- return nil
-
- case reflect.Map:
- kv := reflect.ValueOf(decodedToken)
- rValue.SetMapIndex(kv, reflect.ValueOf(data))
- return nil
-
- case reflect.Slice:
- tokenIndex, err := strconv.Atoi(decodedToken)
- if err != nil {
- return err
- }
- sLength := rValue.Len()
- if tokenIndex < 0 || tokenIndex >= sLength {
- return fmt.Errorf("index out of bounds array[0,%d] index '%d': %w", sLength, tokenIndex, ErrPointer)
- }
-
- elem := rValue.Index(tokenIndex)
- if !elem.CanSet() {
- return fmt.Errorf("can't set slice index %s to %v: %w", decodedToken, data, ErrPointer)
- }
- elem.Set(reflect.ValueOf(data))
- return nil
-
- default:
- return fmt.Errorf("invalid token reference %q: %w", decodedToken, ErrPointer)
- }
-
-}
-
-func (p *Pointer) get(node any, nameProvider *swag.NameProvider) (any, reflect.Kind, error) {
-
- if nameProvider == nil {
- nameProvider = swag.DefaultJSONNameProvider
- }
-
- kind := reflect.Invalid
-
- // Full document when empty
- if len(p.referenceTokens) == 0 {
- return node, kind, nil
- }
-
- for _, token := range p.referenceTokens {
- decodedToken := Unescape(token)
-
- r, knd, err := getSingleImpl(node, decodedToken, nameProvider)
- if err != nil {
- return nil, knd, err
- }
- node = r
- }
-
- rValue := reflect.ValueOf(node)
- kind = rValue.Kind()
-
- return node, kind, nil
-}
-
-func (p *Pointer) set(node, data any, nameProvider *swag.NameProvider) error {
- knd := reflect.ValueOf(node).Kind()
-
- if knd != reflect.Ptr && knd != reflect.Struct && knd != reflect.Map && knd != reflect.Slice && knd != reflect.Array {
- return errors.Join(
- ErrUnsupportedValueType,
- ErrPointer,
- )
- }
-
- if nameProvider == nil {
- nameProvider = swag.DefaultJSONNameProvider
- }
-
- // Full document when empty
- if len(p.referenceTokens) == 0 {
- return nil
- }
-
- lastI := len(p.referenceTokens) - 1
- for i, token := range p.referenceTokens {
- isLastToken := i == lastI
- decodedToken := Unescape(token)
-
- if isLastToken {
-
- return setSingleImpl(node, data, decodedToken, nameProvider)
- }
-
- rValue := reflect.Indirect(reflect.ValueOf(node))
- kind := rValue.Kind()
-
- if rValue.Type().Implements(jsonPointableType) {
- r, err := node.(JSONPointable).JSONLookup(decodedToken)
- if err != nil {
- return err
- }
- fld := reflect.ValueOf(r)
- if fld.CanAddr() && fld.Kind() != reflect.Interface && fld.Kind() != reflect.Map && fld.Kind() != reflect.Slice && fld.Kind() != reflect.Ptr {
- node = fld.Addr().Interface()
- continue
- }
- node = r
- continue
- }
-
- switch kind { //nolint:exhaustive
- case reflect.Struct:
- nm, ok := nameProvider.GetGoNameForType(rValue.Type(), decodedToken)
- if !ok {
- return fmt.Errorf("object has no field %q: %w", decodedToken, ErrPointer)
- }
- fld := rValue.FieldByName(nm)
- if fld.CanAddr() && fld.Kind() != reflect.Interface && fld.Kind() != reflect.Map && fld.Kind() != reflect.Slice && fld.Kind() != reflect.Ptr {
- node = fld.Addr().Interface()
- continue
- }
- node = fld.Interface()
-
- case reflect.Map:
- kv := reflect.ValueOf(decodedToken)
- mv := rValue.MapIndex(kv)
-
- if !mv.IsValid() {
- return fmt.Errorf("object has no key %q: %w", decodedToken, ErrPointer)
- }
- if mv.CanAddr() && mv.Kind() != reflect.Interface && mv.Kind() != reflect.Map && mv.Kind() != reflect.Slice && mv.Kind() != reflect.Ptr {
- node = mv.Addr().Interface()
- continue
- }
- node = mv.Interface()
-
- case reflect.Slice:
- tokenIndex, err := strconv.Atoi(decodedToken)
- if err != nil {
- return err
- }
- sLength := rValue.Len()
- if tokenIndex < 0 || tokenIndex >= sLength {
- return fmt.Errorf("index out of bounds array[0,%d] index '%d': %w", sLength, tokenIndex, ErrPointer)
- }
-
- elem := rValue.Index(tokenIndex)
- if elem.CanAddr() && elem.Kind() != reflect.Interface && elem.Kind() != reflect.Map && elem.Kind() != reflect.Slice && elem.Kind() != reflect.Ptr {
- node = elem.Addr().Interface()
- continue
- }
- node = elem.Interface()
-
- default:
- return fmt.Errorf("invalid token reference %q: %w", decodedToken, ErrPointer)
- }
-
- }
-
- return nil
-}
-
-// DecodedTokens returns the decoded tokens
+// DecodedTokens returns the decoded (unescaped) tokens of this JSON pointer.
func (p *Pointer) DecodedTokens() []string {
result := make([]string, 0, len(p.referenceTokens))
- for _, t := range p.referenceTokens {
- result = append(result, Unescape(t))
+ for _, token := range p.referenceTokens {
+ result = append(result, Unescape(token))
}
+
return result
}
-// IsEmpty returns true if this is an empty json pointer
-// this indicates that it points to the root document
+// IsEmpty returns true if this is an empty json pointer.
+//
+// This indicates that it points to the root document.
func (p *Pointer) IsEmpty() bool {
return len(p.referenceTokens) == 0
}
-// Pointer to string representation function
+// String representation of a pointer.
func (p *Pointer) String() string {
-
if len(p.referenceTokens) == 0 {
return emptyPointer
}
- pointerString := pointerSeparator + strings.Join(p.referenceTokens, pointerSeparator)
-
- return pointerString
+ return pointerSeparator + strings.Join(p.referenceTokens, pointerSeparator)
}
func (p *Pointer) Offset(document string) (int64, error) {
@@ -412,6 +140,319 @@ func (p *Pointer) Offset(document string) (int64, error) {
return offset, nil
}
+// "Constructor", parses the given string JSON pointer.
+func (p *Pointer) parse(jsonPointerString string) error {
+ if jsonPointerString == emptyPointer {
+ return nil
+ }
+
+ if !strings.HasPrefix(jsonPointerString, pointerSeparator) {
+ // non empty pointer must start with "/"
+ return errors.Join(ErrInvalidStart, ErrPointer)
+ }
+
+ referenceTokens := strings.Split(jsonPointerString, pointerSeparator)
+ p.referenceTokens = append(p.referenceTokens, referenceTokens[1:]...)
+
+ return nil
+}
+
+func (p *Pointer) get(node any, nameProvider *jsonname.NameProvider) (any, reflect.Kind, error) {
+ if nameProvider == nil {
+ nameProvider = jsonname.DefaultJSONNameProvider
+ }
+
+ kind := reflect.Invalid
+
+ // full document when empty
+ if len(p.referenceTokens) == 0 {
+ return node, kind, nil
+ }
+
+ for _, token := range p.referenceTokens {
+ decodedToken := Unescape(token)
+
+ r, knd, err := getSingleImpl(node, decodedToken, nameProvider)
+ if err != nil {
+ return nil, knd, err
+ }
+ node = r
+ }
+
+ rValue := reflect.ValueOf(node)
+ kind = rValue.Kind()
+
+ return node, kind, nil
+}
+
+func (p *Pointer) set(node, data any, nameProvider *jsonname.NameProvider) error {
+ knd := reflect.ValueOf(node).Kind()
+
+ if knd != reflect.Pointer && knd != reflect.Struct && knd != reflect.Map && knd != reflect.Slice && knd != reflect.Array {
+ return errors.Join(
+ fmt.Errorf("unexpected type: %T", node), //nolint:err113 // err wrapping is carried out by errors.Join, not fmt.Errorf.
+ ErrUnsupportedValueType,
+ ErrPointer,
+ )
+ }
+
+ l := len(p.referenceTokens)
+
+ // full document when empty
+ if l == 0 {
+ return nil
+ }
+
+ if nameProvider == nil {
+ nameProvider = jsonname.DefaultJSONNameProvider
+ }
+
+ var decodedToken string
+ lastIndex := l - 1
+
+ if lastIndex > 0 { // skip if we only have one token in pointer
+ for _, token := range p.referenceTokens[:lastIndex] {
+ decodedToken = Unescape(token)
+ next, err := p.resolveNodeForToken(node, decodedToken, nameProvider)
+ if err != nil {
+ return err
+ }
+
+ node = next
+ }
+ }
+
+ // last token
+ decodedToken = Unescape(p.referenceTokens[lastIndex])
+
+ return setSingleImpl(node, data, decodedToken, nameProvider)
+}
+
+func (p *Pointer) resolveNodeForToken(node any, decodedToken string, nameProvider *jsonname.NameProvider) (next any, err error) {
+ // check for nil during traversal
+ if isNil(node) {
+ return nil, fmt.Errorf("cannot traverse through nil value at %q: %w", decodedToken, ErrPointer)
+ }
+
+ pointable, ok := node.(JSONPointable)
+ if ok {
+ r, err := pointable.JSONLookup(decodedToken)
+ if err != nil {
+ return nil, err
+ }
+
+ fld := reflect.ValueOf(r)
+ if fld.CanAddr() && fld.Kind() != reflect.Interface && fld.Kind() != reflect.Map && fld.Kind() != reflect.Slice && fld.Kind() != reflect.Pointer {
+ return fld.Addr().Interface(), nil
+ }
+
+ return r, nil
+ }
+
+ rValue := reflect.Indirect(reflect.ValueOf(node))
+ kind := rValue.Kind()
+
+ switch kind {
+ case reflect.Struct:
+ nm, ok := nameProvider.GetGoNameForType(rValue.Type(), decodedToken)
+ if !ok {
+ return nil, fmt.Errorf("object has no field %q: %w", decodedToken, ErrPointer)
+ }
+
+ return typeFromValue(rValue.FieldByName(nm)), nil
+
+ case reflect.Map:
+ kv := reflect.ValueOf(decodedToken)
+ mv := rValue.MapIndex(kv)
+
+ if !mv.IsValid() {
+ return nil, errNoKey(decodedToken)
+ }
+
+ return typeFromValue(mv), nil
+
+ case reflect.Slice:
+ tokenIndex, err := strconv.Atoi(decodedToken)
+ if err != nil {
+ return nil, errors.Join(err, ErrPointer)
+ }
+
+ sLength := rValue.Len()
+ if tokenIndex < 0 || tokenIndex >= sLength {
+ return nil, errOutOfBounds(sLength, tokenIndex)
+ }
+
+ return typeFromValue(rValue.Index(tokenIndex)), nil
+
+ default:
+ return nil, errInvalidReference(decodedToken)
+ }
+}
+
+func isNil(input any) bool {
+ if input == nil {
+ return true
+ }
+
+ kind := reflect.TypeOf(input).Kind()
+ switch kind {
+ case reflect.Pointer, reflect.Map, reflect.Slice, reflect.Chan:
+ return reflect.ValueOf(input).IsNil()
+ default:
+ return false
+ }
+}
+
+func typeFromValue(v reflect.Value) any {
+ if v.CanAddr() && v.Kind() != reflect.Interface && v.Kind() != reflect.Map && v.Kind() != reflect.Slice && v.Kind() != reflect.Pointer {
+ return v.Addr().Interface()
+ }
+
+ return v.Interface()
+}
+
+// GetForToken gets a value for a json pointer token 1 level deep.
+func GetForToken(document any, decodedToken string) (any, reflect.Kind, error) {
+ return getSingleImpl(document, decodedToken, jsonname.DefaultJSONNameProvider)
+}
+
+// SetForToken sets a value for a json pointer token 1 level deep.
+func SetForToken(document any, decodedToken string, value any) (any, error) {
+ return document, setSingleImpl(document, value, decodedToken, jsonname.DefaultJSONNameProvider)
+}
+
+func getSingleImpl(node any, decodedToken string, nameProvider *jsonname.NameProvider) (any, reflect.Kind, error) {
+ rValue := reflect.Indirect(reflect.ValueOf(node))
+ kind := rValue.Kind()
+ if isNil(node) {
+ return nil, kind, fmt.Errorf("nil value has no field %q: %w", decodedToken, ErrPointer)
+ }
+
+ switch typed := node.(type) {
+ case JSONPointable:
+ r, err := typed.JSONLookup(decodedToken)
+ if err != nil {
+ return nil, kind, err
+ }
+ return r, kind, nil
+ case *any: // case of a pointer to interface, that is not resolved by reflect.Indirect
+ return getSingleImpl(*typed, decodedToken, nameProvider)
+ }
+
+ switch kind {
+ case reflect.Struct:
+ nm, ok := nameProvider.GetGoNameForType(rValue.Type(), decodedToken)
+ if !ok {
+ return nil, kind, fmt.Errorf("object has no field %q: %w", decodedToken, ErrPointer)
+ }
+
+ fld := rValue.FieldByName(nm)
+
+ return fld.Interface(), kind, nil
+
+ case reflect.Map:
+ kv := reflect.ValueOf(decodedToken)
+ mv := rValue.MapIndex(kv)
+
+ if mv.IsValid() {
+ return mv.Interface(), kind, nil
+ }
+
+ return nil, kind, errNoKey(decodedToken)
+
+ case reflect.Slice:
+ tokenIndex, err := strconv.Atoi(decodedToken)
+ if err != nil {
+ return nil, kind, errors.Join(err, ErrPointer)
+ }
+ sLength := rValue.Len()
+ if tokenIndex < 0 || tokenIndex >= sLength {
+ return nil, kind, errOutOfBounds(sLength, tokenIndex)
+ }
+
+ elem := rValue.Index(tokenIndex)
+ return elem.Interface(), kind, nil
+
+ default:
+ return nil, kind, errInvalidReference(decodedToken)
+ }
+}
+
+func setSingleImpl(node, data any, decodedToken string, nameProvider *jsonname.NameProvider) error {
+ // check for nil to prevent panic when calling rValue.Type()
+ if isNil(node) {
+ return fmt.Errorf("cannot set field %q on nil value: %w", decodedToken, ErrPointer)
+ }
+
+ if ns, ok := node.(JSONSetable); ok {
+ return ns.JSONSet(decodedToken, data)
+ }
+
+ rValue := reflect.Indirect(reflect.ValueOf(node))
+
+ switch rValue.Kind() {
+ case reflect.Struct:
+ nm, ok := nameProvider.GetGoNameForType(rValue.Type(), decodedToken)
+ if !ok {
+ return fmt.Errorf("object has no field %q: %w", decodedToken, ErrPointer)
+ }
+
+ fld := rValue.FieldByName(nm)
+ if !fld.CanSet() {
+ return fmt.Errorf("can't set struct field %s to %v: %w", nm, data, ErrPointer)
+ }
+
+ value := reflect.ValueOf(data)
+ valueType := value.Type()
+ assignedType := fld.Type()
+
+ if !valueType.AssignableTo(assignedType) {
+ return fmt.Errorf("can't set value with type %T to field %s with type %v: %w", data, nm, assignedType, ErrPointer)
+ }
+
+ fld.Set(value)
+
+ return nil
+
+ case reflect.Map:
+ kv := reflect.ValueOf(decodedToken)
+ rValue.SetMapIndex(kv, reflect.ValueOf(data))
+
+ return nil
+
+ case reflect.Slice:
+ tokenIndex, err := strconv.Atoi(decodedToken)
+ if err != nil {
+ return errors.Join(err, ErrPointer)
+ }
+
+ sLength := rValue.Len()
+ if tokenIndex < 0 || tokenIndex >= sLength {
+ return errOutOfBounds(sLength, tokenIndex)
+ }
+
+ elem := rValue.Index(tokenIndex)
+ if !elem.CanSet() {
+ return fmt.Errorf("can't set slice index %s to %v: %w", decodedToken, data, ErrPointer)
+ }
+
+ value := reflect.ValueOf(data)
+ valueType := value.Type()
+ assignedType := elem.Type()
+
+ if !valueType.AssignableTo(assignedType) {
+ return fmt.Errorf("can't set value with type %T to slice element %d with type %v: %w", data, tokenIndex, assignedType, ErrPointer)
+ }
+
+ elem.Set(value)
+
+ return nil
+
+ default:
+ return errInvalidReference(decodedToken)
+ }
+}
+
func offsetSingleObject(dec *json.Decoder, decodedToken string) (int64, error) {
for dec.More() {
offset := dec.InputOffset()
@@ -439,13 +480,14 @@ func offsetSingleObject(dec *json.Decoder, decodedToken string) (int64, error) {
return 0, fmt.Errorf("invalid token %#v: %w", tk, ErrPointer)
}
}
+
return 0, fmt.Errorf("token reference %q not found: %w", decodedToken, ErrPointer)
}
func offsetSingleArray(dec *json.Decoder, decodedToken string) (int64, error) {
idx, err := strconv.Atoi(decodedToken)
if err != nil {
- return 0, fmt.Errorf("token reference %q is not a number: %v: %w", decodedToken, err, ErrPointer)
+ return 0, fmt.Errorf("token reference %q is not a number: %w: %w", decodedToken, err, ErrPointer)
}
var i int
for i = 0; i < idx && dec.More(); i++ {
@@ -471,10 +513,12 @@ func offsetSingleArray(dec *json.Decoder, decodedToken string) (int64, error) {
if !dec.More() {
return 0, fmt.Errorf("token reference %q not found: %w", decodedToken, ErrPointer)
}
+
return dec.InputOffset(), nil
}
// drainSingle drains a single level of object or array.
+//
// The decoder has to guarantee the beginning delim (i.e. '{' or '[') has been consumed.
func drainSingle(dec *json.Decoder) error {
for dec.More() {
@@ -496,14 +540,15 @@ func drainSingle(dec *json.Decoder) error {
}
}
- // Consumes the ending delim
+ // consumes the ending delim
if _, err := dec.Token(); err != nil {
return err
}
+
return nil
}
-// Specific JSON pointer encoding here
+// JSON pointer encoding:
// ~0 => ~
// ~1 => /
// ... and vice versa
@@ -515,16 +560,24 @@ const (
decRefTok1 = `/`
)
-// Unescape unescapes a json pointer reference token string to the original representation
+var (
+ encRefTokReplacer = strings.NewReplacer(encRefTok1, decRefTok1, encRefTok0, decRefTok0) //nolint:gochecknoglobals // it's okay to declare a replacer as a private global
+ decRefTokReplacer = strings.NewReplacer(decRefTok1, encRefTok1, decRefTok0, encRefTok0) //nolint:gochecknoglobals // it's okay to declare a replacer as a private global
+)
+
+// Unescape unescapes a json pointer reference token string to the original representation.
func Unescape(token string) string {
- step1 := strings.ReplaceAll(token, encRefTok1, decRefTok1)
- step2 := strings.ReplaceAll(step1, encRefTok0, decRefTok0)
- return step2
+ return encRefTokReplacer.Replace(token)
}
-// Escape escapes a pointer reference token string
+// Escape escapes a pointer reference token string.
+//
+// The JSONPointer specification defines "/" as a separator and "~" as an escape prefix.
+//
+// Keys containing such characters are escaped with the following rules:
+//
+// - "~" is escaped as "~0"
+// - "/" is escaped as "~1"
func Escape(token string) string {
- step1 := strings.ReplaceAll(token, decRefTok0, encRefTok0)
- step2 := strings.ReplaceAll(step1, decRefTok1, encRefTok1)
- return step2
+ return decRefTokReplacer.Replace(token)
}
diff --git a/vendor/github.com/go-openapi/jsonreference/.golangci.yml b/vendor/github.com/go-openapi/jsonreference/.golangci.yml
index 22f8d21c..7cea1af8 100644
--- a/vendor/github.com/go-openapi/jsonreference/.golangci.yml
+++ b/vendor/github.com/go-openapi/jsonreference/.golangci.yml
@@ -1,61 +1,75 @@
-linters-settings:
- govet:
- check-shadowing: true
- golint:
- min-confidence: 0
- gocyclo:
- min-complexity: 45
- maligned:
- suggest-new: true
- dupl:
- threshold: 200
- goconst:
- min-len: 2
- min-occurrences: 3
-
+version: "2"
linters:
- enable-all: true
+ default: all
disable:
- - maligned
- - unparam
- - lll
- - gochecknoinits
- - gochecknoglobals
- - funlen
- - godox
- - gocognit
- - whitespace
- - wsl
- - wrapcheck
- - testpackage
- - nlreturn
- - gomnd
- - exhaustivestruct
- - goerr113
- - errorlint
- - nestif
- - godot
- - gofumpt
- - paralleltest
- - tparallel
- - thelper
- - ifshort
- - exhaustruct
- - varnamelen
- - gci
+ - cyclop
- depguard
- errchkjson
- - inamedparam
- - nonamedreturns
- - musttag
- - ireturn
+ - errorlint
+ - exhaustruct
- forcetypeassert
- - cyclop
- # deprecated linters
- - deadcode
- - interfacer
- - scopelint
- - varcheck
- - structcheck
- - golint
- - nosnakecase
+ - funlen
+ - gochecknoglobals
+ - gochecknoinits
+ - gocognit
+ - godot
+ - godox
+ - gosmopolitan
+ - inamedparam
+ #- intrange # disabled while < go1.22
+ - ireturn
+ - lll
+ - musttag
+ - nestif
+ - nlreturn
+ - nonamedreturns
+ - noinlineerr
+ - paralleltest
+ - recvcheck
+ - testpackage
+ - thelper
+ - tparallel
+ - unparam
+ - varnamelen
+ - whitespace
+ - wrapcheck
+ - wsl
+ - wsl_v5
+ settings:
+ dupl:
+ threshold: 200
+ goconst:
+ min-len: 2
+ min-occurrences: 3
+ gocyclo:
+ min-complexity: 45
+ exclusions:
+ generated: lax
+ presets:
+ - comments
+ - common-false-positives
+ - legacy
+ - std-error-handling
+ paths:
+ - third_party$
+ - builtin$
+ - examples$
+formatters:
+ enable:
+ - gofmt
+ - goimports
+ exclusions:
+ generated: lax
+ paths:
+ - third_party$
+ - builtin$
+ - examples$
+issues:
+ # Maximum issues count per one linter.
+ # Set to 0 to disable.
+ # Default: 50
+ max-issues-per-linter: 0
+ # Maximum count of issues with the same text.
+ # Set to 0 to disable.
+ # Default: 3
+ max-same-issues: 0
diff --git a/vendor/github.com/go-openapi/jsonreference/NOTICE b/vendor/github.com/go-openapi/jsonreference/NOTICE
new file mode 100644
index 00000000..f9ad7e0f
--- /dev/null
+++ b/vendor/github.com/go-openapi/jsonreference/NOTICE
@@ -0,0 +1,36 @@
+Copyright 2015-2025 go-swagger maintainers
+
+// SPDX-FileCopyrightText: Copyright 2015-2025 go-swagger maintainers
+// SPDX-License-Identifier: Apache-2.0
+
+This software library, github.com/go-openapi/jsonpointer, includes software developed
+by the go-swagger and go-openapi maintainers ("go-swagger maintainers").
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this software except in compliance with the License.
+You may obtain a copy of the License at
+
+This software is copied from, derived from, and inspired by other original software products.
+It ships with copies of other software which license terms are recalled below.
+
+The original sofware was authored on 25-02-2013 by sigu-399 (https://github.com/sigu-399, sigu.399@gmail.com).
+
+github.com/sigh-399/jsonpointer
+===========================
+
+// SPDX-FileCopyrightText: Copyright 2013 sigu-399 ( https://github.com/sigu-399 )
+// SPDX-License-Identifier: Apache-2.0
+
+Copyright 2013 sigu-399 ( https://github.com/sigu-399 )
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
diff --git a/vendor/github.com/go-openapi/jsonreference/README.md b/vendor/github.com/go-openapi/jsonreference/README.md
index c7fc2049..2274a4b7 100644
--- a/vendor/github.com/go-openapi/jsonreference/README.md
+++ b/vendor/github.com/go-openapi/jsonreference/README.md
@@ -17,3 +17,10 @@ Feature complete. Stable API
* http://tools.ietf.org/html/draft-ietf-appsawg-json-pointer-07
* http://tools.ietf.org/html/draft-pbryan-zyp-json-ref-03
+
+## Licensing
+
+This library ships under the [SPDX-License-Identifier: Apache-2.0](./LICENSE).
+
+See the license [NOTICE](./NOTICE), which recalls the licensing terms of all the pieces of software
+on top of which it has been built.
diff --git a/vendor/github.com/go-openapi/jsonreference/internal/normalize_url.go b/vendor/github.com/go-openapi/jsonreference/internal/normalize_url.go
index f0610cf1..ca79391d 100644
--- a/vendor/github.com/go-openapi/jsonreference/internal/normalize_url.go
+++ b/vendor/github.com/go-openapi/jsonreference/internal/normalize_url.go
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright (c) 2015-2025 go-swagger maintainers
+// SPDX-License-Identifier: Apache-2.0
+
package internal
import (
diff --git a/vendor/github.com/go-openapi/jsonreference/reference.go b/vendor/github.com/go-openapi/jsonreference/reference.go
index cfdef03e..33d4798c 100644
--- a/vendor/github.com/go-openapi/jsonreference/reference.go
+++ b/vendor/github.com/go-openapi/jsonreference/reference.go
@@ -1,27 +1,5 @@
-// Copyright 2013 sigu-399 ( https://github.com/sigu-399 )
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-// author sigu-399
-// author-github https://github.com/sigu-399
-// author-mail sigu.399@gmail.com
-//
-// repository-name jsonreference
-// repository-desc An implementation of JSON Reference - Go language
-//
-// description Main and unique file.
-//
-// created 26-02-2013
+// SPDX-FileCopyrightText: Copyright (c) 2015-2025 go-swagger maintainers
+// SPDX-License-Identifier: Apache-2.0
package jsonreference
@@ -38,24 +16,7 @@ const (
fragmentRune = `#`
)
-// New creates a new reference for the given string
-func New(jsonReferenceString string) (Ref, error) {
-
- var r Ref
- err := r.parse(jsonReferenceString)
- return r, err
-
-}
-
-// MustCreateRef parses the ref string and panics when it's invalid.
-// Use the New method for a version that returns an error
-func MustCreateRef(ref string) Ref {
- r, err := New(ref)
- if err != nil {
- panic(err)
- }
- return r
-}
+var ErrChildURL = errors.New("child url is nil")
// Ref represents a json reference object
type Ref struct {
@@ -69,6 +30,24 @@ type Ref struct {
HasFullFilePath bool
}
+// New creates a new reference for the given string
+func New(jsonReferenceString string) (Ref, error) {
+ var r Ref
+ err := r.parse(jsonReferenceString)
+ return r, err
+}
+
+// MustCreateRef parses the ref string and panics when it's invalid.
+// Use the New method for a version that returns an error
+func MustCreateRef(ref string) Ref {
+ r, err := New(ref)
+ if err != nil {
+ panic(err)
+ }
+
+ return r
+}
+
// GetURL gets the URL for this reference
func (r *Ref) GetURL() *url.URL {
return r.referenceURL
@@ -81,7 +60,6 @@ func (r *Ref) GetPointer() *jsonpointer.Pointer {
// String returns the best version of the url for this reference
func (r *Ref) String() string {
-
if r.referenceURL != nil {
return r.referenceURL.String()
}
@@ -106,9 +84,27 @@ func (r *Ref) IsCanonical() bool {
return (r.HasFileScheme && r.HasFullFilePath) || (!r.HasFileScheme && r.HasFullURL)
}
+// Inherits creates a new reference from a parent and a child
+// If the child cannot inherit from the parent, an error is returned
+func (r *Ref) Inherits(child Ref) (*Ref, error) {
+ childURL := child.GetURL()
+ parentURL := r.GetURL()
+ if childURL == nil {
+ return nil, ErrChildURL
+ }
+ if parentURL == nil {
+ return &child, nil
+ }
+
+ ref, err := New(parentURL.ResolveReference(childURL).String())
+ if err != nil {
+ return nil, err
+ }
+ return &ref, nil
+}
+
// "Constructor", parses the given string JSON reference
func (r *Ref) parse(jsonReferenceString string) error {
-
parsed, err := url.Parse(jsonReferenceString)
if err != nil {
return err
@@ -137,22 +133,3 @@ func (r *Ref) parse(jsonReferenceString string) error {
return nil
}
-
-// Inherits creates a new reference from a parent and a child
-// If the child cannot inherit from the parent, an error is returned
-func (r *Ref) Inherits(child Ref) (*Ref, error) {
- childURL := child.GetURL()
- parentURL := r.GetURL()
- if childURL == nil {
- return nil, errors.New("child url is nil")
- }
- if parentURL == nil {
- return &child, nil
- }
-
- ref, err := New(parentURL.ResolveReference(childURL).String())
- if err != nil {
- return nil, err
- }
- return &ref, nil
-}
diff --git a/vendor/github.com/go-openapi/spec/.golangci.yml b/vendor/github.com/go-openapi/spec/.golangci.yml
index 22f8d21c..1ad5adf4 100644
--- a/vendor/github.com/go-openapi/spec/.golangci.yml
+++ b/vendor/github.com/go-openapi/spec/.golangci.yml
@@ -1,61 +1,75 @@
-linters-settings:
- govet:
- check-shadowing: true
- golint:
- min-confidence: 0
- gocyclo:
- min-complexity: 45
- maligned:
- suggest-new: true
- dupl:
- threshold: 200
- goconst:
- min-len: 2
- min-occurrences: 3
-
+version: "2"
linters:
- enable-all: true
+ default: all
disable:
- - maligned
- - unparam
- - lll
- - gochecknoinits
- - gochecknoglobals
- - funlen
- - godox
- - gocognit
- - whitespace
- - wsl
- - wrapcheck
- - testpackage
- - nlreturn
- - gomnd
- - exhaustivestruct
- - goerr113
- - errorlint
- - nestif
- - godot
- - gofumpt
- - paralleltest
- - tparallel
- - thelper
- - ifshort
- - exhaustruct
- - varnamelen
- - gci
+ - cyclop
- depguard
- errchkjson
- - inamedparam
- - nonamedreturns
- - musttag
- - ireturn
+ - errorlint
+ - exhaustruct
- forcetypeassert
- - cyclop
- # deprecated linters
- - deadcode
- - interfacer
- - scopelint
- - varcheck
- - structcheck
- - golint
- - nosnakecase
+ - funlen
+ - gochecknoglobals
+ - gochecknoinits
+ - gocognit
+ - godot
+ - godox
+ - gosmopolitan
+ - inamedparam
+ - intrange
+ - ireturn
+ - lll
+ - musttag
+ - nestif
+ - nlreturn
+ - nonamedreturns
+ - noinlineerr
+ - paralleltest
+ - recvcheck
+ - testpackage
+ - thelper
+ - tparallel
+ - unparam
+ - varnamelen
+ - whitespace
+ - wrapcheck
+ - wsl
+ - wsl_v5
+ settings:
+ dupl:
+ threshold: 200
+ goconst:
+ min-len: 2
+ min-occurrences: 3
+ gocyclo:
+ min-complexity: 45
+ exclusions:
+ generated: lax
+ presets:
+ - comments
+ - common-false-positives
+ - legacy
+ - std-error-handling
+ paths:
+ - third_party$
+ - builtin$
+ - examples$
+formatters:
+ enable:
+ - gofmt
+ - goimports
+ exclusions:
+ generated: lax
+ paths:
+ - third_party$
+ - builtin$
+ - examples$
+issues:
+ # Maximum issues count per one linter.
+ # Set to 0 to disable.
+ # Default: 50
+ max-issues-per-linter: 0
+ # Maximum count of issues with the same text.
+ # Set to 0 to disable.
+ # Default: 3
+ max-same-issues: 0
diff --git a/vendor/github.com/go-openapi/spec/README.md b/vendor/github.com/go-openapi/spec/README.md
index 7fd2810c..3203bd25 100644
--- a/vendor/github.com/go-openapi/spec/README.md
+++ b/vendor/github.com/go-openapi/spec/README.md
@@ -7,6 +7,10 @@
The object model for OpenAPI specification documents.
+## Licensing
+
+This library ships under the [SPDX-License-Identifier: Apache-2.0](./LICENSE).
+
### FAQ
* What does this do?
diff --git a/vendor/github.com/go-openapi/spec/cache.go b/vendor/github.com/go-openapi/spec/cache.go
index 122993b4..10fba77a 100644
--- a/vendor/github.com/go-openapi/spec/cache.go
+++ b/vendor/github.com/go-openapi/spec/cache.go
@@ -1,40 +1,28 @@
-// Copyright 2015 go-swagger maintainers
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
+// SPDX-FileCopyrightText: Copyright 2015-2025 go-swagger maintainers
+// SPDX-License-Identifier: Apache-2.0
package spec
import (
+ "maps"
"sync"
)
// ResolutionCache a cache for resolving urls
type ResolutionCache interface {
- Get(string) (interface{}, bool)
- Set(string, interface{})
+ Get(string) (any, bool)
+ Set(string, any)
}
type simpleCache struct {
lock sync.RWMutex
- store map[string]interface{}
+ store map[string]any
}
func (s *simpleCache) ShallowClone() ResolutionCache {
- store := make(map[string]interface{}, len(s.store))
+ store := make(map[string]any, len(s.store))
s.lock.RLock()
- for k, v := range s.store {
- store[k] = v
- }
+ maps.Copy(store, s.store)
s.lock.RUnlock()
return &simpleCache{
@@ -43,7 +31,7 @@ func (s *simpleCache) ShallowClone() ResolutionCache {
}
// Get retrieves a cached URI
-func (s *simpleCache) Get(uri string) (interface{}, bool) {
+func (s *simpleCache) Get(uri string) (any, bool) {
s.lock.RLock()
v, ok := s.store[uri]
@@ -52,7 +40,7 @@ func (s *simpleCache) Get(uri string) (interface{}, bool) {
}
// Set caches a URI
-func (s *simpleCache) Set(uri string, data interface{}) {
+func (s *simpleCache) Set(uri string, data any) {
s.lock.Lock()
s.store[uri] = data
s.lock.Unlock()
@@ -80,7 +68,7 @@ func initResolutionCache() {
}
func defaultResolutionCache() *simpleCache {
- return &simpleCache{store: map[string]interface{}{
+ return &simpleCache{store: map[string]any{
"http://swagger.io/v2/schema.json": MustLoadSwagger20Schema(),
"http://json-schema.org/draft-04/schema": MustLoadJSONSchemaDraft04(),
}}
diff --git a/vendor/github.com/go-openapi/spec/contact_info.go b/vendor/github.com/go-openapi/spec/contact_info.go
index 2f7bb219..fafe639b 100644
--- a/vendor/github.com/go-openapi/spec/contact_info.go
+++ b/vendor/github.com/go-openapi/spec/contact_info.go
@@ -1,23 +1,12 @@
-// Copyright 2015 go-swagger maintainers
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
+// SPDX-FileCopyrightText: Copyright 2015-2025 go-swagger maintainers
+// SPDX-License-Identifier: Apache-2.0
package spec
import (
"encoding/json"
- "github.com/go-openapi/swag"
+ "github.com/go-openapi/swag/jsonutils"
)
// ContactInfo contact information for the exposed API.
@@ -53,5 +42,5 @@ func (c ContactInfo) MarshalJSON() ([]byte, error) {
if err != nil {
return nil, err
}
- return swag.ConcatJSON(b1, b2), nil
+ return jsonutils.ConcatJSON(b1, b2), nil
}
diff --git a/vendor/github.com/go-openapi/spec/debug.go b/vendor/github.com/go-openapi/spec/debug.go
index fc889f6d..f4316c26 100644
--- a/vendor/github.com/go-openapi/spec/debug.go
+++ b/vendor/github.com/go-openapi/spec/debug.go
@@ -1,16 +1,5 @@
-// Copyright 2015 go-swagger maintainers
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
+// SPDX-FileCopyrightText: Copyright 2015-2025 go-swagger maintainers
+// SPDX-License-Identifier: Apache-2.0
package spec
@@ -40,7 +29,7 @@ func debugOptions() {
specLogger = log.New(os.Stdout, "spec:", log.LstdFlags)
}
-func debugLog(msg string, args ...interface{}) {
+func debugLog(msg string, args ...any) {
// A private, trivial trace logger, based on go-openapi/spec/expander.go:debugLog()
if Debug {
_, file1, pos1, _ := runtime.Caller(1)
diff --git a/vendor/github.com/go-openapi/spec/embed.go b/vendor/github.com/go-openapi/spec/embed.go
index 1f428475..0d0b6999 100644
--- a/vendor/github.com/go-openapi/spec/embed.go
+++ b/vendor/github.com/go-openapi/spec/embed.go
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2015-2025 go-swagger maintainers
+// SPDX-License-Identifier: Apache-2.0
+
package spec
import (
diff --git a/vendor/github.com/go-openapi/spec/errors.go b/vendor/github.com/go-openapi/spec/errors.go
index 6992c7ba..e39ab8bf 100644
--- a/vendor/github.com/go-openapi/spec/errors.go
+++ b/vendor/github.com/go-openapi/spec/errors.go
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2015-2025 go-swagger maintainers
+// SPDX-License-Identifier: Apache-2.0
+
package spec
import "errors"
@@ -16,4 +19,7 @@ var (
// ErrExpandUnsupportedType indicates that $ref expansion is attempted on some invalid type
ErrExpandUnsupportedType = errors.New("expand: unsupported type. Input should be of type *Parameter or *Response")
+
+ // ErrSpec is an error raised by the spec package
+ ErrSpec = errors.New("spec error")
)
diff --git a/vendor/github.com/go-openapi/spec/expander.go b/vendor/github.com/go-openapi/spec/expander.go
index b81a5699..cc4bd1cb 100644
--- a/vendor/github.com/go-openapi/spec/expander.go
+++ b/vendor/github.com/go-openapi/spec/expander.go
@@ -1,16 +1,5 @@
-// Copyright 2015 go-swagger maintainers
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
+// SPDX-FileCopyrightText: Copyright 2015-2025 go-swagger maintainers
+// SPDX-License-Identifier: Apache-2.0
package spec
@@ -19,6 +8,8 @@ import (
"fmt"
)
+const smallPrealloc = 10
+
// ExpandOptions provides options for the spec expander.
//
// RelativeBase is the path to the root document. This can be a remote URL or a path to a local file.
@@ -56,7 +47,7 @@ func ExpandSpec(spec *Swagger, options *ExpandOptions) error {
if !options.SkipSchemas {
for key, definition := range spec.Definitions {
- parentRefs := make([]string, 0, 10)
+ parentRefs := make([]string, 0, smallPrealloc)
parentRefs = append(parentRefs, "#/definitions/"+key)
def, err := expandSchema(definition, parentRefs, resolver, specBasePath)
@@ -102,7 +93,7 @@ const rootBase = ".root"
// baseForRoot loads in the cache the root document and produces a fake ".root" base path entry
// for further $ref resolution
-func baseForRoot(root interface{}, cache ResolutionCache) string {
+func baseForRoot(root any, cache ResolutionCache) string {
// cache the root document to resolve $ref's
normalizedBase := normalizeBase(rootBase)
@@ -114,7 +105,7 @@ func baseForRoot(root interface{}, cache ResolutionCache) string {
return normalizedBase
}
- root = map[string]interface{}{}
+ root = map[string]any{}
}
cache.Set(normalizedBase, root)
@@ -130,7 +121,7 @@ func baseForRoot(root interface{}, cache ResolutionCache) string {
// (use ExpandSchemaWithBasePath to resolve external references).
//
// Setting the cache is optional and this parameter may safely be left to nil.
-func ExpandSchema(schema *Schema, root interface{}, cache ResolutionCache) error {
+func ExpandSchema(schema *Schema, root any, cache ResolutionCache) error {
cache = cacheOrDefault(cache)
if root == nil {
root = schema
@@ -160,7 +151,7 @@ func ExpandSchemaWithBasePath(schema *Schema, cache ResolutionCache, opts *Expan
resolver := defaultSchemaLoader(nil, opts, cache, nil)
- parentRefs := make([]string, 0, 10)
+ parentRefs := make([]string, 0, smallPrealloc)
s, err := expandSchema(*schema, parentRefs, resolver, opts.RelativeBase)
if err != nil {
return err
@@ -386,7 +377,7 @@ func expandPathItem(pathItem *PathItem, resolver *schemaLoader, basePath string)
return nil
}
- parentRefs := make([]string, 0, 10)
+ parentRefs := make([]string, 0, smallPrealloc)
if err := resolver.deref(pathItem, parentRefs, basePath); resolver.shouldStopOnError(err) {
return err
}
@@ -461,7 +452,7 @@ func expandOperation(op *Operation, resolver *schemaLoader, basePath string) err
// (use ExpandResponse to resolve external references).
//
// Setting the cache is optional and this parameter may safely be left to nil.
-func ExpandResponseWithRoot(response *Response, root interface{}, cache ResolutionCache) error {
+func ExpandResponseWithRoot(response *Response, root any, cache ResolutionCache) error {
cache = cacheOrDefault(cache)
opts := &ExpandOptions{
RelativeBase: baseForRoot(root, cache),
@@ -487,7 +478,7 @@ func ExpandResponse(response *Response, basePath string) error {
//
// Notice that it is impossible to reference a json schema in a different document other than root
// (use ExpandParameter to resolve external references).
-func ExpandParameterWithRoot(parameter *Parameter, root interface{}, cache ResolutionCache) error {
+func ExpandParameterWithRoot(parameter *Parameter, root any, cache ResolutionCache) error {
cache = cacheOrDefault(cache)
opts := &ExpandOptions{
@@ -510,7 +501,7 @@ func ExpandParameter(parameter *Parameter, basePath string) error {
return expandParameterOrResponse(parameter, resolver, opts.RelativeBase)
}
-func getRefAndSchema(input interface{}) (*Ref, *Schema, error) {
+func getRefAndSchema(input any) (*Ref, *Schema, error) {
var (
ref *Ref
sch *Schema
@@ -536,7 +527,7 @@ func getRefAndSchema(input interface{}) (*Ref, *Schema, error) {
return ref, sch, nil
}
-func expandParameterOrResponse(input interface{}, resolver *schemaLoader, basePath string) error {
+func expandParameterOrResponse(input any, resolver *schemaLoader, basePath string) error {
ref, sch, err := getRefAndSchema(input)
if err != nil {
return err
@@ -546,7 +537,7 @@ func expandParameterOrResponse(input interface{}, resolver *schemaLoader, basePa
return nil
}
- parentRefs := make([]string, 0, 10)
+ parentRefs := make([]string, 0, smallPrealloc)
if ref != nil {
// dereference this $ref
if err = resolver.deref(input, parentRefs, basePath); resolver.shouldStopOnError(err) {
diff --git a/vendor/github.com/go-openapi/spec/external_docs.go b/vendor/github.com/go-openapi/spec/external_docs.go
index 88add91b..17b8efbf 100644
--- a/vendor/github.com/go-openapi/spec/external_docs.go
+++ b/vendor/github.com/go-openapi/spec/external_docs.go
@@ -1,16 +1,5 @@
-// Copyright 2015 go-swagger maintainers
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
+// SPDX-FileCopyrightText: Copyright 2015-2025 go-swagger maintainers
+// SPDX-License-Identifier: Apache-2.0
package spec
diff --git a/vendor/github.com/go-openapi/spec/header.go b/vendor/github.com/go-openapi/spec/header.go
index 9dfd17b1..ab251ef7 100644
--- a/vendor/github.com/go-openapi/spec/header.go
+++ b/vendor/github.com/go-openapi/spec/header.go
@@ -1,16 +1,5 @@
-// Copyright 2015 go-swagger maintainers
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
+// SPDX-FileCopyrightText: Copyright 2015-2025 go-swagger maintainers
+// SPDX-License-Identifier: Apache-2.0
package spec
@@ -19,7 +8,7 @@ import (
"strings"
"github.com/go-openapi/jsonpointer"
- "github.com/go-openapi/swag"
+ "github.com/go-openapi/swag/jsonutils"
)
const (
@@ -68,20 +57,20 @@ func (h *Header) CollectionOf(items *Items, format string) *Header {
}
// WithDefault sets the default value on this item
-func (h *Header) WithDefault(defaultValue interface{}) *Header {
+func (h *Header) WithDefault(defaultValue any) *Header {
h.Default = defaultValue
return h
}
// WithMaxLength sets a max length value
-func (h *Header) WithMaxLength(max int64) *Header {
- h.MaxLength = &max
+func (h *Header) WithMaxLength(maximum int64) *Header {
+ h.MaxLength = &maximum
return h
}
// WithMinLength sets a min length value
-func (h *Header) WithMinLength(min int64) *Header {
- h.MinLength = &min
+func (h *Header) WithMinLength(minimum int64) *Header {
+ h.MinLength = &minimum
return h
}
@@ -98,22 +87,22 @@ func (h *Header) WithMultipleOf(number float64) *Header {
}
// WithMaximum sets a maximum number value
-func (h *Header) WithMaximum(max float64, exclusive bool) *Header {
- h.Maximum = &max
+func (h *Header) WithMaximum(maximum float64, exclusive bool) *Header {
+ h.Maximum = &maximum
h.ExclusiveMaximum = exclusive
return h
}
// WithMinimum sets a minimum number value
-func (h *Header) WithMinimum(min float64, exclusive bool) *Header {
- h.Minimum = &min
+func (h *Header) WithMinimum(minimum float64, exclusive bool) *Header {
+ h.Minimum = &minimum
h.ExclusiveMinimum = exclusive
return h
}
// WithEnum sets a the enum values (replace)
-func (h *Header) WithEnum(values ...interface{}) *Header {
- h.Enum = append([]interface{}{}, values...)
+func (h *Header) WithEnum(values ...any) *Header {
+ h.Enum = append([]any{}, values...)
return h
}
@@ -161,7 +150,7 @@ func (h Header) MarshalJSON() ([]byte, error) {
if err != nil {
return nil, err
}
- return swag.ConcatJSON(b1, b2, b3), nil
+ return jsonutils.ConcatJSON(b1, b2, b3), nil
}
// UnmarshalJSON unmarshals this header from JSON
@@ -179,7 +168,7 @@ func (h *Header) UnmarshalJSON(data []byte) error {
}
// JSONLookup look up a value by the json property name
-func (h Header) JSONLookup(token string) (interface{}, error) {
+func (h Header) JSONLookup(token string) (any, error) {
if ex, ok := h.Extensions[token]; ok {
return &ex, nil
}
diff --git a/vendor/github.com/go-openapi/spec/info.go b/vendor/github.com/go-openapi/spec/info.go
index 582f0fd4..9401065b 100644
--- a/vendor/github.com/go-openapi/spec/info.go
+++ b/vendor/github.com/go-openapi/spec/info.go
@@ -1,16 +1,5 @@
-// Copyright 2015 go-swagger maintainers
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
+// SPDX-FileCopyrightText: Copyright 2015-2025 go-swagger maintainers
+// SPDX-License-Identifier: Apache-2.0
package spec
@@ -20,14 +9,14 @@ import (
"strings"
"github.com/go-openapi/jsonpointer"
- "github.com/go-openapi/swag"
+ "github.com/go-openapi/swag/jsonutils"
)
// Extensions vendor specific extensions
-type Extensions map[string]interface{}
+type Extensions map[string]any
// Add adds a value to these extensions
-func (e Extensions) Add(key string, value interface{}) {
+func (e Extensions) Add(key string, value any) {
realKey := strings.ToLower(key)
e[realKey] = value
}
@@ -71,7 +60,7 @@ func (e Extensions) GetBool(key string) (bool, bool) {
// GetStringSlice gets a string value from the extensions
func (e Extensions) GetStringSlice(key string) ([]string, bool) {
if v, ok := e[strings.ToLower(key)]; ok {
- arr, isSlice := v.([]interface{})
+ arr, isSlice := v.([]any)
if !isSlice {
return nil, false
}
@@ -94,19 +83,19 @@ type VendorExtensible struct {
}
// AddExtension adds an extension to this extensible object
-func (v *VendorExtensible) AddExtension(key string, value interface{}) {
+func (v *VendorExtensible) AddExtension(key string, value any) {
if value == nil {
return
}
if v.Extensions == nil {
- v.Extensions = make(map[string]interface{})
+ v.Extensions = make(map[string]any)
}
v.Extensions.Add(key, value)
}
// MarshalJSON marshals the extensions to json
func (v VendorExtensible) MarshalJSON() ([]byte, error) {
- toser := make(map[string]interface{})
+ toser := make(map[string]any)
for k, v := range v.Extensions {
lk := strings.ToLower(k)
if strings.HasPrefix(lk, "x-") {
@@ -118,7 +107,7 @@ func (v VendorExtensible) MarshalJSON() ([]byte, error) {
// UnmarshalJSON for this extensible object
func (v *VendorExtensible) UnmarshalJSON(data []byte) error {
- var d map[string]interface{}
+ var d map[string]any
if err := json.Unmarshal(data, &d); err != nil {
return err
}
@@ -126,7 +115,7 @@ func (v *VendorExtensible) UnmarshalJSON(data []byte) error {
lk := strings.ToLower(k)
if strings.HasPrefix(lk, "x-") {
if v.Extensions == nil {
- v.Extensions = map[string]interface{}{}
+ v.Extensions = map[string]any{}
}
v.Extensions[k] = vv
}
@@ -154,7 +143,7 @@ type Info struct {
}
// JSONLookup look up a value by the json property name
-func (i Info) JSONLookup(token string) (interface{}, error) {
+func (i Info) JSONLookup(token string) (any, error) {
if ex, ok := i.Extensions[token]; ok {
return &ex, nil
}
@@ -172,7 +161,7 @@ func (i Info) MarshalJSON() ([]byte, error) {
if err != nil {
return nil, err
}
- return swag.ConcatJSON(b1, b2), nil
+ return jsonutils.ConcatJSON(b1, b2), nil
}
// UnmarshalJSON marshal this from JSON
diff --git a/vendor/github.com/go-openapi/spec/items.go b/vendor/github.com/go-openapi/spec/items.go
index e2afb213..d30ca356 100644
--- a/vendor/github.com/go-openapi/spec/items.go
+++ b/vendor/github.com/go-openapi/spec/items.go
@@ -1,16 +1,5 @@
-// Copyright 2015 go-swagger maintainers
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
+// SPDX-FileCopyrightText: Copyright 2015-2025 go-swagger maintainers
+// SPDX-License-Identifier: Apache-2.0
package spec
@@ -19,7 +8,7 @@ import (
"strings"
"github.com/go-openapi/jsonpointer"
- "github.com/go-openapi/swag"
+ "github.com/go-openapi/swag/jsonutils"
)
const (
@@ -28,13 +17,13 @@ const (
// SimpleSchema describe swagger simple schemas for parameters and headers
type SimpleSchema struct {
- Type string `json:"type,omitempty"`
- Nullable bool `json:"nullable,omitempty"`
- Format string `json:"format,omitempty"`
- Items *Items `json:"items,omitempty"`
- CollectionFormat string `json:"collectionFormat,omitempty"`
- Default interface{} `json:"default,omitempty"`
- Example interface{} `json:"example,omitempty"`
+ Type string `json:"type,omitempty"`
+ Nullable bool `json:"nullable,omitempty"`
+ Format string `json:"format,omitempty"`
+ Items *Items `json:"items,omitempty"`
+ CollectionFormat string `json:"collectionFormat,omitempty"`
+ Default any `json:"default,omitempty"`
+ Example any `json:"example,omitempty"`
}
// TypeName return the type (or format) of a simple schema
@@ -91,20 +80,20 @@ func (i *Items) CollectionOf(items *Items, format string) *Items {
}
// WithDefault sets the default value on this item
-func (i *Items) WithDefault(defaultValue interface{}) *Items {
+func (i *Items) WithDefault(defaultValue any) *Items {
i.Default = defaultValue
return i
}
// WithMaxLength sets a max length value
-func (i *Items) WithMaxLength(max int64) *Items {
- i.MaxLength = &max
+func (i *Items) WithMaxLength(maximum int64) *Items {
+ i.MaxLength = &maximum
return i
}
// WithMinLength sets a min length value
-func (i *Items) WithMinLength(min int64) *Items {
- i.MinLength = &min
+func (i *Items) WithMinLength(minimum int64) *Items {
+ i.MinLength = &minimum
return i
}
@@ -121,22 +110,22 @@ func (i *Items) WithMultipleOf(number float64) *Items {
}
// WithMaximum sets a maximum number value
-func (i *Items) WithMaximum(max float64, exclusive bool) *Items {
- i.Maximum = &max
+func (i *Items) WithMaximum(maximum float64, exclusive bool) *Items {
+ i.Maximum = &maximum
i.ExclusiveMaximum = exclusive
return i
}
// WithMinimum sets a minimum number value
-func (i *Items) WithMinimum(min float64, exclusive bool) *Items {
- i.Minimum = &min
+func (i *Items) WithMinimum(minimum float64, exclusive bool) *Items {
+ i.Minimum = &minimum
i.ExclusiveMinimum = exclusive
return i
}
// WithEnum sets a the enum values (replace)
-func (i *Items) WithEnum(values ...interface{}) *Items {
- i.Enum = append([]interface{}{}, values...)
+func (i *Items) WithEnum(values ...any) *Items {
+ i.Enum = append([]any{}, values...)
return i
}
@@ -213,11 +202,11 @@ func (i Items) MarshalJSON() ([]byte, error) {
if err != nil {
return nil, err
}
- return swag.ConcatJSON(b4, b3, b1, b2), nil
+ return jsonutils.ConcatJSON(b4, b3, b1, b2), nil
}
// JSONLookup look up a value by the json property name
-func (i Items) JSONLookup(token string) (interface{}, error) {
+func (i Items) JSONLookup(token string) (any, error) {
if token == jsonRef {
return &i.Ref, nil
}
diff --git a/vendor/github.com/go-openapi/spec/license.go b/vendor/github.com/go-openapi/spec/license.go
index b42f8036..286b237e 100644
--- a/vendor/github.com/go-openapi/spec/license.go
+++ b/vendor/github.com/go-openapi/spec/license.go
@@ -1,23 +1,12 @@
-// Copyright 2015 go-swagger maintainers
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
+// SPDX-FileCopyrightText: Copyright 2015-2025 go-swagger maintainers
+// SPDX-License-Identifier: Apache-2.0
package spec
import (
"encoding/json"
- "github.com/go-openapi/swag"
+ "github.com/go-openapi/swag/jsonutils"
)
// License information for the exposed API.
@@ -52,5 +41,5 @@ func (l License) MarshalJSON() ([]byte, error) {
if err != nil {
return nil, err
}
- return swag.ConcatJSON(b1, b2), nil
+ return jsonutils.ConcatJSON(b1, b2), nil
}
diff --git a/vendor/github.com/go-openapi/spec/normalizer.go b/vendor/github.com/go-openapi/spec/normalizer.go
index e8b60099..c3ea810a 100644
--- a/vendor/github.com/go-openapi/spec/normalizer.go
+++ b/vendor/github.com/go-openapi/spec/normalizer.go
@@ -1,16 +1,5 @@
-// Copyright 2015 go-swagger maintainers
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
+// SPDX-FileCopyrightText: Copyright 2015-2025 go-swagger maintainers
+// SPDX-License-Identifier: Apache-2.0
package spec
@@ -129,8 +118,8 @@ func rebase(ref *Ref, v *url.URL, notEqual bool) (Ref, bool) {
newBase.Fragment = u.Fragment
- if strings.HasPrefix(u.Path, docPath) {
- newBase.Path = strings.TrimPrefix(u.Path, docPath)
+ if after, ok := strings.CutPrefix(u.Path, docPath); ok {
+ newBase.Path = after
} else {
newBase.Path = strings.TrimPrefix(u.Path, v.Path)
}
diff --git a/vendor/github.com/go-openapi/spec/normalizer_nonwindows.go b/vendor/github.com/go-openapi/spec/normalizer_nonwindows.go
index f19f1a8f..0d556323 100644
--- a/vendor/github.com/go-openapi/spec/normalizer_nonwindows.go
+++ b/vendor/github.com/go-openapi/spec/normalizer_nonwindows.go
@@ -1,19 +1,7 @@
//go:build !windows
-// +build !windows
-// Copyright 2015 go-swagger maintainers
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
+// SPDX-FileCopyrightText: Copyright 2015-2025 go-swagger maintainers
+// SPDX-License-Identifier: Apache-2.0
package spec
diff --git a/vendor/github.com/go-openapi/spec/normalizer_windows.go b/vendor/github.com/go-openapi/spec/normalizer_windows.go
index a66c532d..61515c9a 100644
--- a/vendor/github.com/go-openapi/spec/normalizer_windows.go
+++ b/vendor/github.com/go-openapi/spec/normalizer_windows.go
@@ -1,18 +1,7 @@
// -build windows
-// Copyright 2015 go-swagger maintainers
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
+// SPDX-FileCopyrightText: Copyright 2015-2025 go-swagger maintainers
+// SPDX-License-Identifier: Apache-2.0
package spec
diff --git a/vendor/github.com/go-openapi/spec/operation.go b/vendor/github.com/go-openapi/spec/operation.go
index a69cca88..bbf8c757 100644
--- a/vendor/github.com/go-openapi/spec/operation.go
+++ b/vendor/github.com/go-openapi/spec/operation.go
@@ -1,16 +1,5 @@
-// Copyright 2015 go-swagger maintainers
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
+// SPDX-FileCopyrightText: Copyright 2015-2025 go-swagger maintainers
+// SPDX-License-Identifier: Apache-2.0
package spec
@@ -21,12 +10,12 @@ import (
"sort"
"github.com/go-openapi/jsonpointer"
- "github.com/go-openapi/swag"
+ "github.com/go-openapi/swag/jsonutils"
)
func init() {
- gob.Register(map[string]interface{}{})
- gob.Register([]interface{}{})
+ gob.Register(map[string]any{})
+ gob.Register([]any{})
}
// OperationProps describes an operation
@@ -58,19 +47,22 @@ func (op OperationProps) MarshalJSON() ([]byte, error) {
type Alias OperationProps
if op.Security == nil {
return json.Marshal(&struct {
- Security []map[string][]string `json:"security,omitempty"`
*Alias
+
+ Security []map[string][]string `json:"security,omitempty"`
}{
- Security: op.Security,
Alias: (*Alias)(&op),
+ Security: op.Security,
})
}
+
return json.Marshal(&struct {
- Security []map[string][]string `json:"security"`
*Alias
+
+ Security []map[string][]string `json:"security"`
}{
- Security: op.Security,
Alias: (*Alias)(&op),
+ Security: op.Security,
})
}
@@ -82,6 +74,14 @@ type Operation struct {
OperationProps
}
+// NewOperation creates a new operation instance.
+// It expects an ID as parameter but not passing an ID is also valid.
+func NewOperation(id string) *Operation {
+ op := new(Operation)
+ op.ID = id
+ return op
+}
+
// SuccessResponse gets a success response model
func (o *Operation) SuccessResponse() (*Response, int, bool) {
if o.Responses == nil {
@@ -104,7 +104,7 @@ func (o *Operation) SuccessResponse() (*Response, int, bool) {
}
// JSONLookup look up a value by the json property name
-func (o Operation) JSONLookup(token string) (interface{}, error) {
+func (o Operation) JSONLookup(token string) (any, error) {
if ex, ok := o.Extensions[token]; ok {
return &ex, nil
}
@@ -130,18 +130,10 @@ func (o Operation) MarshalJSON() ([]byte, error) {
if err != nil {
return nil, err
}
- concated := swag.ConcatJSON(b1, b2)
+ concated := jsonutils.ConcatJSON(b1, b2)
return concated, nil
}
-// NewOperation creates a new operation instance.
-// It expects an ID as parameter but not passing an ID is also valid.
-func NewOperation(id string) *Operation {
- op := new(Operation)
- op.ID = id
- return op
-}
-
// WithID sets the ID property on this operation, allows for chaining.
func (o *Operation) WithID(id string) *Operation {
o.ID = id
diff --git a/vendor/github.com/go-openapi/spec/parameter.go b/vendor/github.com/go-openapi/spec/parameter.go
index bd4f1cdb..b94b7682 100644
--- a/vendor/github.com/go-openapi/spec/parameter.go
+++ b/vendor/github.com/go-openapi/spec/parameter.go
@@ -1,16 +1,5 @@
-// Copyright 2015 go-swagger maintainers
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
+// SPDX-FileCopyrightText: Copyright 2015-2025 go-swagger maintainers
+// SPDX-License-Identifier: Apache-2.0
package spec
@@ -19,7 +8,7 @@ import (
"strings"
"github.com/go-openapi/jsonpointer"
- "github.com/go-openapi/swag"
+ "github.com/go-openapi/swag/jsonutils"
)
// QueryParam creates a query parameter
@@ -116,7 +105,7 @@ type Parameter struct {
}
// JSONLookup look up a value by the json property name
-func (p Parameter) JSONLookup(token string) (interface{}, error) {
+func (p Parameter) JSONLookup(token string) (any, error) {
if ex, ok := p.Extensions[token]; ok {
return &ex, nil
}
@@ -176,7 +165,7 @@ func (p *Parameter) CollectionOf(items *Items, format string) *Parameter {
}
// WithDefault sets the default value on this parameter
-func (p *Parameter) WithDefault(defaultValue interface{}) *Parameter {
+func (p *Parameter) WithDefault(defaultValue any) *Parameter {
p.AsOptional() // with default implies optional
p.Default = defaultValue
return p
@@ -210,14 +199,14 @@ func (p *Parameter) AsRequired() *Parameter {
}
// WithMaxLength sets a max length value
-func (p *Parameter) WithMaxLength(max int64) *Parameter {
- p.MaxLength = &max
+func (p *Parameter) WithMaxLength(maximum int64) *Parameter {
+ p.MaxLength = &maximum
return p
}
// WithMinLength sets a min length value
-func (p *Parameter) WithMinLength(min int64) *Parameter {
- p.MinLength = &min
+func (p *Parameter) WithMinLength(minimum int64) *Parameter {
+ p.MinLength = &minimum
return p
}
@@ -234,22 +223,22 @@ func (p *Parameter) WithMultipleOf(number float64) *Parameter {
}
// WithMaximum sets a maximum number value
-func (p *Parameter) WithMaximum(max float64, exclusive bool) *Parameter {
- p.Maximum = &max
+func (p *Parameter) WithMaximum(maximum float64, exclusive bool) *Parameter {
+ p.Maximum = &maximum
p.ExclusiveMaximum = exclusive
return p
}
// WithMinimum sets a minimum number value
-func (p *Parameter) WithMinimum(min float64, exclusive bool) *Parameter {
- p.Minimum = &min
+func (p *Parameter) WithMinimum(minimum float64, exclusive bool) *Parameter {
+ p.Minimum = &minimum
p.ExclusiveMinimum = exclusive
return p
}
// WithEnum sets a the enum values (replace)
-func (p *Parameter) WithEnum(values ...interface{}) *Parameter {
- p.Enum = append([]interface{}{}, values...)
+func (p *Parameter) WithEnum(values ...any) *Parameter {
+ p.Enum = append([]any{}, values...)
return p
}
@@ -322,5 +311,5 @@ func (p Parameter) MarshalJSON() ([]byte, error) {
if err != nil {
return nil, err
}
- return swag.ConcatJSON(b3, b1, b2, b4, b5), nil
+ return jsonutils.ConcatJSON(b3, b1, b2, b4, b5), nil
}
diff --git a/vendor/github.com/go-openapi/spec/path_item.go b/vendor/github.com/go-openapi/spec/path_item.go
index 68fc8e90..c692b89e 100644
--- a/vendor/github.com/go-openapi/spec/path_item.go
+++ b/vendor/github.com/go-openapi/spec/path_item.go
@@ -1,16 +1,5 @@
-// Copyright 2015 go-swagger maintainers
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
+// SPDX-FileCopyrightText: Copyright 2015-2025 go-swagger maintainers
+// SPDX-License-Identifier: Apache-2.0
package spec
@@ -18,7 +7,7 @@ import (
"encoding/json"
"github.com/go-openapi/jsonpointer"
- "github.com/go-openapi/swag"
+ "github.com/go-openapi/swag/jsonutils"
)
// PathItemProps the path item specific properties
@@ -46,7 +35,7 @@ type PathItem struct {
}
// JSONLookup look up a value by the json property name
-func (p PathItem) JSONLookup(token string) (interface{}, error) {
+func (p PathItem) JSONLookup(token string) (any, error) {
if ex, ok := p.Extensions[token]; ok {
return &ex, nil
}
@@ -82,6 +71,6 @@ func (p PathItem) MarshalJSON() ([]byte, error) {
if err != nil {
return nil, err
}
- concated := swag.ConcatJSON(b3, b4, b5)
+ concated := jsonutils.ConcatJSON(b3, b4, b5)
return concated, nil
}
diff --git a/vendor/github.com/go-openapi/spec/paths.go b/vendor/github.com/go-openapi/spec/paths.go
index 9dc82a29..b9e42184 100644
--- a/vendor/github.com/go-openapi/spec/paths.go
+++ b/vendor/github.com/go-openapi/spec/paths.go
@@ -1,16 +1,5 @@
-// Copyright 2015 go-swagger maintainers
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
+// SPDX-FileCopyrightText: Copyright 2015-2025 go-swagger maintainers
+// SPDX-License-Identifier: Apache-2.0
package spec
@@ -19,7 +8,7 @@ import (
"fmt"
"strings"
- "github.com/go-openapi/swag"
+ "github.com/go-openapi/swag/jsonutils"
)
// Paths holds the relative paths to the individual endpoints.
@@ -30,18 +19,19 @@ import (
// For more information: http://goo.gl/8us55a#pathsObject
type Paths struct {
VendorExtensible
+
Paths map[string]PathItem `json:"-"` // custom serializer to flatten this, each entry must start with "/"
}
// JSONLookup look up a value by the json property name
-func (p Paths) JSONLookup(token string) (interface{}, error) {
+func (p Paths) JSONLookup(token string) (any, error) {
if pi, ok := p.Paths[token]; ok {
return &pi, nil
}
if ex, ok := p.Extensions[token]; ok {
return &ex, nil
}
- return nil, fmt.Errorf("object has no field %q", token)
+ return nil, fmt.Errorf("object has no field %q: %w", token, ErrSpec)
}
// UnmarshalJSON hydrates this items instance with the data from JSON
@@ -53,9 +43,9 @@ func (p *Paths) UnmarshalJSON(data []byte) error {
for k, v := range res {
if strings.HasPrefix(strings.ToLower(k), "x-") {
if p.Extensions == nil {
- p.Extensions = make(map[string]interface{})
+ p.Extensions = make(map[string]any)
}
- var d interface{}
+ var d any
if err := json.Unmarshal(v, &d); err != nil {
return err
}
@@ -92,6 +82,6 @@ func (p Paths) MarshalJSON() ([]byte, error) {
if err != nil {
return nil, err
}
- concated := swag.ConcatJSON(b1, b2)
+ concated := jsonutils.ConcatJSON(b1, b2)
return concated, nil
}
diff --git a/vendor/github.com/go-openapi/spec/properties.go b/vendor/github.com/go-openapi/spec/properties.go
index 91d2435f..4142308d 100644
--- a/vendor/github.com/go-openapi/spec/properties.go
+++ b/vendor/github.com/go-openapi/spec/properties.go
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2015-2025 go-swagger maintainers
+// SPDX-License-Identifier: Apache-2.0
+
package spec
import (
@@ -9,8 +12,9 @@ import (
// OrderSchemaItem holds a named schema (e.g. from a property of an object)
type OrderSchemaItem struct {
- Name string
Schema
+
+ Name string
}
// OrderSchemaItems is a sortable slice of named schemas.
diff --git a/vendor/github.com/go-openapi/spec/ref.go b/vendor/github.com/go-openapi/spec/ref.go
index b0ef9bd9..c9279262 100644
--- a/vendor/github.com/go-openapi/spec/ref.go
+++ b/vendor/github.com/go-openapi/spec/ref.go
@@ -1,16 +1,5 @@
-// Copyright 2015 go-swagger maintainers
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
+// SPDX-FileCopyrightText: Copyright 2015-2025 go-swagger maintainers
+// SPDX-License-Identifier: Apache-2.0
package spec
@@ -45,6 +34,23 @@ type Ref struct {
jsonreference.Ref
}
+// NewRef creates a new instance of a ref object
+// returns an error when the reference uri is an invalid uri
+func NewRef(refURI string) (Ref, error) {
+ ref, err := jsonreference.New(refURI)
+ if err != nil {
+ return Ref{}, err
+ }
+
+ return Ref{Ref: ref}, nil
+}
+
+// MustCreateRef creates a ref object but panics when refURI is invalid.
+// Use the NewRef method for a version that returns an error.
+func MustCreateRef(refURI string) Ref {
+ return Ref{Ref: jsonreference.MustCreateRef(refURI)}
+}
+
// RemoteURI gets the remote uri part of the ref
func (r *Ref) RemoteURI() string {
if r.String() == "" {
@@ -75,10 +81,11 @@ func (r *Ref) IsValidURI(basepaths ...string) bool {
}
defer rr.Body.Close()
- return rr.StatusCode/100 == 2
+ // true if the response is >= 200 and < 300
+ return rr.StatusCode/100 == 2 //nolint:mnd
}
- if !(r.HasFileScheme || r.HasFullFilePath || r.HasURLPathOnly) {
+ if !r.HasFileScheme && !r.HasFullFilePath && !r.HasURLPathOnly {
return false
}
@@ -114,22 +121,6 @@ func (r *Ref) Inherits(child Ref) (*Ref, error) {
return &Ref{Ref: *ref}, nil
}
-// NewRef creates a new instance of a ref object
-// returns an error when the reference uri is an invalid uri
-func NewRef(refURI string) (Ref, error) {
- ref, err := jsonreference.New(refURI)
- if err != nil {
- return Ref{}, err
- }
- return Ref{Ref: ref}, nil
-}
-
-// MustCreateRef creates a ref object but panics when refURI is invalid.
-// Use the NewRef method for a version that returns an error.
-func MustCreateRef(refURI string) Ref {
- return Ref{Ref: jsonreference.MustCreateRef(refURI)}
-}
-
// MarshalJSON marshals this ref into a JSON object
func (r Ref) MarshalJSON() ([]byte, error) {
str := r.String()
@@ -139,13 +130,13 @@ func (r Ref) MarshalJSON() ([]byte, error) {
}
return []byte("{}"), nil
}
- v := map[string]interface{}{"$ref": str}
+ v := map[string]any{"$ref": str}
return json.Marshal(v)
}
// UnmarshalJSON unmarshals this ref from a JSON object
func (r *Ref) UnmarshalJSON(d []byte) error {
- var v map[string]interface{}
+ var v map[string]any
if err := json.Unmarshal(d, &v); err != nil {
return err
}
@@ -174,7 +165,7 @@ func (r *Ref) GobDecode(b []byte) error {
return json.Unmarshal(raw, r)
}
-func (r *Ref) fromMap(v map[string]interface{}) error {
+func (r *Ref) fromMap(v map[string]any) error {
if v == nil {
return nil
}
diff --git a/vendor/github.com/go-openapi/spec/resolver.go b/vendor/github.com/go-openapi/spec/resolver.go
index 47d1ee13..b82c1821 100644
--- a/vendor/github.com/go-openapi/spec/resolver.go
+++ b/vendor/github.com/go-openapi/spec/resolver.go
@@ -1,12 +1,15 @@
+// SPDX-FileCopyrightText: Copyright 2015-2025 go-swagger maintainers
+// SPDX-License-Identifier: Apache-2.0
+
package spec
import (
"fmt"
- "github.com/go-openapi/swag"
+ "github.com/go-openapi/swag/jsonutils"
)
-func resolveAnyWithBase(root interface{}, ref *Ref, result interface{}, options *ExpandOptions) error {
+func resolveAnyWithBase(root any, ref *Ref, result any, options *ExpandOptions) error {
options = optionsOrDefault(options)
resolver := defaultSchemaLoader(root, options, nil, nil)
@@ -18,7 +21,7 @@ func resolveAnyWithBase(root interface{}, ref *Ref, result interface{}, options
}
// ResolveRefWithBase resolves a reference against a context root with preservation of base path
-func ResolveRefWithBase(root interface{}, ref *Ref, options *ExpandOptions) (*Schema, error) {
+func ResolveRefWithBase(root any, ref *Ref, options *ExpandOptions) (*Schema, error) {
result := new(Schema)
if err := resolveAnyWithBase(root, ref, result, options); err != nil {
@@ -32,7 +35,7 @@ func ResolveRefWithBase(root interface{}, ref *Ref, options *ExpandOptions) (*Sc
// ref is guaranteed to be in root (no need to go to external files)
//
// ResolveRef is ONLY called from the code generation module
-func ResolveRef(root interface{}, ref *Ref) (*Schema, error) {
+func ResolveRef(root any, ref *Ref) (*Schema, error) {
res, _, err := ref.GetPointer().Get(root)
if err != nil {
return nil, err
@@ -43,9 +46,9 @@ func ResolveRef(root interface{}, ref *Ref) (*Schema, error) {
return &sch, nil
case *Schema:
return sch, nil
- case map[string]interface{}:
+ case map[string]any:
newSch := new(Schema)
- if err = swag.DynamicJSONToStruct(sch, newSch); err != nil {
+ if err = jsonutils.FromDynamicJSON(sch, newSch); err != nil {
return nil, err
}
return newSch, nil
@@ -55,7 +58,7 @@ func ResolveRef(root interface{}, ref *Ref) (*Schema, error) {
}
// ResolveParameterWithBase resolves a parameter reference against a context root and base path
-func ResolveParameterWithBase(root interface{}, ref Ref, options *ExpandOptions) (*Parameter, error) {
+func ResolveParameterWithBase(root any, ref Ref, options *ExpandOptions) (*Parameter, error) {
result := new(Parameter)
if err := resolveAnyWithBase(root, &ref, result, options); err != nil {
@@ -66,12 +69,12 @@ func ResolveParameterWithBase(root interface{}, ref Ref, options *ExpandOptions)
}
// ResolveParameter resolves a parameter reference against a context root
-func ResolveParameter(root interface{}, ref Ref) (*Parameter, error) {
+func ResolveParameter(root any, ref Ref) (*Parameter, error) {
return ResolveParameterWithBase(root, ref, nil)
}
// ResolveResponseWithBase resolves response a reference against a context root and base path
-func ResolveResponseWithBase(root interface{}, ref Ref, options *ExpandOptions) (*Response, error) {
+func ResolveResponseWithBase(root any, ref Ref, options *ExpandOptions) (*Response, error) {
result := new(Response)
err := resolveAnyWithBase(root, &ref, result, options)
@@ -83,12 +86,12 @@ func ResolveResponseWithBase(root interface{}, ref Ref, options *ExpandOptions)
}
// ResolveResponse resolves response a reference against a context root
-func ResolveResponse(root interface{}, ref Ref) (*Response, error) {
+func ResolveResponse(root any, ref Ref) (*Response, error) {
return ResolveResponseWithBase(root, ref, nil)
}
// ResolvePathItemWithBase resolves response a path item against a context root and base path
-func ResolvePathItemWithBase(root interface{}, ref Ref, options *ExpandOptions) (*PathItem, error) {
+func ResolvePathItemWithBase(root any, ref Ref, options *ExpandOptions) (*PathItem, error) {
result := new(PathItem)
if err := resolveAnyWithBase(root, &ref, result, options); err != nil {
@@ -101,7 +104,7 @@ func ResolvePathItemWithBase(root interface{}, ref Ref, options *ExpandOptions)
// ResolvePathItem resolves response a path item against a context root and base path
//
// Deprecated: use ResolvePathItemWithBase instead
-func ResolvePathItem(root interface{}, ref Ref, options *ExpandOptions) (*PathItem, error) {
+func ResolvePathItem(root any, ref Ref, options *ExpandOptions) (*PathItem, error) {
return ResolvePathItemWithBase(root, ref, options)
}
@@ -109,7 +112,7 @@ func ResolvePathItem(root interface{}, ref Ref, options *ExpandOptions) (*PathIt
//
// NOTE: stricly speaking, this construct is not supported by Swagger 2.0.
// Similarly, $ref are forbidden in response headers.
-func ResolveItemsWithBase(root interface{}, ref Ref, options *ExpandOptions) (*Items, error) {
+func ResolveItemsWithBase(root any, ref Ref, options *ExpandOptions) (*Items, error) {
result := new(Items)
if err := resolveAnyWithBase(root, &ref, result, options); err != nil {
@@ -122,6 +125,6 @@ func ResolveItemsWithBase(root interface{}, ref Ref, options *ExpandOptions) (*I
// ResolveItems resolves parameter items reference against a context root and base path.
//
// Deprecated: use ResolveItemsWithBase instead
-func ResolveItems(root interface{}, ref Ref, options *ExpandOptions) (*Items, error) {
+func ResolveItems(root any, ref Ref, options *ExpandOptions) (*Items, error) {
return ResolveItemsWithBase(root, ref, options)
}
diff --git a/vendor/github.com/go-openapi/spec/response.go b/vendor/github.com/go-openapi/spec/response.go
index 0340b60d..e5a7e5c4 100644
--- a/vendor/github.com/go-openapi/spec/response.go
+++ b/vendor/github.com/go-openapi/spec/response.go
@@ -1,16 +1,5 @@
-// Copyright 2015 go-swagger maintainers
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
+// SPDX-FileCopyrightText: Copyright 2015-2025 go-swagger maintainers
+// SPDX-License-Identifier: Apache-2.0
package spec
@@ -18,15 +7,15 @@ import (
"encoding/json"
"github.com/go-openapi/jsonpointer"
- "github.com/go-openapi/swag"
+ "github.com/go-openapi/swag/jsonutils"
)
// ResponseProps properties specific to a response
type ResponseProps struct {
- Description string `json:"description"`
- Schema *Schema `json:"schema,omitempty"`
- Headers map[string]Header `json:"headers,omitempty"`
- Examples map[string]interface{} `json:"examples,omitempty"`
+ Description string `json:"description"`
+ Schema *Schema `json:"schema,omitempty"`
+ Headers map[string]Header `json:"headers,omitempty"`
+ Examples map[string]any `json:"examples,omitempty"`
}
// Response describes a single response from an API Operation.
@@ -38,8 +27,20 @@ type Response struct {
VendorExtensible
}
+// NewResponse creates a new response instance
+func NewResponse() *Response {
+ return new(Response)
+}
+
+// ResponseRef creates a response as a json reference
+func ResponseRef(url string) *Response {
+ resp := NewResponse()
+ resp.Ref = MustCreateRef(url)
+ return resp
+}
+
// JSONLookup look up a value by the json property name
-func (r Response) JSONLookup(token string) (interface{}, error) {
+func (r Response) JSONLookup(token string) (any, error) {
if ex, ok := r.Extensions[token]; ok {
return &ex, nil
}
@@ -74,14 +75,14 @@ func (r Response) MarshalJSON() ([]byte, error) {
} else {
// when there is $ref inside the schema, description should be omitempty-ied
b1, err = json.Marshal(struct {
- Description string `json:"description,omitempty"`
- Schema *Schema `json:"schema,omitempty"`
- Headers map[string]Header `json:"headers,omitempty"`
- Examples map[string]interface{} `json:"examples,omitempty"`
+ Description string `json:"description,omitempty"`
+ Schema *Schema `json:"schema,omitempty"`
+ Headers map[string]Header `json:"headers,omitempty"`
+ Examples map[string]any `json:"examples,omitempty"`
}{
- Description: r.ResponseProps.Description,
- Schema: r.ResponseProps.Schema,
- Examples: r.ResponseProps.Examples,
+ Description: r.Description,
+ Schema: r.Schema,
+ Examples: r.Examples,
})
}
if err != nil {
@@ -96,19 +97,7 @@ func (r Response) MarshalJSON() ([]byte, error) {
if err != nil {
return nil, err
}
- return swag.ConcatJSON(b1, b2, b3), nil
-}
-
-// NewResponse creates a new response instance
-func NewResponse() *Response {
- return new(Response)
-}
-
-// ResponseRef creates a response as a json reference
-func ResponseRef(url string) *Response {
- resp := NewResponse()
- resp.Ref = MustCreateRef(url)
- return resp
+ return jsonutils.ConcatJSON(b1, b2, b3), nil
}
// WithDescription sets the description on this response, allows for chaining
@@ -143,9 +132,9 @@ func (r *Response) RemoveHeader(name string) *Response {
}
// AddExample adds an example to this response
-func (r *Response) AddExample(mediaType string, example interface{}) *Response {
+func (r *Response) AddExample(mediaType string, example any) *Response {
if r.Examples == nil {
- r.Examples = make(map[string]interface{})
+ r.Examples = make(map[string]any)
}
r.Examples[mediaType] = example
return r
diff --git a/vendor/github.com/go-openapi/spec/responses.go b/vendor/github.com/go-openapi/spec/responses.go
index 16c3076f..733a1315 100644
--- a/vendor/github.com/go-openapi/spec/responses.go
+++ b/vendor/github.com/go-openapi/spec/responses.go
@@ -1,16 +1,5 @@
-// Copyright 2015 go-swagger maintainers
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
+// SPDX-FileCopyrightText: Copyright 2015-2025 go-swagger maintainers
+// SPDX-License-Identifier: Apache-2.0
package spec
@@ -21,7 +10,7 @@ import (
"strconv"
"strings"
- "github.com/go-openapi/swag"
+ "github.com/go-openapi/swag/jsonutils"
)
// Responses is a container for the expected responses of an operation.
@@ -43,7 +32,7 @@ type Responses struct {
}
// JSONLookup implements an interface to customize json pointer lookup
-func (r Responses) JSONLookup(token string) (interface{}, error) {
+func (r Responses) JSONLookup(token string) (any, error) {
if token == "default" {
return r.Default, nil
}
@@ -55,7 +44,7 @@ func (r Responses) JSONLookup(token string) (interface{}, error) {
return scr, nil
}
}
- return nil, fmt.Errorf("object has no field %q", token)
+ return nil, fmt.Errorf("object has no field %q: %w", token, ErrSpec)
}
// UnmarshalJSON hydrates this items instance with the data from JSON
@@ -83,7 +72,7 @@ func (r Responses) MarshalJSON() ([]byte, error) {
if err != nil {
return nil, err
}
- concated := swag.ConcatJSON(b1, b2)
+ concated := jsonutils.ConcatJSON(b1, b2)
return concated, nil
}
diff --git a/vendor/github.com/go-openapi/spec/schema.go b/vendor/github.com/go-openapi/spec/schema.go
index 4e9be857..6623728a 100644
--- a/vendor/github.com/go-openapi/spec/schema.go
+++ b/vendor/github.com/go-openapi/spec/schema.go
@@ -1,16 +1,5 @@
-// Copyright 2015 go-swagger maintainers
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
+// SPDX-FileCopyrightText: Copyright 2015-2025 go-swagger maintainers
+// SPDX-License-Identifier: Apache-2.0
package spec
@@ -20,7 +9,8 @@ import (
"strings"
"github.com/go-openapi/jsonpointer"
- "github.com/go-openapi/swag"
+ "github.com/go-openapi/swag/jsonname"
+ "github.com/go-openapi/swag/jsonutils"
)
// BooleanProperty creates a boolean property
@@ -125,20 +115,20 @@ func (r SchemaURL) MarshalJSON() ([]byte, error) {
if r == "" {
return []byte("{}"), nil
}
- v := map[string]interface{}{"$schema": string(r)}
+ v := map[string]any{"$schema": string(r)}
return json.Marshal(v)
}
// UnmarshalJSON unmarshal this from JSON
func (r *SchemaURL) UnmarshalJSON(data []byte) error {
- var v map[string]interface{}
+ var v map[string]any
if err := json.Unmarshal(data, &v); err != nil {
return err
}
return r.fromMap(v)
}
-func (r *SchemaURL) fromMap(v map[string]interface{}) error {
+func (r *SchemaURL) fromMap(v map[string]any) error {
if v == nil {
return nil
}
@@ -165,7 +155,7 @@ type SchemaProps struct {
Nullable bool `json:"nullable,omitempty"`
Format string `json:"format,omitempty"`
Title string `json:"title,omitempty"`
- Default interface{} `json:"default,omitempty"`
+ Default any `json:"default,omitempty"`
Maximum *float64 `json:"maximum,omitempty"`
ExclusiveMaximum bool `json:"exclusiveMaximum,omitempty"`
Minimum *float64 `json:"minimum,omitempty"`
@@ -177,7 +167,7 @@ type SchemaProps struct {
MinItems *int64 `json:"minItems,omitempty"`
UniqueItems bool `json:"uniqueItems,omitempty"`
MultipleOf *float64 `json:"multipleOf,omitempty"`
- Enum []interface{} `json:"enum,omitempty"`
+ Enum []any `json:"enum,omitempty"`
MaxProperties *int64 `json:"maxProperties,omitempty"`
MinProperties *int64 `json:"minProperties,omitempty"`
Required []string `json:"required,omitempty"`
@@ -200,7 +190,7 @@ type SwaggerSchemaProps struct {
ReadOnly bool `json:"readOnly,omitempty"`
XML *XMLObject `json:"xml,omitempty"`
ExternalDocs *ExternalDocumentation `json:"externalDocs,omitempty"`
- Example interface{} `json:"example,omitempty"`
+ Example any `json:"example,omitempty"`
}
// Schema the schema object allows the definition of input and output data types.
@@ -214,11 +204,12 @@ type Schema struct {
VendorExtensible
SchemaProps
SwaggerSchemaProps
- ExtraProps map[string]interface{} `json:"-"`
+
+ ExtraProps map[string]any `json:"-"`
}
// JSONLookup implements an interface to customize json pointer lookup
-func (s Schema) JSONLookup(token string) (interface{}, error) {
+func (s Schema) JSONLookup(token string) (any, error) {
if ex, ok := s.Extensions[token]; ok {
return &ex, nil
}
@@ -275,14 +266,14 @@ func (s *Schema) WithAllOf(schemas ...Schema) *Schema {
}
// WithMaxProperties sets the max number of properties an object can have
-func (s *Schema) WithMaxProperties(max int64) *Schema {
- s.MaxProperties = &max
+func (s *Schema) WithMaxProperties(maximum int64) *Schema {
+ s.MaxProperties = &maximum
return s
}
// WithMinProperties sets the min number of properties an object must have
-func (s *Schema) WithMinProperties(min int64) *Schema {
- s.MinProperties = &min
+func (s *Schema) WithMinProperties(minimum int64) *Schema {
+ s.MinProperties = &minimum
return s
}
@@ -316,7 +307,7 @@ func (s *Schema) CollectionOf(items Schema) *Schema {
}
// WithDefault sets the default value on this parameter
-func (s *Schema) WithDefault(defaultValue interface{}) *Schema {
+func (s *Schema) WithDefault(defaultValue any) *Schema {
s.Default = defaultValue
return s
}
@@ -334,14 +325,14 @@ func (s *Schema) AddRequired(items ...string) *Schema {
}
// WithMaxLength sets a max length value
-func (s *Schema) WithMaxLength(max int64) *Schema {
- s.MaxLength = &max
+func (s *Schema) WithMaxLength(maximum int64) *Schema {
+ s.MaxLength = &maximum
return s
}
// WithMinLength sets a min length value
-func (s *Schema) WithMinLength(min int64) *Schema {
- s.MinLength = &min
+func (s *Schema) WithMinLength(minimum int64) *Schema {
+ s.MinLength = &minimum
return s
}
@@ -358,22 +349,22 @@ func (s *Schema) WithMultipleOf(number float64) *Schema {
}
// WithMaximum sets a maximum number value
-func (s *Schema) WithMaximum(max float64, exclusive bool) *Schema {
- s.Maximum = &max
+func (s *Schema) WithMaximum(maximum float64, exclusive bool) *Schema {
+ s.Maximum = &maximum
s.ExclusiveMaximum = exclusive
return s
}
// WithMinimum sets a minimum number value
-func (s *Schema) WithMinimum(min float64, exclusive bool) *Schema {
- s.Minimum = &min
+func (s *Schema) WithMinimum(minimum float64, exclusive bool) *Schema {
+ s.Minimum = &minimum
s.ExclusiveMinimum = exclusive
return s
}
// WithEnum sets a the enum values (replace)
-func (s *Schema) WithEnum(values ...interface{}) *Schema {
- s.Enum = append([]interface{}{}, values...)
+func (s *Schema) WithEnum(values ...any) *Schema {
+ s.Enum = append([]any{}, values...)
return s
}
@@ -426,7 +417,7 @@ func (s *Schema) AsWritable() *Schema {
}
// WithExample sets the example for this schema
-func (s *Schema) WithExample(example interface{}) *Schema {
+func (s *Schema) WithExample(example any) *Schema {
s.Example = example
return s
}
@@ -566,33 +557,33 @@ func (s Schema) Validations() SchemaValidations {
func (s Schema) MarshalJSON() ([]byte, error) {
b1, err := json.Marshal(s.SchemaProps)
if err != nil {
- return nil, fmt.Errorf("schema props %v", err)
+ return nil, fmt.Errorf("schema props %v: %w", err, ErrSpec)
}
b2, err := json.Marshal(s.VendorExtensible)
if err != nil {
- return nil, fmt.Errorf("vendor props %v", err)
+ return nil, fmt.Errorf("vendor props %v: %w", err, ErrSpec)
}
b3, err := s.Ref.MarshalJSON()
if err != nil {
- return nil, fmt.Errorf("ref prop %v", err)
+ return nil, fmt.Errorf("ref prop %v: %w", err, ErrSpec)
}
b4, err := s.Schema.MarshalJSON()
if err != nil {
- return nil, fmt.Errorf("schema prop %v", err)
+ return nil, fmt.Errorf("schema prop %v: %w", err, ErrSpec)
}
b5, err := json.Marshal(s.SwaggerSchemaProps)
if err != nil {
- return nil, fmt.Errorf("common validations %v", err)
+ return nil, fmt.Errorf("common validations %v: %w", err, ErrSpec)
}
var b6 []byte
if s.ExtraProps != nil {
jj, err := json.Marshal(s.ExtraProps)
if err != nil {
- return nil, fmt.Errorf("extra props %v", err)
+ return nil, fmt.Errorf("extra props %v: %w", err, ErrSpec)
}
b6 = jj
}
- return swag.ConcatJSON(b1, b2, b3, b4, b5, b6), nil
+ return jsonutils.ConcatJSON(b1, b2, b3, b4, b5, b6), nil
}
// UnmarshalJSON marshal this from JSON
@@ -610,7 +601,7 @@ func (s *Schema) UnmarshalJSON(data []byte) error {
SwaggerSchemaProps: props.SwaggerSchemaProps,
}
- var d map[string]interface{}
+ var d map[string]any
if err := json.Unmarshal(data, &d); err != nil {
return err
}
@@ -620,7 +611,7 @@ func (s *Schema) UnmarshalJSON(data []byte) error {
delete(d, "$ref")
delete(d, "$schema")
- for _, pn := range swag.DefaultJSONNameProvider.GetJSONNames(s) {
+ for _, pn := range jsonname.DefaultJSONNameProvider.GetJSONNames(s) {
delete(d, pn)
}
@@ -628,13 +619,13 @@ func (s *Schema) UnmarshalJSON(data []byte) error {
lk := strings.ToLower(k)
if strings.HasPrefix(lk, "x-") {
if sch.Extensions == nil {
- sch.Extensions = map[string]interface{}{}
+ sch.Extensions = map[string]any{}
}
sch.Extensions[k] = vv
continue
}
if sch.ExtraProps == nil {
- sch.ExtraProps = map[string]interface{}{}
+ sch.ExtraProps = map[string]any{}
}
sch.ExtraProps[k] = vv
}
diff --git a/vendor/github.com/go-openapi/spec/schema_loader.go b/vendor/github.com/go-openapi/spec/schema_loader.go
index 0059b99a..8d4a9853 100644
--- a/vendor/github.com/go-openapi/spec/schema_loader.go
+++ b/vendor/github.com/go-openapi/spec/schema_loader.go
@@ -1,16 +1,5 @@
-// Copyright 2015 go-swagger maintainers
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
+// SPDX-FileCopyrightText: Copyright 2015-2025 go-swagger maintainers
+// SPDX-License-Identifier: Apache-2.0
package spec
@@ -22,7 +11,9 @@ import (
"reflect"
"strings"
- "github.com/go-openapi/swag"
+ "github.com/go-openapi/swag/jsonutils"
+ "github.com/go-openapi/swag/loading"
+ "github.com/go-openapi/swag/stringutils"
)
// PathLoader is a function to use when loading remote refs.
@@ -34,7 +25,7 @@ import (
// this value with its own default (a loader to retrieve YAML documents as
// well as JSON ones).
var PathLoader = func(pth string) (json.RawMessage, error) {
- data, err := swag.LoadFromFileOrHTTP(pth)
+ data, err := loading.LoadFromFileOrHTTP(pth)
if err != nil {
return nil, err
}
@@ -73,12 +64,23 @@ func newResolverContext(options *ExpandOptions) *resolverContext {
}
type schemaLoader struct {
- root interface{}
+ root any
options *ExpandOptions
cache ResolutionCache
context *resolverContext
}
+// Resolve resolves a reference against basePath and stores the result in target.
+//
+// Resolve is not in charge of following references: it only resolves ref by following its URL.
+//
+// If the schema the ref is referring to holds nested refs, Resolve doesn't resolve them.
+//
+// If basePath is an empty string, ref is resolved against the root schema stored in the schemaLoader struct
+func (r *schemaLoader) Resolve(ref *Ref, target any, basePath string) error {
+ return r.resolveRef(ref, target, basePath)
+}
+
func (r *schemaLoader) transitiveResolver(basePath string, ref Ref) *schemaLoader {
if ref.IsRoot() || ref.HasFragmentOnly {
return r
@@ -113,7 +115,7 @@ func (r *schemaLoader) updateBasePath(transitive *schemaLoader, basePath string)
return basePath
}
-func (r *schemaLoader) resolveRef(ref *Ref, target interface{}, basePath string) error {
+func (r *schemaLoader) resolveRef(ref *Ref, target any, basePath string) error {
tgt := reflect.ValueOf(target)
if tgt.Kind() != reflect.Ptr {
return ErrResolveRefNeedsAPointer
@@ -124,8 +126,8 @@ func (r *schemaLoader) resolveRef(ref *Ref, target interface{}, basePath string)
}
var (
- res interface{}
- data interface{}
+ res any
+ data any
err error
)
@@ -155,10 +157,10 @@ func (r *schemaLoader) resolveRef(ref *Ref, target interface{}, basePath string)
return err
}
}
- return swag.DynamicJSONToStruct(res, target)
+ return jsonutils.FromDynamicJSON(res, target)
}
-func (r *schemaLoader) load(refURL *url.URL) (interface{}, url.URL, bool, error) {
+func (r *schemaLoader) load(refURL *url.URL) (any, url.URL, bool, error) {
debugLog("loading schema from url: %s", refURL)
toFetch := *refURL
toFetch.Fragment = ""
@@ -178,7 +180,7 @@ func (r *schemaLoader) load(refURL *url.URL) (interface{}, url.URL, bool, error)
return nil, url.URL{}, false, err
}
- var doc interface{}
+ var doc any
if err := json.Unmarshal(b, &doc); err != nil {
return nil, url.URL{}, false, err
}
@@ -197,25 +199,14 @@ func (r *schemaLoader) isCircular(ref *Ref, basePath string, parentRefs ...strin
foundCycle = true
return
}
- foundCycle = swag.ContainsStrings(parentRefs, normalizedRef) // normalized windows url's are lower cased
+ foundCycle = stringutils.ContainsStrings(parentRefs, normalizedRef) // normalized windows url's are lower cased
if foundCycle {
r.context.circulars[normalizedRef] = true
}
return
}
-// Resolve resolves a reference against basePath and stores the result in target.
-//
-// Resolve is not in charge of following references: it only resolves ref by following its URL.
-//
-// If the schema the ref is referring to holds nested refs, Resolve doesn't resolve them.
-//
-// If basePath is an empty string, ref is resolved against the root schema stored in the schemaLoader struct
-func (r *schemaLoader) Resolve(ref *Ref, target interface{}, basePath string) error {
- return r.resolveRef(ref, target, basePath)
-}
-
-func (r *schemaLoader) deref(input interface{}, parentRefs []string, basePath string) error {
+func (r *schemaLoader) deref(input any, parentRefs []string, basePath string) error {
var ref *Ref
switch refable := input.(type) {
case *Schema:
@@ -267,7 +258,7 @@ func (r *schemaLoader) shouldStopOnError(err error) bool {
return false
}
-func (r *schemaLoader) setSchemaID(target interface{}, id, basePath string) (string, string) {
+func (r *schemaLoader) setSchemaID(target any, id, basePath string) (string, string) {
debugLog("schema has ID: %s", id)
// handling the case when id is a folder
@@ -299,7 +290,7 @@ func (r *schemaLoader) setSchemaID(target interface{}, id, basePath string) (str
}
func defaultSchemaLoader(
- root interface{},
+ root any,
expandOptions *ExpandOptions,
cache ResolutionCache,
context *resolverContext) *schemaLoader {
diff --git a/vendor/github.com/go-openapi/spec/security_scheme.go b/vendor/github.com/go-openapi/spec/security_scheme.go
index 9d0bdae9..46a4a7e2 100644
--- a/vendor/github.com/go-openapi/spec/security_scheme.go
+++ b/vendor/github.com/go-openapi/spec/security_scheme.go
@@ -1,16 +1,5 @@
-// Copyright 2015 go-swagger maintainers
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
+// SPDX-FileCopyrightText: Copyright 2015-2025 go-swagger maintainers
+// SPDX-License-Identifier: Apache-2.0
package spec
@@ -18,7 +7,7 @@ import (
"encoding/json"
"github.com/go-openapi/jsonpointer"
- "github.com/go-openapi/swag"
+ "github.com/go-openapi/swag/jsonutils"
)
const (
@@ -109,7 +98,7 @@ type SecurityScheme struct {
}
// JSONLookup implements an interface to customize json pointer lookup
-func (s SecurityScheme) JSONLookup(token string) (interface{}, error) {
+func (s SecurityScheme) JSONLookup(token string) (any, error) {
if ex, ok := s.Extensions[token]; ok {
return &ex, nil
}
@@ -158,7 +147,7 @@ func (s SecurityScheme) MarshalJSON() ([]byte, error) {
if err != nil {
return nil, err
}
- return swag.ConcatJSON(b1, b2), nil
+ return jsonutils.ConcatJSON(b1, b2), nil
}
// UnmarshalJSON marshal this from JSON
diff --git a/vendor/github.com/go-openapi/spec/spec.go b/vendor/github.com/go-openapi/spec/spec.go
index 876aa127..05c3fc77 100644
--- a/vendor/github.com/go-openapi/spec/spec.go
+++ b/vendor/github.com/go-openapi/spec/spec.go
@@ -1,16 +1,5 @@
-// Copyright 2015 go-swagger maintainers
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
+// SPDX-FileCopyrightText: Copyright 2015-2025 go-swagger maintainers
+// SPDX-License-Identifier: Apache-2.0
package spec
diff --git a/vendor/github.com/go-openapi/spec/swagger.go b/vendor/github.com/go-openapi/spec/swagger.go
index 1590fd17..f7cd0f60 100644
--- a/vendor/github.com/go-openapi/spec/swagger.go
+++ b/vendor/github.com/go-openapi/spec/swagger.go
@@ -1,16 +1,5 @@
-// Copyright 2015 go-swagger maintainers
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
+// SPDX-FileCopyrightText: Copyright 2015-2025 go-swagger maintainers
+// SPDX-License-Identifier: Apache-2.0
package spec
@@ -19,10 +8,11 @@ import (
"encoding/gob"
"encoding/json"
"fmt"
+ "slices"
"strconv"
"github.com/go-openapi/jsonpointer"
- "github.com/go-openapi/swag"
+ "github.com/go-openapi/swag/jsonutils"
)
// Swagger this is the root document object for the API specification.
@@ -36,7 +26,7 @@ type Swagger struct {
}
// JSONLookup look up a value by the json property name
-func (s Swagger) JSONLookup(token string) (interface{}, error) {
+func (s Swagger) JSONLookup(token string) (any, error) {
if ex, ok := s.Extensions[token]; ok {
return &ex, nil
}
@@ -54,7 +44,7 @@ func (s Swagger) MarshalJSON() ([]byte, error) {
if err != nil {
return nil, err
}
- return swag.ConcatJSON(b1, b2), nil
+ return jsonutils.ConcatJSON(b1, b2), nil
}
// UnmarshalJSON unmarshals a swagger spec from json
@@ -227,7 +217,7 @@ type SchemaOrBool struct {
}
// JSONLookup implements an interface to customize json pointer lookup
-func (s SchemaOrBool) JSONLookup(token string) (interface{}, error) {
+func (s SchemaOrBool) JSONLookup(token string) (any, error) {
if token == "allows" {
return s.Allows, nil
}
@@ -274,7 +264,7 @@ type SchemaOrStringArray struct {
}
// JSONLookup implements an interface to customize json pointer lookup
-func (s SchemaOrStringArray) JSONLookup(token string) (interface{}, error) {
+func (s SchemaOrStringArray) JSONLookup(token string) (any, error) {
r, _, err := jsonpointer.GetForToken(s.Schema, token)
return r, err
}
@@ -333,16 +323,11 @@ type StringOrArray []string
// Contains returns true when the value is contained in the slice
func (s StringOrArray) Contains(value string) bool {
- for _, str := range s {
- if str == value {
- return true
- }
- }
- return false
+ return slices.Contains(s, value)
}
// JSONLookup implements an interface to customize json pointer lookup
-func (s SchemaOrArray) JSONLookup(token string) (interface{}, error) {
+func (s SchemaOrArray) JSONLookup(token string) (any, error) {
if _, err := strconv.Atoi(token); err == nil {
r, _, err := jsonpointer.GetForToken(s.Schemas, token)
return r, err
@@ -367,7 +352,7 @@ func (s *StringOrArray) UnmarshalJSON(data []byte) error {
return nil
}
- var single interface{}
+ var single any
if err := json.Unmarshal(data, &single); err != nil {
return err
}
@@ -379,7 +364,7 @@ func (s *StringOrArray) UnmarshalJSON(data []byte) error {
*s = StringOrArray([]string{v})
return nil
default:
- return fmt.Errorf("only string or array is allowed, not %T", single)
+ return fmt.Errorf("only string or array is allowed, not %T: %w", single, ErrSpec)
}
}
diff --git a/vendor/github.com/go-openapi/spec/tag.go b/vendor/github.com/go-openapi/spec/tag.go
index faa3d3de..ae98fd98 100644
--- a/vendor/github.com/go-openapi/spec/tag.go
+++ b/vendor/github.com/go-openapi/spec/tag.go
@@ -1,16 +1,5 @@
-// Copyright 2015 go-swagger maintainers
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
+// SPDX-FileCopyrightText: Copyright 2015-2025 go-swagger maintainers
+// SPDX-License-Identifier: Apache-2.0
package spec
@@ -18,7 +7,7 @@ import (
"encoding/json"
"github.com/go-openapi/jsonpointer"
- "github.com/go-openapi/swag"
+ "github.com/go-openapi/swag/jsonutils"
)
// TagProps describe a tag entry in the top level tags section of a swagger spec
@@ -28,11 +17,6 @@ type TagProps struct {
ExternalDocs *ExternalDocumentation `json:"externalDocs,omitempty"`
}
-// NewTag creates a new tag
-func NewTag(name, description string, externalDocs *ExternalDocumentation) Tag {
- return Tag{TagProps: TagProps{Description: description, Name: name, ExternalDocs: externalDocs}}
-}
-
// Tag allows adding meta data to a single tag that is used by the
// [Operation Object](http://goo.gl/8us55a#operationObject).
// It is not mandatory to have a Tag Object per tag used there.
@@ -43,8 +27,13 @@ type Tag struct {
TagProps
}
+// NewTag creates a new tag
+func NewTag(name, description string, externalDocs *ExternalDocumentation) Tag {
+ return Tag{TagProps: TagProps{Description: description, Name: name, ExternalDocs: externalDocs}}
+}
+
// JSONLookup implements an interface to customize json pointer lookup
-func (t Tag) JSONLookup(token string) (interface{}, error) {
+func (t Tag) JSONLookup(token string) (any, error) {
if ex, ok := t.Extensions[token]; ok {
return &ex, nil
}
@@ -63,7 +52,7 @@ func (t Tag) MarshalJSON() ([]byte, error) {
if err != nil {
return nil, err
}
- return swag.ConcatJSON(b1, b2), nil
+ return jsonutils.ConcatJSON(b1, b2), nil
}
// UnmarshalJSON marshal this from JSON
diff --git a/vendor/github.com/go-openapi/spec/url_go19.go b/vendor/github.com/go-openapi/spec/url_go19.go
index 5bdfe40b..8d0c81ac 100644
--- a/vendor/github.com/go-openapi/spec/url_go19.go
+++ b/vendor/github.com/go-openapi/spec/url_go19.go
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2015-2025 go-swagger maintainers
+// SPDX-License-Identifier: Apache-2.0
+
package spec
import "net/url"
diff --git a/vendor/github.com/go-openapi/spec/validations.go b/vendor/github.com/go-openapi/spec/validations.go
index 6360a8ea..4f70e301 100644
--- a/vendor/github.com/go-openapi/spec/validations.go
+++ b/vendor/github.com/go-openapi/spec/validations.go
@@ -1,19 +1,22 @@
+// SPDX-FileCopyrightText: Copyright 2015-2025 go-swagger maintainers
+// SPDX-License-Identifier: Apache-2.0
+
package spec
// CommonValidations describe common JSON-schema validations
type CommonValidations struct {
- Maximum *float64 `json:"maximum,omitempty"`
- ExclusiveMaximum bool `json:"exclusiveMaximum,omitempty"`
- Minimum *float64 `json:"minimum,omitempty"`
- ExclusiveMinimum bool `json:"exclusiveMinimum,omitempty"`
- MaxLength *int64 `json:"maxLength,omitempty"`
- MinLength *int64 `json:"minLength,omitempty"`
- Pattern string `json:"pattern,omitempty"`
- MaxItems *int64 `json:"maxItems,omitempty"`
- MinItems *int64 `json:"minItems,omitempty"`
- UniqueItems bool `json:"uniqueItems,omitempty"`
- MultipleOf *float64 `json:"multipleOf,omitempty"`
- Enum []interface{} `json:"enum,omitempty"`
+ Maximum *float64 `json:"maximum,omitempty"`
+ ExclusiveMaximum bool `json:"exclusiveMaximum,omitempty"`
+ Minimum *float64 `json:"minimum,omitempty"`
+ ExclusiveMinimum bool `json:"exclusiveMinimum,omitempty"`
+ MaxLength *int64 `json:"maxLength,omitempty"`
+ MinLength *int64 `json:"minLength,omitempty"`
+ Pattern string `json:"pattern,omitempty"`
+ MaxItems *int64 `json:"maxItems,omitempty"`
+ MinItems *int64 `json:"minItems,omitempty"`
+ UniqueItems bool `json:"uniqueItems,omitempty"`
+ MultipleOf *float64 `json:"multipleOf,omitempty"`
+ Enum []any `json:"enum,omitempty"`
}
// SetValidations defines all validations for a simple schema.
@@ -37,12 +40,12 @@ func (v *CommonValidations) SetValidations(val SchemaValidations) {
type clearedValidation struct {
Validation string
- Value interface{}
+ Value any
}
type clearedValidations []clearedValidation
-func (c clearedValidations) apply(cbs []func(string, interface{})) {
+func (c clearedValidations) apply(cbs []func(string, any)) {
for _, cb := range cbs {
for _, cleared := range c {
cb(cleared.Validation, cleared.Value)
@@ -53,8 +56,9 @@ func (c clearedValidations) apply(cbs []func(string, interface{})) {
// ClearNumberValidations clears all number validations.
//
// Some callbacks may be set by the caller to capture changed values.
-func (v *CommonValidations) ClearNumberValidations(cbs ...func(string, interface{})) {
- done := make(clearedValidations, 0, 5)
+func (v *CommonValidations) ClearNumberValidations(cbs ...func(string, any)) {
+ const maxNumberValidations = 5
+ done := make(clearedValidations, 0, maxNumberValidations)
defer func() {
done.apply(cbs)
}()
@@ -84,8 +88,9 @@ func (v *CommonValidations) ClearNumberValidations(cbs ...func(string, interface
// ClearStringValidations clears all string validations.
//
// Some callbacks may be set by the caller to capture changed values.
-func (v *CommonValidations) ClearStringValidations(cbs ...func(string, interface{})) {
- done := make(clearedValidations, 0, 3)
+func (v *CommonValidations) ClearStringValidations(cbs ...func(string, any)) {
+ const maxStringValidations = 3
+ done := make(clearedValidations, 0, maxStringValidations)
defer func() {
done.apply(cbs)
}()
@@ -107,8 +112,9 @@ func (v *CommonValidations) ClearStringValidations(cbs ...func(string, interface
// ClearArrayValidations clears all array validations.
//
// Some callbacks may be set by the caller to capture changed values.
-func (v *CommonValidations) ClearArrayValidations(cbs ...func(string, interface{})) {
- done := make(clearedValidations, 0, 3)
+func (v *CommonValidations) ClearArrayValidations(cbs ...func(string, any)) {
+ const maxArrayValidations = 3
+ done := make(clearedValidations, 0, maxArrayValidations)
defer func() {
done.apply(cbs)
}()
@@ -194,8 +200,9 @@ func (v SchemaValidations) Validations() SchemaValidations {
// ClearObjectValidations returns a clone of the validations with all object validations cleared.
//
// Some callbacks may be set by the caller to capture changed values.
-func (v *SchemaValidations) ClearObjectValidations(cbs ...func(string, interface{})) {
- done := make(clearedValidations, 0, 3)
+func (v *SchemaValidations) ClearObjectValidations(cbs ...func(string, any)) {
+ const maxObjectValidations = 3
+ done := make(clearedValidations, 0, maxObjectValidations)
defer func() {
done.apply(cbs)
}()
diff --git a/vendor/github.com/go-openapi/spec/xml_object.go b/vendor/github.com/go-openapi/spec/xml_object.go
index 945a4670..bf2f8f18 100644
--- a/vendor/github.com/go-openapi/spec/xml_object.go
+++ b/vendor/github.com/go-openapi/spec/xml_object.go
@@ -1,16 +1,5 @@
-// Copyright 2015 go-swagger maintainers
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
+// SPDX-FileCopyrightText: Copyright 2015-2025 go-swagger maintainers
+// SPDX-License-Identifier: Apache-2.0
package spec
diff --git a/vendor/github.com/go-openapi/swag/.editorconfig b/vendor/github.com/go-openapi/swag/.editorconfig
deleted file mode 100644
index 3152da69..00000000
--- a/vendor/github.com/go-openapi/swag/.editorconfig
+++ /dev/null
@@ -1,26 +0,0 @@
-# top-most EditorConfig file
-root = true
-
-# Unix-style newlines with a newline ending every file
-[*]
-end_of_line = lf
-insert_final_newline = true
-indent_style = space
-indent_size = 2
-trim_trailing_whitespace = true
-
-# Set default charset
-[*.{js,py,go,scala,rb,java,html,css,less,sass,md}]
-charset = utf-8
-
-# Tab indentation (no size specified)
-[*.go]
-indent_style = tab
-
-[*.md]
-trim_trailing_whitespace = false
-
-# Matches the exact files either package.json or .travis.yml
-[{package.json,.travis.yml}]
-indent_style = space
-indent_size = 2
diff --git a/vendor/github.com/go-openapi/swag/.gitattributes b/vendor/github.com/go-openapi/swag/.gitattributes
deleted file mode 100644
index 49ad5276..00000000
--- a/vendor/github.com/go-openapi/swag/.gitattributes
+++ /dev/null
@@ -1,2 +0,0 @@
-# gofmt always uses LF, whereas Git uses CRLF on Windows.
-*.go text eol=lf
diff --git a/vendor/github.com/go-openapi/swag/.gitignore b/vendor/github.com/go-openapi/swag/.gitignore
deleted file mode 100644
index c4b1b64f..00000000
--- a/vendor/github.com/go-openapi/swag/.gitignore
+++ /dev/null
@@ -1,5 +0,0 @@
-secrets.yml
-vendor
-Godeps
-.idea
-*.out
diff --git a/vendor/github.com/go-openapi/swag/.golangci.yml b/vendor/github.com/go-openapi/swag/.golangci.yml
deleted file mode 100644
index d2fafb8a..00000000
--- a/vendor/github.com/go-openapi/swag/.golangci.yml
+++ /dev/null
@@ -1,56 +0,0 @@
-linters-settings:
- gocyclo:
- min-complexity: 45
- dupl:
- threshold: 200
- goconst:
- min-len: 2
- min-occurrences: 3
-
-linters:
- enable-all: true
- disable:
- - recvcheck
- - unparam
- - lll
- - gochecknoinits
- - gochecknoglobals
- - funlen
- - godox
- - gocognit
- - whitespace
- - wsl
- - wrapcheck
- - testpackage
- - nlreturn
- - errorlint
- - nestif
- - godot
- - gofumpt
- - paralleltest
- - tparallel
- - thelper
- - exhaustruct
- - varnamelen
- - gci
- - depguard
- - errchkjson
- - inamedparam
- - nonamedreturns
- - musttag
- - ireturn
- - forcetypeassert
- - cyclop
- # deprecated linters
- #- deadcode
- #- interfacer
- #- scopelint
- #- varcheck
- #- structcheck
- #- golint
- #- nosnakecase
- #- maligned
- #- goerr113
- #- ifshort
- #- gomnd
- #- exhaustivestruct
diff --git a/vendor/github.com/go-openapi/swag/BENCHMARK.md b/vendor/github.com/go-openapi/swag/BENCHMARK.md
deleted file mode 100644
index e7f28ed6..00000000
--- a/vendor/github.com/go-openapi/swag/BENCHMARK.md
+++ /dev/null
@@ -1,52 +0,0 @@
-# Benchmarks
-
-## Name mangling utilities
-
-```bash
-go test -bench XXX -run XXX -benchtime 30s
-```
-
-### Benchmarks at b3e7a5386f996177e4808f11acb2aa93a0f660df
-
-```
-goos: linux
-goarch: amd64
-pkg: github.com/go-openapi/swag
-cpu: Intel(R) Core(TM) i5-6200U CPU @ 2.30GHz
-BenchmarkToXXXName/ToGoName-4 862623 44101 ns/op 10450 B/op 732 allocs/op
-BenchmarkToXXXName/ToVarName-4 853656 40728 ns/op 10468 B/op 734 allocs/op
-BenchmarkToXXXName/ToFileName-4 1268312 27813 ns/op 9785 B/op 617 allocs/op
-BenchmarkToXXXName/ToCommandName-4 1276322 27903 ns/op 9785 B/op 617 allocs/op
-BenchmarkToXXXName/ToHumanNameLower-4 895334 40354 ns/op 10472 B/op 731 allocs/op
-BenchmarkToXXXName/ToHumanNameTitle-4 882441 40678 ns/op 10566 B/op 749 allocs/op
-```
-
-### Benchmarks after PR #79
-
-~ x10 performance improvement and ~ /100 memory allocations.
-
-```
-goos: linux
-goarch: amd64
-pkg: github.com/go-openapi/swag
-cpu: Intel(R) Core(TM) i5-6200U CPU @ 2.30GHz
-BenchmarkToXXXName/ToGoName-4 9595830 3991 ns/op 42 B/op 5 allocs/op
-BenchmarkToXXXName/ToVarName-4 9194276 3984 ns/op 62 B/op 7 allocs/op
-BenchmarkToXXXName/ToFileName-4 17002711 2123 ns/op 147 B/op 7 allocs/op
-BenchmarkToXXXName/ToCommandName-4 16772926 2111 ns/op 147 B/op 7 allocs/op
-BenchmarkToXXXName/ToHumanNameLower-4 9788331 3749 ns/op 92 B/op 6 allocs/op
-BenchmarkToXXXName/ToHumanNameTitle-4 9188260 3941 ns/op 104 B/op 6 allocs/op
-```
-
-```
-goos: linux
-goarch: amd64
-pkg: github.com/go-openapi/swag
-cpu: AMD Ryzen 7 5800X 8-Core Processor
-BenchmarkToXXXName/ToGoName-16 18527378 1972 ns/op 42 B/op 5 allocs/op
-BenchmarkToXXXName/ToVarName-16 15552692 2093 ns/op 62 B/op 7 allocs/op
-BenchmarkToXXXName/ToFileName-16 32161176 1117 ns/op 147 B/op 7 allocs/op
-BenchmarkToXXXName/ToCommandName-16 32256634 1137 ns/op 147 B/op 7 allocs/op
-BenchmarkToXXXName/ToHumanNameLower-16 18599661 1946 ns/op 92 B/op 6 allocs/op
-BenchmarkToXXXName/ToHumanNameTitle-16 17581353 2054 ns/op 105 B/op 6 allocs/op
-```
diff --git a/vendor/github.com/go-openapi/swag/CODE_OF_CONDUCT.md b/vendor/github.com/go-openapi/swag/CODE_OF_CONDUCT.md
deleted file mode 100644
index 9322b065..00000000
--- a/vendor/github.com/go-openapi/swag/CODE_OF_CONDUCT.md
+++ /dev/null
@@ -1,74 +0,0 @@
-# Contributor Covenant Code of Conduct
-
-## Our Pledge
-
-In the interest of fostering an open and welcoming environment, we as
-contributors and maintainers pledge to making participation in our project and
-our community a harassment-free experience for everyone, regardless of age, body
-size, disability, ethnicity, gender identity and expression, level of experience,
-nationality, personal appearance, race, religion, or sexual identity and
-orientation.
-
-## Our Standards
-
-Examples of behavior that contributes to creating a positive environment
-include:
-
-* Using welcoming and inclusive language
-* Being respectful of differing viewpoints and experiences
-* Gracefully accepting constructive criticism
-* Focusing on what is best for the community
-* Showing empathy towards other community members
-
-Examples of unacceptable behavior by participants include:
-
-* The use of sexualized language or imagery and unwelcome sexual attention or
-advances
-* Trolling, insulting/derogatory comments, and personal or political attacks
-* Public or private harassment
-* Publishing others' private information, such as a physical or electronic
- address, without explicit permission
-* Other conduct which could reasonably be considered inappropriate in a
- professional setting
-
-## Our Responsibilities
-
-Project maintainers are responsible for clarifying the standards of acceptable
-behavior and are expected to take appropriate and fair corrective action in
-response to any instances of unacceptable behavior.
-
-Project maintainers have the right and responsibility to remove, edit, or
-reject comments, commits, code, wiki edits, issues, and other contributions
-that are not aligned to this Code of Conduct, or to ban temporarily or
-permanently any contributor for other behaviors that they deem inappropriate,
-threatening, offensive, or harmful.
-
-## Scope
-
-This Code of Conduct applies both within project spaces and in public spaces
-when an individual is representing the project or its community. Examples of
-representing a project or community include using an official project e-mail
-address, posting via an official social media account, or acting as an appointed
-representative at an online or offline event. Representation of a project may be
-further defined and clarified by project maintainers.
-
-## Enforcement
-
-Instances of abusive, harassing, or otherwise unacceptable behavior may be
-reported by contacting the project team at ivan+abuse@flanders.co.nz. All
-complaints will be reviewed and investigated and will result in a response that
-is deemed necessary and appropriate to the circumstances. The project team is
-obligated to maintain confidentiality with regard to the reporter of an incident.
-Further details of specific enforcement policies may be posted separately.
-
-Project maintainers who do not follow or enforce the Code of Conduct in good
-faith may face temporary or permanent repercussions as determined by other
-members of the project's leadership.
-
-## Attribution
-
-This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
-available at [http://contributor-covenant.org/version/1/4][version]
-
-[homepage]: http://contributor-covenant.org
-[version]: http://contributor-covenant.org/version/1/4/
diff --git a/vendor/github.com/go-openapi/swag/README.md b/vendor/github.com/go-openapi/swag/README.md
deleted file mode 100644
index a7292229..00000000
--- a/vendor/github.com/go-openapi/swag/README.md
+++ /dev/null
@@ -1,23 +0,0 @@
-# Swag [](https://github.com/go-openapi/swag/actions?query=workflow%3A"go+test") [](https://codecov.io/gh/go-openapi/swag)
-
-[](https://slackin.goswagger.io)
-[](https://raw.githubusercontent.com/go-openapi/swag/master/LICENSE)
-[](https://pkg.go.dev/github.com/go-openapi/swag)
-[](https://goreportcard.com/report/github.com/go-openapi/swag)
-
-Contains a bunch of helper functions for go-openapi and go-swagger projects.
-
-You may also use it standalone for your projects.
-
-* convert between value and pointers for builtin types
-* convert from string to builtin types (wraps strconv)
-* fast json concatenation
-* search in path
-* load from file or http
-* name mangling
-
-
-This repo has only few dependencies outside of the standard library:
-
-* YAML utilities depend on `gopkg.in/yaml.v3`
-* `github.com/mailru/easyjson v0.7.7`
diff --git a/vendor/github.com/go-openapi/swag/LICENSE b/vendor/github.com/go-openapi/swag/conv/LICENSE
similarity index 100%
rename from vendor/github.com/go-openapi/swag/LICENSE
rename to vendor/github.com/go-openapi/swag/conv/LICENSE
diff --git a/vendor/github.com/go-openapi/swag/conv/convert.go b/vendor/github.com/go-openapi/swag/conv/convert.go
new file mode 100644
index 00000000..f205c391
--- /dev/null
+++ b/vendor/github.com/go-openapi/swag/conv/convert.go
@@ -0,0 +1,161 @@
+// SPDX-FileCopyrightText: Copyright 2015-2025 go-swagger maintainers
+// SPDX-License-Identifier: Apache-2.0
+
+package conv
+
+import (
+ "math"
+ "strconv"
+ "strings"
+)
+
+// same as ECMA Number.MAX_SAFE_INTEGER and Number.MIN_SAFE_INTEGER
+const (
+ maxJSONFloat = float64(1<<53 - 1) // 9007199254740991.0 2^53 - 1
+ minJSONFloat = -float64(1<<53 - 1) //-9007199254740991.0 -2^53 - 1
+ epsilon float64 = 1e-9
+)
+
+// IsFloat64AJSONInteger allows for integers [-2^53, 2^53-1] inclusive.
+func IsFloat64AJSONInteger(f float64) bool {
+ if math.IsNaN(f) || math.IsInf(f, 0) || f < minJSONFloat || f > maxJSONFloat {
+ return false
+ }
+ rounded := math.Round(f)
+ if f == rounded {
+ return true
+ }
+ if rounded == 0 { // f = 0.0 exited above
+ return false
+ }
+
+ diff := math.Abs(f - rounded)
+ if diff == 0 {
+ return true
+ }
+
+ // relative error Abs{f - Round(f)) / Round(f)} < ε ; Round(f)
+ return diff < epsilon*math.Abs(rounded)
+}
+
+// ConvertFloat turns a string into a float numerical value.
+func ConvertFloat[T Float](str string) (T, error) {
+ var v T
+ f, err := strconv.ParseFloat(str, bitsize(v))
+ if err != nil {
+ return 0, err
+ }
+
+ return T(f), nil
+}
+
+// ConvertInteger turns a string into a signed integer.
+func ConvertInteger[T Signed](str string) (T, error) {
+ var v T
+ f, err := strconv.ParseInt(str, 10, bitsize(v))
+ if err != nil {
+ return 0, err
+ }
+
+ return T(f), nil
+}
+
+// ConvertUinteger turns a string into an unsigned integer.
+func ConvertUinteger[T Unsigned](str string) (T, error) {
+ var v T
+ f, err := strconv.ParseUint(str, 10, bitsize(v))
+ if err != nil {
+ return 0, err
+ }
+
+ return T(f), nil
+}
+
+// ConvertBool turns a string into a boolean.
+//
+// It supports a few more "true" strings than [strconv.ParseBool]:
+//
+// - it is not case sensitive ("trUe" or "FalsE" work)
+// - "ok", "yes", "y", "on", "selected", "checked", "enabled" are all true
+// - everything that is not true is false: there is never an actual error returned
+func ConvertBool(str string) (bool, error) {
+ switch strings.ToLower(str) {
+ case "true",
+ "1",
+ "yes",
+ "ok",
+ "y",
+ "on",
+ "selected",
+ "checked",
+ "t",
+ "enabled":
+ return true, nil
+ default:
+ return false, nil
+ }
+}
+
+// ConvertFloat32 turns a string into a float32.
+func ConvertFloat32(str string) (float32, error) { return ConvertFloat[float32](str) }
+
+// ConvertFloat64 turns a string into a float64
+func ConvertFloat64(str string) (float64, error) { return ConvertFloat[float64](str) }
+
+// ConvertInt8 turns a string into an int8
+func ConvertInt8(str string) (int8, error) { return ConvertInteger[int8](str) }
+
+// ConvertInt16 turns a string into an int16
+func ConvertInt16(str string) (int16, error) {
+ i, err := strconv.ParseInt(str, 10, 16)
+ if err != nil {
+ return 0, err
+ }
+ return int16(i), nil
+}
+
+// ConvertInt32 turns a string into an int32
+func ConvertInt32(str string) (int32, error) {
+ i, err := strconv.ParseInt(str, 10, 32)
+ if err != nil {
+ return 0, err
+ }
+ return int32(i), nil
+}
+
+// ConvertInt64 turns a string into an int64
+func ConvertInt64(str string) (int64, error) {
+ return strconv.ParseInt(str, 10, 64)
+}
+
+// ConvertUint8 turns a string into an uint8
+func ConvertUint8(str string) (uint8, error) {
+ i, err := strconv.ParseUint(str, 10, 8)
+ if err != nil {
+ return 0, err
+ }
+ return uint8(i), nil
+}
+
+// ConvertUint16 turns a string into an uint16
+func ConvertUint16(str string) (uint16, error) {
+ i, err := strconv.ParseUint(str, 10, 16)
+ if err != nil {
+ return 0, err
+ }
+ return uint16(i), nil
+}
+
+// ConvertUint32 turns a string into an uint32
+func ConvertUint32(str string) (uint32, error) {
+ i, err := strconv.ParseUint(str, 10, 32)
+ if err != nil {
+ return 0, err
+ }
+ return uint32(i), nil
+}
+
+// ConvertUint64 turns a string into an uint64
+func ConvertUint64(str string) (uint64, error) {
+ return strconv.ParseUint(str, 10, 64)
+}
diff --git a/vendor/github.com/go-openapi/swag/conv/convert_types.go b/vendor/github.com/go-openapi/swag/conv/convert_types.go
new file mode 100644
index 00000000..cf4c6495
--- /dev/null
+++ b/vendor/github.com/go-openapi/swag/conv/convert_types.go
@@ -0,0 +1,72 @@
+// SPDX-FileCopyrightText: Copyright 2015-2025 go-swagger maintainers
+// SPDX-License-Identifier: Apache-2.0
+
+package conv
+
+// Unlicensed credits (idea, concept)
+//
+// The idea to convert values to pointers and the other way around, was inspired, eons ago, by the aws go sdk.
+//
+// Nowadays, all sensible API sdk's expose a similar functionality.
+
+// Pointer returns a pointer to the value passed in.
+func Pointer[T any](v T) *T {
+ return &v
+}
+
+// Value returns a shallow copy of the value of the pointer passed in.
+//
+// If the pointer is nil, the returned value is the zero value.
+func Value[T any](v *T) T {
+ if v != nil {
+ return *v
+ }
+
+ var zero T
+ return zero
+}
+
+// PointerSlice converts a slice of values into a slice of pointers.
+func PointerSlice[T any](src []T) []*T {
+ dst := make([]*T, len(src))
+ for i := 0; i < len(src); i++ {
+ dst[i] = &(src[i])
+ }
+ return dst
+}
+
+// ValueSlice converts a slice of pointers into a slice of values.
+//
+// nil elements are zero values.
+func ValueSlice[T any](src []*T) []T {
+ dst := make([]T, len(src))
+ for i := 0; i < len(src); i++ {
+ if src[i] != nil {
+ dst[i] = *(src[i])
+ }
+ }
+ return dst
+}
+
+// PointerMap converts a map of values into a map of pointers.
+func PointerMap[K comparable, T any](src map[K]T) map[K]*T {
+ dst := make(map[K]*T)
+ for k, val := range src {
+ v := val
+ dst[k] = &v
+ }
+ return dst
+}
+
+// ValueMap converts a map of pointers into a map of values.
+//
+// nil elements are skipped.
+func ValueMap[K comparable, T any](src map[K]*T) map[K]T {
+ dst := make(map[K]T)
+ for k, val := range src {
+ if val != nil {
+ dst[k] = *val
+ }
+ }
+ return dst
+}
diff --git a/vendor/github.com/go-openapi/swag/conv/doc.go b/vendor/github.com/go-openapi/swag/conv/doc.go
new file mode 100644
index 00000000..1bd6ead6
--- /dev/null
+++ b/vendor/github.com/go-openapi/swag/conv/doc.go
@@ -0,0 +1,15 @@
+// SPDX-FileCopyrightText: Copyright 2015-2025 go-swagger maintainers
+// SPDX-License-Identifier: Apache-2.0
+
+// Package conv exposes utilities to convert types.
+//
+// The Convert and Format families of functions are essentially a shorthand to [strconv] functions,
+// using the decimal representation of numbers.
+//
+// Features:
+//
+// - from string representation to value ("Convert*") and reciprocally ("Format*")
+// - from pointer to value ([Value]) and reciprocally ([Pointer])
+// - from slice of values to slice of pointers ([PointerSlice]) and reciprocally ([ValueSlice])
+// - from map of values to map of pointers ([PointerMap]) and reciprocally ([ValueMap])
+package conv
diff --git a/vendor/github.com/go-openapi/swag/conv/format.go b/vendor/github.com/go-openapi/swag/conv/format.go
new file mode 100644
index 00000000..5b87b8e1
--- /dev/null
+++ b/vendor/github.com/go-openapi/swag/conv/format.go
@@ -0,0 +1,28 @@
+// SPDX-FileCopyrightText: Copyright 2015-2025 go-swagger maintainers
+// SPDX-License-Identifier: Apache-2.0
+
+package conv
+
+import (
+ "strconv"
+)
+
+// FormatInteger turns an integer type into a string.
+func FormatInteger[T Signed](value T) string {
+ return strconv.FormatInt(int64(value), 10)
+}
+
+// FormatUinteger turns an unsigned integer type into a string.
+func FormatUinteger[T Unsigned](value T) string {
+ return strconv.FormatUint(uint64(value), 10)
+}
+
+// FormatFloat turns a floating point numerical value into a string.
+func FormatFloat[T Float](value T) string {
+ return strconv.FormatFloat(float64(value), 'f', -1, bitsize(value))
+}
+
+// FormatBool turns a boolean into a string.
+func FormatBool(value bool) string {
+ return strconv.FormatBool(value)
+}
diff --git a/vendor/github.com/go-openapi/swag/conv/sizeof.go b/vendor/github.com/go-openapi/swag/conv/sizeof.go
new file mode 100644
index 00000000..49434655
--- /dev/null
+++ b/vendor/github.com/go-openapi/swag/conv/sizeof.go
@@ -0,0 +1,20 @@
+// SPDX-FileCopyrightText: Copyright 2015-2025 go-swagger maintainers
+// SPDX-License-Identifier: Apache-2.0
+
+package conv
+
+import "unsafe"
+
+// bitsize returns the size in bits of a type.
+//
+// NOTE: [unsafe.SizeOf] simply returns the size in bytes of the value.
+// For primitive types T, the generic stencil is precompiled and this value
+// is resolved at compile time, resulting in an immediate call to [strconv.ParseFloat].
+//
+// We may leave up to the go compiler to simplify this function into a
+// constant value, which happens in practice at least for primitive types
+// (e.g. numerical types).
+func bitsize[T Numerical](value T) int {
+ const bitsPerByte = 8
+ return int(unsafe.Sizeof(value)) * bitsPerByte
+}
diff --git a/vendor/github.com/go-openapi/swag/conv/type_constraints.go b/vendor/github.com/go-openapi/swag/conv/type_constraints.go
new file mode 100644
index 00000000..81135e82
--- /dev/null
+++ b/vendor/github.com/go-openapi/swag/conv/type_constraints.go
@@ -0,0 +1,29 @@
+// SPDX-FileCopyrightText: Copyright 2015-2025 go-swagger maintainers
+// SPDX-License-Identifier: Apache-2.0
+
+package conv
+
+type (
+ // these type constraints are redefined after golang.org/x/exp/constraints,
+ // because importing that package causes an undesired go upgrade.
+
+ // Signed integer types, cf. [golang.org/x/exp/constraints.Signed]
+ Signed interface {
+ ~int | ~int8 | ~int16 | ~int32 | ~int64
+ }
+
+ // Unsigned integer types, cf. [golang.org/x/exp/constraints.Unsigned]
+ Unsigned interface {
+ ~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 | ~uintptr
+ }
+
+ // Float numerical types, cf. [golang.org/x/exp/constraints.Float]
+ Float interface {
+ ~float32 | ~float64
+ }
+
+ // Numerical types
+ Numerical interface {
+ Signed | Unsigned | Float
+ }
+)
diff --git a/vendor/github.com/go-openapi/swag/convert.go b/vendor/github.com/go-openapi/swag/convert.go
deleted file mode 100644
index fc085aeb..00000000
--- a/vendor/github.com/go-openapi/swag/convert.go
+++ /dev/null
@@ -1,208 +0,0 @@
-// Copyright 2015 go-swagger maintainers
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package swag
-
-import (
- "math"
- "strconv"
- "strings"
-)
-
-// same as ECMA Number.MAX_SAFE_INTEGER and Number.MIN_SAFE_INTEGER
-const (
- maxJSONFloat = float64(1<<53 - 1) // 9007199254740991.0 2^53 - 1
- minJSONFloat = -float64(1<<53 - 1) //-9007199254740991.0 -2^53 - 1
- epsilon float64 = 1e-9
-)
-
-// IsFloat64AJSONInteger allow for integers [-2^53, 2^53-1] inclusive
-func IsFloat64AJSONInteger(f float64) bool {
- if math.IsNaN(f) || math.IsInf(f, 0) || f < minJSONFloat || f > maxJSONFloat {
- return false
- }
- fa := math.Abs(f)
- g := float64(uint64(f))
- ga := math.Abs(g)
-
- diff := math.Abs(f - g)
-
- // more info: https://floating-point-gui.de/errors/comparison/#look-out-for-edge-cases
- switch {
- case f == g: // best case
- return true
- case f == float64(int64(f)) || f == float64(uint64(f)): // optimistic case
- return true
- case f == 0 || g == 0 || diff < math.SmallestNonzeroFloat64: // very close to 0 values
- return diff < (epsilon * math.SmallestNonzeroFloat64)
- }
- // check the relative error
- return diff/math.Min(fa+ga, math.MaxFloat64) < epsilon
-}
-
-var evaluatesAsTrue map[string]struct{}
-
-func init() {
- evaluatesAsTrue = map[string]struct{}{
- "true": {},
- "1": {},
- "yes": {},
- "ok": {},
- "y": {},
- "on": {},
- "selected": {},
- "checked": {},
- "t": {},
- "enabled": {},
- }
-}
-
-// ConvertBool turn a string into a boolean
-func ConvertBool(str string) (bool, error) {
- _, ok := evaluatesAsTrue[strings.ToLower(str)]
- return ok, nil
-}
-
-// ConvertFloat32 turn a string into a float32
-func ConvertFloat32(str string) (float32, error) {
- f, err := strconv.ParseFloat(str, 32)
- if err != nil {
- return 0, err
- }
- return float32(f), nil
-}
-
-// ConvertFloat64 turn a string into a float64
-func ConvertFloat64(str string) (float64, error) {
- return strconv.ParseFloat(str, 64)
-}
-
-// ConvertInt8 turn a string into an int8
-func ConvertInt8(str string) (int8, error) {
- i, err := strconv.ParseInt(str, 10, 8)
- if err != nil {
- return 0, err
- }
- return int8(i), nil
-}
-
-// ConvertInt16 turn a string into an int16
-func ConvertInt16(str string) (int16, error) {
- i, err := strconv.ParseInt(str, 10, 16)
- if err != nil {
- return 0, err
- }
- return int16(i), nil
-}
-
-// ConvertInt32 turn a string into an int32
-func ConvertInt32(str string) (int32, error) {
- i, err := strconv.ParseInt(str, 10, 32)
- if err != nil {
- return 0, err
- }
- return int32(i), nil
-}
-
-// ConvertInt64 turn a string into an int64
-func ConvertInt64(str string) (int64, error) {
- return strconv.ParseInt(str, 10, 64)
-}
-
-// ConvertUint8 turn a string into an uint8
-func ConvertUint8(str string) (uint8, error) {
- i, err := strconv.ParseUint(str, 10, 8)
- if err != nil {
- return 0, err
- }
- return uint8(i), nil
-}
-
-// ConvertUint16 turn a string into an uint16
-func ConvertUint16(str string) (uint16, error) {
- i, err := strconv.ParseUint(str, 10, 16)
- if err != nil {
- return 0, err
- }
- return uint16(i), nil
-}
-
-// ConvertUint32 turn a string into an uint32
-func ConvertUint32(str string) (uint32, error) {
- i, err := strconv.ParseUint(str, 10, 32)
- if err != nil {
- return 0, err
- }
- return uint32(i), nil
-}
-
-// ConvertUint64 turn a string into an uint64
-func ConvertUint64(str string) (uint64, error) {
- return strconv.ParseUint(str, 10, 64)
-}
-
-// FormatBool turns a boolean into a string
-func FormatBool(value bool) string {
- return strconv.FormatBool(value)
-}
-
-// FormatFloat32 turns a float32 into a string
-func FormatFloat32(value float32) string {
- return strconv.FormatFloat(float64(value), 'f', -1, 32)
-}
-
-// FormatFloat64 turns a float64 into a string
-func FormatFloat64(value float64) string {
- return strconv.FormatFloat(value, 'f', -1, 64)
-}
-
-// FormatInt8 turns an int8 into a string
-func FormatInt8(value int8) string {
- return strconv.FormatInt(int64(value), 10)
-}
-
-// FormatInt16 turns an int16 into a string
-func FormatInt16(value int16) string {
- return strconv.FormatInt(int64(value), 10)
-}
-
-// FormatInt32 turns an int32 into a string
-func FormatInt32(value int32) string {
- return strconv.Itoa(int(value))
-}
-
-// FormatInt64 turns an int64 into a string
-func FormatInt64(value int64) string {
- return strconv.FormatInt(value, 10)
-}
-
-// FormatUint8 turns an uint8 into a string
-func FormatUint8(value uint8) string {
- return strconv.FormatUint(uint64(value), 10)
-}
-
-// FormatUint16 turns an uint16 into a string
-func FormatUint16(value uint16) string {
- return strconv.FormatUint(uint64(value), 10)
-}
-
-// FormatUint32 turns an uint32 into a string
-func FormatUint32(value uint32) string {
- return strconv.FormatUint(uint64(value), 10)
-}
-
-// FormatUint64 turns an uint64 into a string
-func FormatUint64(value uint64) string {
- return strconv.FormatUint(value, 10)
-}
diff --git a/vendor/github.com/go-openapi/swag/convert_types.go b/vendor/github.com/go-openapi/swag/convert_types.go
deleted file mode 100644
index c49cc473..00000000
--- a/vendor/github.com/go-openapi/swag/convert_types.go
+++ /dev/null
@@ -1,730 +0,0 @@
-package swag
-
-import "time"
-
-// This file was taken from the aws go sdk
-
-// String returns a pointer to of the string value passed in.
-func String(v string) *string {
- return &v
-}
-
-// StringValue returns the value of the string pointer passed in or
-// "" if the pointer is nil.
-func StringValue(v *string) string {
- if v != nil {
- return *v
- }
- return ""
-}
-
-// StringSlice converts a slice of string values into a slice of
-// string pointers
-func StringSlice(src []string) []*string {
- dst := make([]*string, len(src))
- for i := 0; i < len(src); i++ {
- dst[i] = &(src[i])
- }
- return dst
-}
-
-// StringValueSlice converts a slice of string pointers into a slice of
-// string values
-func StringValueSlice(src []*string) []string {
- dst := make([]string, len(src))
- for i := 0; i < len(src); i++ {
- if src[i] != nil {
- dst[i] = *(src[i])
- }
- }
- return dst
-}
-
-// StringMap converts a string map of string values into a string
-// map of string pointers
-func StringMap(src map[string]string) map[string]*string {
- dst := make(map[string]*string)
- for k, val := range src {
- v := val
- dst[k] = &v
- }
- return dst
-}
-
-// StringValueMap converts a string map of string pointers into a string
-// map of string values
-func StringValueMap(src map[string]*string) map[string]string {
- dst := make(map[string]string)
- for k, val := range src {
- if val != nil {
- dst[k] = *val
- }
- }
- return dst
-}
-
-// Bool returns a pointer to of the bool value passed in.
-func Bool(v bool) *bool {
- return &v
-}
-
-// BoolValue returns the value of the bool pointer passed in or
-// false if the pointer is nil.
-func BoolValue(v *bool) bool {
- if v != nil {
- return *v
- }
- return false
-}
-
-// BoolSlice converts a slice of bool values into a slice of
-// bool pointers
-func BoolSlice(src []bool) []*bool {
- dst := make([]*bool, len(src))
- for i := 0; i < len(src); i++ {
- dst[i] = &(src[i])
- }
- return dst
-}
-
-// BoolValueSlice converts a slice of bool pointers into a slice of
-// bool values
-func BoolValueSlice(src []*bool) []bool {
- dst := make([]bool, len(src))
- for i := 0; i < len(src); i++ {
- if src[i] != nil {
- dst[i] = *(src[i])
- }
- }
- return dst
-}
-
-// BoolMap converts a string map of bool values into a string
-// map of bool pointers
-func BoolMap(src map[string]bool) map[string]*bool {
- dst := make(map[string]*bool)
- for k, val := range src {
- v := val
- dst[k] = &v
- }
- return dst
-}
-
-// BoolValueMap converts a string map of bool pointers into a string
-// map of bool values
-func BoolValueMap(src map[string]*bool) map[string]bool {
- dst := make(map[string]bool)
- for k, val := range src {
- if val != nil {
- dst[k] = *val
- }
- }
- return dst
-}
-
-// Int returns a pointer to of the int value passed in.
-func Int(v int) *int {
- return &v
-}
-
-// IntValue returns the value of the int pointer passed in or
-// 0 if the pointer is nil.
-func IntValue(v *int) int {
- if v != nil {
- return *v
- }
- return 0
-}
-
-// IntSlice converts a slice of int values into a slice of
-// int pointers
-func IntSlice(src []int) []*int {
- dst := make([]*int, len(src))
- for i := 0; i < len(src); i++ {
- dst[i] = &(src[i])
- }
- return dst
-}
-
-// IntValueSlice converts a slice of int pointers into a slice of
-// int values
-func IntValueSlice(src []*int) []int {
- dst := make([]int, len(src))
- for i := 0; i < len(src); i++ {
- if src[i] != nil {
- dst[i] = *(src[i])
- }
- }
- return dst
-}
-
-// IntMap converts a string map of int values into a string
-// map of int pointers
-func IntMap(src map[string]int) map[string]*int {
- dst := make(map[string]*int)
- for k, val := range src {
- v := val
- dst[k] = &v
- }
- return dst
-}
-
-// IntValueMap converts a string map of int pointers into a string
-// map of int values
-func IntValueMap(src map[string]*int) map[string]int {
- dst := make(map[string]int)
- for k, val := range src {
- if val != nil {
- dst[k] = *val
- }
- }
- return dst
-}
-
-// Int32 returns a pointer to of the int32 value passed in.
-func Int32(v int32) *int32 {
- return &v
-}
-
-// Int32Value returns the value of the int32 pointer passed in or
-// 0 if the pointer is nil.
-func Int32Value(v *int32) int32 {
- if v != nil {
- return *v
- }
- return 0
-}
-
-// Int32Slice converts a slice of int32 values into a slice of
-// int32 pointers
-func Int32Slice(src []int32) []*int32 {
- dst := make([]*int32, len(src))
- for i := 0; i < len(src); i++ {
- dst[i] = &(src[i])
- }
- return dst
-}
-
-// Int32ValueSlice converts a slice of int32 pointers into a slice of
-// int32 values
-func Int32ValueSlice(src []*int32) []int32 {
- dst := make([]int32, len(src))
- for i := 0; i < len(src); i++ {
- if src[i] != nil {
- dst[i] = *(src[i])
- }
- }
- return dst
-}
-
-// Int32Map converts a string map of int32 values into a string
-// map of int32 pointers
-func Int32Map(src map[string]int32) map[string]*int32 {
- dst := make(map[string]*int32)
- for k, val := range src {
- v := val
- dst[k] = &v
- }
- return dst
-}
-
-// Int32ValueMap converts a string map of int32 pointers into a string
-// map of int32 values
-func Int32ValueMap(src map[string]*int32) map[string]int32 {
- dst := make(map[string]int32)
- for k, val := range src {
- if val != nil {
- dst[k] = *val
- }
- }
- return dst
-}
-
-// Int64 returns a pointer to of the int64 value passed in.
-func Int64(v int64) *int64 {
- return &v
-}
-
-// Int64Value returns the value of the int64 pointer passed in or
-// 0 if the pointer is nil.
-func Int64Value(v *int64) int64 {
- if v != nil {
- return *v
- }
- return 0
-}
-
-// Int64Slice converts a slice of int64 values into a slice of
-// int64 pointers
-func Int64Slice(src []int64) []*int64 {
- dst := make([]*int64, len(src))
- for i := 0; i < len(src); i++ {
- dst[i] = &(src[i])
- }
- return dst
-}
-
-// Int64ValueSlice converts a slice of int64 pointers into a slice of
-// int64 values
-func Int64ValueSlice(src []*int64) []int64 {
- dst := make([]int64, len(src))
- for i := 0; i < len(src); i++ {
- if src[i] != nil {
- dst[i] = *(src[i])
- }
- }
- return dst
-}
-
-// Int64Map converts a string map of int64 values into a string
-// map of int64 pointers
-func Int64Map(src map[string]int64) map[string]*int64 {
- dst := make(map[string]*int64)
- for k, val := range src {
- v := val
- dst[k] = &v
- }
- return dst
-}
-
-// Int64ValueMap converts a string map of int64 pointers into a string
-// map of int64 values
-func Int64ValueMap(src map[string]*int64) map[string]int64 {
- dst := make(map[string]int64)
- for k, val := range src {
- if val != nil {
- dst[k] = *val
- }
- }
- return dst
-}
-
-// Uint16 returns a pointer to of the uint16 value passed in.
-func Uint16(v uint16) *uint16 {
- return &v
-}
-
-// Uint16Value returns the value of the uint16 pointer passed in or
-// 0 if the pointer is nil.
-func Uint16Value(v *uint16) uint16 {
- if v != nil {
- return *v
- }
-
- return 0
-}
-
-// Uint16Slice converts a slice of uint16 values into a slice of
-// uint16 pointers
-func Uint16Slice(src []uint16) []*uint16 {
- dst := make([]*uint16, len(src))
- for i := 0; i < len(src); i++ {
- dst[i] = &(src[i])
- }
-
- return dst
-}
-
-// Uint16ValueSlice converts a slice of uint16 pointers into a slice of
-// uint16 values
-func Uint16ValueSlice(src []*uint16) []uint16 {
- dst := make([]uint16, len(src))
-
- for i := 0; i < len(src); i++ {
- if src[i] != nil {
- dst[i] = *(src[i])
- }
- }
-
- return dst
-}
-
-// Uint16Map converts a string map of uint16 values into a string
-// map of uint16 pointers
-func Uint16Map(src map[string]uint16) map[string]*uint16 {
- dst := make(map[string]*uint16)
-
- for k, val := range src {
- v := val
- dst[k] = &v
- }
-
- return dst
-}
-
-// Uint16ValueMap converts a string map of uint16 pointers into a string
-// map of uint16 values
-func Uint16ValueMap(src map[string]*uint16) map[string]uint16 {
- dst := make(map[string]uint16)
-
- for k, val := range src {
- if val != nil {
- dst[k] = *val
- }
- }
-
- return dst
-}
-
-// Uint returns a pointer to of the uint value passed in.
-func Uint(v uint) *uint {
- return &v
-}
-
-// UintValue returns the value of the uint pointer passed in or
-// 0 if the pointer is nil.
-func UintValue(v *uint) uint {
- if v != nil {
- return *v
- }
- return 0
-}
-
-// UintSlice converts a slice of uint values into a slice of
-// uint pointers
-func UintSlice(src []uint) []*uint {
- dst := make([]*uint, len(src))
- for i := 0; i < len(src); i++ {
- dst[i] = &(src[i])
- }
- return dst
-}
-
-// UintValueSlice converts a slice of uint pointers into a slice of
-// uint values
-func UintValueSlice(src []*uint) []uint {
- dst := make([]uint, len(src))
- for i := 0; i < len(src); i++ {
- if src[i] != nil {
- dst[i] = *(src[i])
- }
- }
- return dst
-}
-
-// UintMap converts a string map of uint values into a string
-// map of uint pointers
-func UintMap(src map[string]uint) map[string]*uint {
- dst := make(map[string]*uint)
- for k, val := range src {
- v := val
- dst[k] = &v
- }
- return dst
-}
-
-// UintValueMap converts a string map of uint pointers into a string
-// map of uint values
-func UintValueMap(src map[string]*uint) map[string]uint {
- dst := make(map[string]uint)
- for k, val := range src {
- if val != nil {
- dst[k] = *val
- }
- }
- return dst
-}
-
-// Uint32 returns a pointer to of the uint32 value passed in.
-func Uint32(v uint32) *uint32 {
- return &v
-}
-
-// Uint32Value returns the value of the uint32 pointer passed in or
-// 0 if the pointer is nil.
-func Uint32Value(v *uint32) uint32 {
- if v != nil {
- return *v
- }
- return 0
-}
-
-// Uint32Slice converts a slice of uint32 values into a slice of
-// uint32 pointers
-func Uint32Slice(src []uint32) []*uint32 {
- dst := make([]*uint32, len(src))
- for i := 0; i < len(src); i++ {
- dst[i] = &(src[i])
- }
- return dst
-}
-
-// Uint32ValueSlice converts a slice of uint32 pointers into a slice of
-// uint32 values
-func Uint32ValueSlice(src []*uint32) []uint32 {
- dst := make([]uint32, len(src))
- for i := 0; i < len(src); i++ {
- if src[i] != nil {
- dst[i] = *(src[i])
- }
- }
- return dst
-}
-
-// Uint32Map converts a string map of uint32 values into a string
-// map of uint32 pointers
-func Uint32Map(src map[string]uint32) map[string]*uint32 {
- dst := make(map[string]*uint32)
- for k, val := range src {
- v := val
- dst[k] = &v
- }
- return dst
-}
-
-// Uint32ValueMap converts a string map of uint32 pointers into a string
-// map of uint32 values
-func Uint32ValueMap(src map[string]*uint32) map[string]uint32 {
- dst := make(map[string]uint32)
- for k, val := range src {
- if val != nil {
- dst[k] = *val
- }
- }
- return dst
-}
-
-// Uint64 returns a pointer to of the uint64 value passed in.
-func Uint64(v uint64) *uint64 {
- return &v
-}
-
-// Uint64Value returns the value of the uint64 pointer passed in or
-// 0 if the pointer is nil.
-func Uint64Value(v *uint64) uint64 {
- if v != nil {
- return *v
- }
- return 0
-}
-
-// Uint64Slice converts a slice of uint64 values into a slice of
-// uint64 pointers
-func Uint64Slice(src []uint64) []*uint64 {
- dst := make([]*uint64, len(src))
- for i := 0; i < len(src); i++ {
- dst[i] = &(src[i])
- }
- return dst
-}
-
-// Uint64ValueSlice converts a slice of uint64 pointers into a slice of
-// uint64 values
-func Uint64ValueSlice(src []*uint64) []uint64 {
- dst := make([]uint64, len(src))
- for i := 0; i < len(src); i++ {
- if src[i] != nil {
- dst[i] = *(src[i])
- }
- }
- return dst
-}
-
-// Uint64Map converts a string map of uint64 values into a string
-// map of uint64 pointers
-func Uint64Map(src map[string]uint64) map[string]*uint64 {
- dst := make(map[string]*uint64)
- for k, val := range src {
- v := val
- dst[k] = &v
- }
- return dst
-}
-
-// Uint64ValueMap converts a string map of uint64 pointers into a string
-// map of uint64 values
-func Uint64ValueMap(src map[string]*uint64) map[string]uint64 {
- dst := make(map[string]uint64)
- for k, val := range src {
- if val != nil {
- dst[k] = *val
- }
- }
- return dst
-}
-
-// Float32 returns a pointer to of the float32 value passed in.
-func Float32(v float32) *float32 {
- return &v
-}
-
-// Float32Value returns the value of the float32 pointer passed in or
-// 0 if the pointer is nil.
-func Float32Value(v *float32) float32 {
- if v != nil {
- return *v
- }
-
- return 0
-}
-
-// Float32Slice converts a slice of float32 values into a slice of
-// float32 pointers
-func Float32Slice(src []float32) []*float32 {
- dst := make([]*float32, len(src))
-
- for i := 0; i < len(src); i++ {
- dst[i] = &(src[i])
- }
-
- return dst
-}
-
-// Float32ValueSlice converts a slice of float32 pointers into a slice of
-// float32 values
-func Float32ValueSlice(src []*float32) []float32 {
- dst := make([]float32, len(src))
-
- for i := 0; i < len(src); i++ {
- if src[i] != nil {
- dst[i] = *(src[i])
- }
- }
-
- return dst
-}
-
-// Float32Map converts a string map of float32 values into a string
-// map of float32 pointers
-func Float32Map(src map[string]float32) map[string]*float32 {
- dst := make(map[string]*float32)
-
- for k, val := range src {
- v := val
- dst[k] = &v
- }
-
- return dst
-}
-
-// Float32ValueMap converts a string map of float32 pointers into a string
-// map of float32 values
-func Float32ValueMap(src map[string]*float32) map[string]float32 {
- dst := make(map[string]float32)
-
- for k, val := range src {
- if val != nil {
- dst[k] = *val
- }
- }
-
- return dst
-}
-
-// Float64 returns a pointer to of the float64 value passed in.
-func Float64(v float64) *float64 {
- return &v
-}
-
-// Float64Value returns the value of the float64 pointer passed in or
-// 0 if the pointer is nil.
-func Float64Value(v *float64) float64 {
- if v != nil {
- return *v
- }
- return 0
-}
-
-// Float64Slice converts a slice of float64 values into a slice of
-// float64 pointers
-func Float64Slice(src []float64) []*float64 {
- dst := make([]*float64, len(src))
- for i := 0; i < len(src); i++ {
- dst[i] = &(src[i])
- }
- return dst
-}
-
-// Float64ValueSlice converts a slice of float64 pointers into a slice of
-// float64 values
-func Float64ValueSlice(src []*float64) []float64 {
- dst := make([]float64, len(src))
- for i := 0; i < len(src); i++ {
- if src[i] != nil {
- dst[i] = *(src[i])
- }
- }
- return dst
-}
-
-// Float64Map converts a string map of float64 values into a string
-// map of float64 pointers
-func Float64Map(src map[string]float64) map[string]*float64 {
- dst := make(map[string]*float64)
- for k, val := range src {
- v := val
- dst[k] = &v
- }
- return dst
-}
-
-// Float64ValueMap converts a string map of float64 pointers into a string
-// map of float64 values
-func Float64ValueMap(src map[string]*float64) map[string]float64 {
- dst := make(map[string]float64)
- for k, val := range src {
- if val != nil {
- dst[k] = *val
- }
- }
- return dst
-}
-
-// Time returns a pointer to of the time.Time value passed in.
-func Time(v time.Time) *time.Time {
- return &v
-}
-
-// TimeValue returns the value of the time.Time pointer passed in or
-// time.Time{} if the pointer is nil.
-func TimeValue(v *time.Time) time.Time {
- if v != nil {
- return *v
- }
- return time.Time{}
-}
-
-// TimeSlice converts a slice of time.Time values into a slice of
-// time.Time pointers
-func TimeSlice(src []time.Time) []*time.Time {
- dst := make([]*time.Time, len(src))
- for i := 0; i < len(src); i++ {
- dst[i] = &(src[i])
- }
- return dst
-}
-
-// TimeValueSlice converts a slice of time.Time pointers into a slice of
-// time.Time values
-func TimeValueSlice(src []*time.Time) []time.Time {
- dst := make([]time.Time, len(src))
- for i := 0; i < len(src); i++ {
- if src[i] != nil {
- dst[i] = *(src[i])
- }
- }
- return dst
-}
-
-// TimeMap converts a string map of time.Time values into a string
-// map of time.Time pointers
-func TimeMap(src map[string]time.Time) map[string]*time.Time {
- dst := make(map[string]*time.Time)
- for k, val := range src {
- v := val
- dst[k] = &v
- }
- return dst
-}
-
-// TimeValueMap converts a string map of time.Time pointers into a string
-// map of time.Time values
-func TimeValueMap(src map[string]*time.Time) map[string]time.Time {
- dst := make(map[string]time.Time)
- for k, val := range src {
- if val != nil {
- dst[k] = *val
- }
- }
- return dst
-}
diff --git a/vendor/github.com/go-openapi/swag/doc.go b/vendor/github.com/go-openapi/swag/doc.go
deleted file mode 100644
index 55094cb7..00000000
--- a/vendor/github.com/go-openapi/swag/doc.go
+++ /dev/null
@@ -1,31 +0,0 @@
-// Copyright 2015 go-swagger maintainers
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-/*
-Package swag contains a bunch of helper functions for go-openapi and go-swagger projects.
-
-You may also use it standalone for your projects.
-
- - convert between value and pointers for builtin types
- - convert from string to builtin types (wraps strconv)
- - fast json concatenation
- - search in path
- - load from file or http
- - name mangling
-
-This repo has only few dependencies outside of the standard library:
-
- - YAML utilities depend on gopkg.in/yaml.v2
-*/
-package swag
diff --git a/vendor/github.com/go-openapi/swag/errors.go b/vendor/github.com/go-openapi/swag/errors.go
deleted file mode 100644
index 6c67fbf9..00000000
--- a/vendor/github.com/go-openapi/swag/errors.go
+++ /dev/null
@@ -1,15 +0,0 @@
-package swag
-
-type swagError string
-
-const (
- // ErrYAML is an error raised by YAML utilities
- ErrYAML swagError = "yaml error"
-
- // ErrLoader is an error raised by the file loader utility
- ErrLoader swagError = "loader error"
-)
-
-func (e swagError) Error() string {
- return string(e)
-}
diff --git a/vendor/github.com/go-openapi/swag/file.go b/vendor/github.com/go-openapi/swag/file.go
deleted file mode 100644
index 16accc55..00000000
--- a/vendor/github.com/go-openapi/swag/file.go
+++ /dev/null
@@ -1,33 +0,0 @@
-// Copyright 2015 go-swagger maintainers
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package swag
-
-import "mime/multipart"
-
-// File represents an uploaded file.
-type File struct {
- Data multipart.File
- Header *multipart.FileHeader
-}
-
-// Read bytes from the file
-func (f *File) Read(p []byte) (n int, err error) {
- return f.Data.Read(p)
-}
-
-// Close the file
-func (f *File) Close() error {
- return f.Data.Close()
-}
diff --git a/vendor/github.com/go-openapi/swag/initialism_index.go b/vendor/github.com/go-openapi/swag/initialism_index.go
deleted file mode 100644
index 20a359bb..00000000
--- a/vendor/github.com/go-openapi/swag/initialism_index.go
+++ /dev/null
@@ -1,202 +0,0 @@
-// Copyright 2015 go-swagger maintainers
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package swag
-
-import (
- "sort"
- "strings"
- "sync"
-)
-
-var (
- // commonInitialisms are common acronyms that are kept as whole uppercased words.
- commonInitialisms *indexOfInitialisms
-
- // initialisms is a slice of sorted initialisms
- initialisms []string
-
- // a copy of initialisms pre-baked as []rune
- initialismsRunes [][]rune
- initialismsUpperCased [][]rune
-
- isInitialism func(string) bool
-
- maxAllocMatches int
-)
-
-func init() {
- // Taken from https://github.com/golang/lint/blob/3390df4df2787994aea98de825b964ac7944b817/lint.go#L732-L769
- configuredInitialisms := map[string]bool{
- "ACL": true,
- "API": true,
- "ASCII": true,
- "CPU": true,
- "CSS": true,
- "DNS": true,
- "EOF": true,
- "GUID": true,
- "HTML": true,
- "HTTPS": true,
- "HTTP": true,
- "ID": true,
- "IP": true,
- "IPv4": true,
- "IPv6": true,
- "JSON": true,
- "LHS": true,
- "OAI": true,
- "QPS": true,
- "RAM": true,
- "RHS": true,
- "RPC": true,
- "SLA": true,
- "SMTP": true,
- "SQL": true,
- "SSH": true,
- "TCP": true,
- "TLS": true,
- "TTL": true,
- "UDP": true,
- "UI": true,
- "UID": true,
- "UUID": true,
- "URI": true,
- "URL": true,
- "UTF8": true,
- "VM": true,
- "XML": true,
- "XMPP": true,
- "XSRF": true,
- "XSS": true,
- }
-
- // a thread-safe index of initialisms
- commonInitialisms = newIndexOfInitialisms().load(configuredInitialisms)
- initialisms = commonInitialisms.sorted()
- initialismsRunes = asRunes(initialisms)
- initialismsUpperCased = asUpperCased(initialisms)
- maxAllocMatches = maxAllocHeuristic(initialismsRunes)
-
- // a test function
- isInitialism = commonInitialisms.isInitialism
-}
-
-func asRunes(in []string) [][]rune {
- out := make([][]rune, len(in))
- for i, initialism := range in {
- out[i] = []rune(initialism)
- }
-
- return out
-}
-
-func asUpperCased(in []string) [][]rune {
- out := make([][]rune, len(in))
-
- for i, initialism := range in {
- out[i] = []rune(upper(trim(initialism)))
- }
-
- return out
-}
-
-func maxAllocHeuristic(in [][]rune) int {
- heuristic := make(map[rune]int)
- for _, initialism := range in {
- heuristic[initialism[0]]++
- }
-
- var maxAlloc int
- for _, val := range heuristic {
- if val > maxAlloc {
- maxAlloc = val
- }
- }
-
- return maxAlloc
-}
-
-// AddInitialisms add additional initialisms
-func AddInitialisms(words ...string) {
- for _, word := range words {
- // commonInitialisms[upper(word)] = true
- commonInitialisms.add(upper(word))
- }
- // sort again
- initialisms = commonInitialisms.sorted()
- initialismsRunes = asRunes(initialisms)
- initialismsUpperCased = asUpperCased(initialisms)
-}
-
-// indexOfInitialisms is a thread-safe implementation of the sorted index of initialisms.
-// Since go1.9, this may be implemented with sync.Map.
-type indexOfInitialisms struct {
- sortMutex *sync.Mutex
- index *sync.Map
-}
-
-func newIndexOfInitialisms() *indexOfInitialisms {
- return &indexOfInitialisms{
- sortMutex: new(sync.Mutex),
- index: new(sync.Map),
- }
-}
-
-func (m *indexOfInitialisms) load(initial map[string]bool) *indexOfInitialisms {
- m.sortMutex.Lock()
- defer m.sortMutex.Unlock()
- for k, v := range initial {
- m.index.Store(k, v)
- }
- return m
-}
-
-func (m *indexOfInitialisms) isInitialism(key string) bool {
- _, ok := m.index.Load(key)
- return ok
-}
-
-func (m *indexOfInitialisms) add(key string) *indexOfInitialisms {
- m.index.Store(key, true)
- return m
-}
-
-func (m *indexOfInitialisms) sorted() (result []string) {
- m.sortMutex.Lock()
- defer m.sortMutex.Unlock()
- m.index.Range(func(key, _ interface{}) bool {
- k := key.(string)
- result = append(result, k)
- return true
- })
- sort.Sort(sort.Reverse(byInitialism(result)))
- return
-}
-
-type byInitialism []string
-
-func (s byInitialism) Len() int {
- return len(s)
-}
-func (s byInitialism) Swap(i, j int) {
- s[i], s[j] = s[j], s[i]
-}
-func (s byInitialism) Less(i, j int) bool {
- if len(s[i]) != len(s[j]) {
- return len(s[i]) < len(s[j])
- }
-
- return strings.Compare(s[i], s[j]) > 0
-}
diff --git a/vendor/github.com/go-openapi/swag/json.go b/vendor/github.com/go-openapi/swag/json.go
deleted file mode 100644
index c7caa990..00000000
--- a/vendor/github.com/go-openapi/swag/json.go
+++ /dev/null
@@ -1,313 +0,0 @@
-// Copyright 2015 go-swagger maintainers
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package swag
-
-import (
- "bytes"
- "encoding/json"
- "log"
- "reflect"
- "strings"
- "sync"
-
- "github.com/mailru/easyjson/jlexer"
- "github.com/mailru/easyjson/jwriter"
-)
-
-// nullJSON represents a JSON object with null type
-var nullJSON = []byte("null")
-
-// DefaultJSONNameProvider the default cache for types
-var DefaultJSONNameProvider = NewNameProvider()
-
-const comma = byte(',')
-
-var closers map[byte]byte
-
-func init() {
- closers = map[byte]byte{
- '{': '}',
- '[': ']',
- }
-}
-
-type ejMarshaler interface {
- MarshalEasyJSON(w *jwriter.Writer)
-}
-
-type ejUnmarshaler interface {
- UnmarshalEasyJSON(w *jlexer.Lexer)
-}
-
-// WriteJSON writes json data, prefers finding an appropriate interface to short-circuit the marshaler
-// so it takes the fastest option available.
-func WriteJSON(data interface{}) ([]byte, error) {
- if d, ok := data.(ejMarshaler); ok {
- jw := new(jwriter.Writer)
- d.MarshalEasyJSON(jw)
- return jw.BuildBytes()
- }
- if d, ok := data.(json.Marshaler); ok {
- return d.MarshalJSON()
- }
- return json.Marshal(data)
-}
-
-// ReadJSON reads json data, prefers finding an appropriate interface to short-circuit the unmarshaler
-// so it takes the fastest option available
-func ReadJSON(data []byte, value interface{}) error {
- trimmedData := bytes.Trim(data, "\x00")
- if d, ok := value.(ejUnmarshaler); ok {
- jl := &jlexer.Lexer{Data: trimmedData}
- d.UnmarshalEasyJSON(jl)
- return jl.Error()
- }
- if d, ok := value.(json.Unmarshaler); ok {
- return d.UnmarshalJSON(trimmedData)
- }
- return json.Unmarshal(trimmedData, value)
-}
-
-// DynamicJSONToStruct converts an untyped json structure into a struct
-func DynamicJSONToStruct(data interface{}, target interface{}) error {
- // TODO: convert straight to a json typed map (mergo + iterate?)
- b, err := WriteJSON(data)
- if err != nil {
- return err
- }
- return ReadJSON(b, target)
-}
-
-// ConcatJSON concatenates multiple json objects efficiently
-func ConcatJSON(blobs ...[]byte) []byte {
- if len(blobs) == 0 {
- return nil
- }
-
- last := len(blobs) - 1
- for blobs[last] == nil || bytes.Equal(blobs[last], nullJSON) {
- // strips trailing null objects
- last--
- if last < 0 {
- // there was nothing but "null"s or nil...
- return nil
- }
- }
- if last == 0 {
- return blobs[0]
- }
-
- var opening, closing byte
- var idx, a int
- buf := bytes.NewBuffer(nil)
-
- for i, b := range blobs[:last+1] {
- if b == nil || bytes.Equal(b, nullJSON) {
- // a null object is in the list: skip it
- continue
- }
- if len(b) > 0 && opening == 0 { // is this an array or an object?
- opening, closing = b[0], closers[b[0]]
- }
-
- if opening != '{' && opening != '[' {
- continue // don't know how to concatenate non container objects
- }
-
- const minLengthIfNotEmpty = 3
- if len(b) < minLengthIfNotEmpty { // yep empty but also the last one, so closing this thing
- if i == last && a > 0 {
- if err := buf.WriteByte(closing); err != nil {
- log.Println(err)
- }
- }
- continue
- }
-
- idx = 0
- if a > 0 { // we need to join with a comma for everything beyond the first non-empty item
- if err := buf.WriteByte(comma); err != nil {
- log.Println(err)
- }
- idx = 1 // this is not the first or the last so we want to drop the leading bracket
- }
-
- if i != last { // not the last one, strip brackets
- if _, err := buf.Write(b[idx : len(b)-1]); err != nil {
- log.Println(err)
- }
- } else { // last one, strip only the leading bracket
- if _, err := buf.Write(b[idx:]); err != nil {
- log.Println(err)
- }
- }
- a++
- }
- // somehow it ended up being empty, so provide a default value
- if buf.Len() == 0 {
- if err := buf.WriteByte(opening); err != nil {
- log.Println(err)
- }
- if err := buf.WriteByte(closing); err != nil {
- log.Println(err)
- }
- }
- return buf.Bytes()
-}
-
-// ToDynamicJSON turns an object into a properly JSON typed structure
-func ToDynamicJSON(data interface{}) interface{} {
- // TODO: convert straight to a json typed map (mergo + iterate?)
- b, err := json.Marshal(data)
- if err != nil {
- log.Println(err)
- }
- var res interface{}
- if err := json.Unmarshal(b, &res); err != nil {
- log.Println(err)
- }
- return res
-}
-
-// FromDynamicJSON turns an object into a properly JSON typed structure
-func FromDynamicJSON(data, target interface{}) error {
- b, err := json.Marshal(data)
- if err != nil {
- log.Println(err)
- }
- return json.Unmarshal(b, target)
-}
-
-// NameProvider represents an object capable of translating from go property names
-// to json property names
-// This type is thread-safe.
-type NameProvider struct {
- lock *sync.Mutex
- index map[reflect.Type]nameIndex
-}
-
-type nameIndex struct {
- jsonNames map[string]string
- goNames map[string]string
-}
-
-// NewNameProvider creates a new name provider
-func NewNameProvider() *NameProvider {
- return &NameProvider{
- lock: &sync.Mutex{},
- index: make(map[reflect.Type]nameIndex),
- }
-}
-
-func buildnameIndex(tpe reflect.Type, idx, reverseIdx map[string]string) {
- for i := 0; i < tpe.NumField(); i++ {
- targetDes := tpe.Field(i)
-
- if targetDes.PkgPath != "" { // unexported
- continue
- }
-
- if targetDes.Anonymous { // walk embedded structures tree down first
- buildnameIndex(targetDes.Type, idx, reverseIdx)
- continue
- }
-
- if tag := targetDes.Tag.Get("json"); tag != "" {
-
- parts := strings.Split(tag, ",")
- if len(parts) == 0 {
- continue
- }
-
- nm := parts[0]
- if nm == "-" {
- continue
- }
- if nm == "" { // empty string means we want to use the Go name
- nm = targetDes.Name
- }
-
- idx[nm] = targetDes.Name
- reverseIdx[targetDes.Name] = nm
- }
- }
-}
-
-func newNameIndex(tpe reflect.Type) nameIndex {
- var idx = make(map[string]string, tpe.NumField())
- var reverseIdx = make(map[string]string, tpe.NumField())
-
- buildnameIndex(tpe, idx, reverseIdx)
- return nameIndex{jsonNames: idx, goNames: reverseIdx}
-}
-
-// GetJSONNames gets all the json property names for a type
-func (n *NameProvider) GetJSONNames(subject interface{}) []string {
- n.lock.Lock()
- defer n.lock.Unlock()
- tpe := reflect.Indirect(reflect.ValueOf(subject)).Type()
- names, ok := n.index[tpe]
- if !ok {
- names = n.makeNameIndex(tpe)
- }
-
- res := make([]string, 0, len(names.jsonNames))
- for k := range names.jsonNames {
- res = append(res, k)
- }
- return res
-}
-
-// GetJSONName gets the json name for a go property name
-func (n *NameProvider) GetJSONName(subject interface{}, name string) (string, bool) {
- tpe := reflect.Indirect(reflect.ValueOf(subject)).Type()
- return n.GetJSONNameForType(tpe, name)
-}
-
-// GetJSONNameForType gets the json name for a go property name on a given type
-func (n *NameProvider) GetJSONNameForType(tpe reflect.Type, name string) (string, bool) {
- n.lock.Lock()
- defer n.lock.Unlock()
- names, ok := n.index[tpe]
- if !ok {
- names = n.makeNameIndex(tpe)
- }
- nme, ok := names.goNames[name]
- return nme, ok
-}
-
-func (n *NameProvider) makeNameIndex(tpe reflect.Type) nameIndex {
- names := newNameIndex(tpe)
- n.index[tpe] = names
- return names
-}
-
-// GetGoName gets the go name for a json property name
-func (n *NameProvider) GetGoName(subject interface{}, name string) (string, bool) {
- tpe := reflect.Indirect(reflect.ValueOf(subject)).Type()
- return n.GetGoNameForType(tpe, name)
-}
-
-// GetGoNameForType gets the go name for a given type for a json property name
-func (n *NameProvider) GetGoNameForType(tpe reflect.Type, name string) (string, bool) {
- n.lock.Lock()
- defer n.lock.Unlock()
- names, ok := n.index[tpe]
- if !ok {
- names = n.makeNameIndex(tpe)
- }
- nme, ok := names.jsonNames[name]
- return nme, ok
-}
diff --git a/vendor/github.com/go-openapi/swag/jsonname/LICENSE b/vendor/github.com/go-openapi/swag/jsonname/LICENSE
new file mode 100644
index 00000000..d6456956
--- /dev/null
+++ b/vendor/github.com/go-openapi/swag/jsonname/LICENSE
@@ -0,0 +1,202 @@
+
+ Apache License
+ Version 2.0, January 2004
+ http://www.apache.org/licenses/
+
+ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+ 1. Definitions.
+
+ "License" shall mean the terms and conditions for use, reproduction,
+ and distribution as defined by Sections 1 through 9 of this document.
+
+ "Licensor" shall mean the copyright owner or entity authorized by
+ the copyright owner that is granting the License.
+
+ "Legal Entity" shall mean the union of the acting entity and all
+ other entities that control, are controlled by, or are under common
+ control with that entity. For the purposes of this definition,
+ "control" means (i) the power, direct or indirect, to cause the
+ direction or management of such entity, whether by contract or
+ otherwise, or (ii) ownership of fifty percent (50%) or more of the
+ outstanding shares, or (iii) beneficial ownership of such entity.
+
+ "You" (or "Your") shall mean an individual or Legal Entity
+ exercising permissions granted by this License.
+
+ "Source" form shall mean the preferred form for making modifications,
+ including but not limited to software source code, documentation
+ source, and configuration files.
+
+ "Object" form shall mean any form resulting from mechanical
+ transformation or translation of a Source form, including but
+ not limited to compiled object code, generated documentation,
+ and conversions to other media types.
+
+ "Work" shall mean the work of authorship, whether in Source or
+ Object form, made available under the License, as indicated by a
+ copyright notice that is included in or attached to the work
+ (an example is provided in the Appendix below).
+
+ "Derivative Works" shall mean any work, whether in Source or Object
+ form, that is based on (or derived from) the Work and for which the
+ editorial revisions, annotations, elaborations, or other modifications
+ represent, as a whole, an original work of authorship. For the purposes
+ of this License, Derivative Works shall not include works that remain
+ separable from, or merely link (or bind by name) to the interfaces of,
+ the Work and Derivative Works thereof.
+
+ "Contribution" shall mean any work of authorship, including
+ the original version of the Work and any modifications or additions
+ to that Work or Derivative Works thereof, that is intentionally
+ submitted to Licensor for inclusion in the Work by the copyright owner
+ or by an individual or Legal Entity authorized to submit on behalf of
+ the copyright owner. For the purposes of this definition, "submitted"
+ means any form of electronic, verbal, or written communication sent
+ to the Licensor or its representatives, including but not limited to
+ communication on electronic mailing lists, source code control systems,
+ and issue tracking systems that are managed by, or on behalf of, the
+ Licensor for the purpose of discussing and improving the Work, but
+ excluding communication that is conspicuously marked or otherwise
+ designated in writing by the copyright owner as "Not a Contribution."
+
+ "Contributor" shall mean Licensor and any individual or Legal Entity
+ on behalf of whom a Contribution has been received by Licensor and
+ subsequently incorporated within the Work.
+
+ 2. Grant of Copyright License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ copyright license to reproduce, prepare Derivative Works of,
+ publicly display, publicly perform, sublicense, and distribute the
+ Work and such Derivative Works in Source or Object form.
+
+ 3. Grant of Patent License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ (except as stated in this section) patent license to make, have made,
+ use, offer to sell, sell, import, and otherwise transfer the Work,
+ where such license applies only to those patent claims licensable
+ by such Contributor that are necessarily infringed by their
+ Contribution(s) alone or by combination of their Contribution(s)
+ with the Work to which such Contribution(s) was submitted. If You
+ institute patent litigation against any entity (including a
+ cross-claim or counterclaim in a lawsuit) alleging that the Work
+ or a Contribution incorporated within the Work constitutes direct
+ or contributory patent infringement, then any patent licenses
+ granted to You under this License for that Work shall terminate
+ as of the date such litigation is filed.
+
+ 4. Redistribution. You may reproduce and distribute copies of the
+ Work or Derivative Works thereof in any medium, with or without
+ modifications, and in Source or Object form, provided that You
+ meet the following conditions:
+
+ (a) You must give any other recipients of the Work or
+ Derivative Works a copy of this License; and
+
+ (b) You must cause any modified files to carry prominent notices
+ stating that You changed the files; and
+
+ (c) You must retain, in the Source form of any Derivative Works
+ that You distribute, all copyright, patent, trademark, and
+ attribution notices from the Source form of the Work,
+ excluding those notices that do not pertain to any part of
+ the Derivative Works; and
+
+ (d) If the Work includes a "NOTICE" text file as part of its
+ distribution, then any Derivative Works that You distribute must
+ include a readable copy of the attribution notices contained
+ within such NOTICE file, excluding those notices that do not
+ pertain to any part of the Derivative Works, in at least one
+ of the following places: within a NOTICE text file distributed
+ as part of the Derivative Works; within the Source form or
+ documentation, if provided along with the Derivative Works; or,
+ within a display generated by the Derivative Works, if and
+ wherever such third-party notices normally appear. The contents
+ of the NOTICE file are for informational purposes only and
+ do not modify the License. You may add Your own attribution
+ notices within Derivative Works that You distribute, alongside
+ or as an addendum to the NOTICE text from the Work, provided
+ that such additional attribution notices cannot be construed
+ as modifying the License.
+
+ You may add Your own copyright statement to Your modifications and
+ may provide additional or different license terms and conditions
+ for use, reproduction, or distribution of Your modifications, or
+ for any such Derivative Works as a whole, provided Your use,
+ reproduction, and distribution of the Work otherwise complies with
+ the conditions stated in this License.
+
+ 5. Submission of Contributions. Unless You explicitly state otherwise,
+ any Contribution intentionally submitted for inclusion in the Work
+ by You to the Licensor shall be under the terms and conditions of
+ this License, without any additional terms or conditions.
+ Notwithstanding the above, nothing herein shall supersede or modify
+ the terms of any separate license agreement you may have executed
+ with Licensor regarding such Contributions.
+
+ 6. Trademarks. This License does not grant permission to use the trade
+ names, trademarks, service marks, or product names of the Licensor,
+ except as required for reasonable and customary use in describing the
+ origin of the Work and reproducing the content of the NOTICE file.
+
+ 7. Disclaimer of Warranty. Unless required by applicable law or
+ agreed to in writing, Licensor provides the Work (and each
+ Contributor provides its Contributions) on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ implied, including, without limitation, any warranties or conditions
+ of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+ PARTICULAR PURPOSE. You are solely responsible for determining the
+ appropriateness of using or redistributing the Work and assume any
+ risks associated with Your exercise of permissions under this License.
+
+ 8. Limitation of Liability. In no event and under no legal theory,
+ whether in tort (including negligence), contract, or otherwise,
+ unless required by applicable law (such as deliberate and grossly
+ negligent acts) or agreed to in writing, shall any Contributor be
+ liable to You for damages, including any direct, indirect, special,
+ incidental, or consequential damages of any character arising as a
+ result of this License or out of the use or inability to use the
+ Work (including but not limited to damages for loss of goodwill,
+ work stoppage, computer failure or malfunction, or any and all
+ other commercial damages or losses), even if such Contributor
+ has been advised of the possibility of such damages.
+
+ 9. Accepting Warranty or Additional Liability. While redistributing
+ the Work or Derivative Works thereof, You may choose to offer,
+ and charge a fee for, acceptance of support, warranty, indemnity,
+ or other liability obligations and/or rights consistent with this
+ License. However, in accepting such obligations, You may act only
+ on Your own behalf and on Your sole responsibility, not on behalf
+ of any other Contributor, and only if You agree to indemnify,
+ defend, and hold each Contributor harmless for any liability
+ incurred by, or claims asserted against, such Contributor by reason
+ of your accepting any such warranty or additional liability.
+
+ END OF TERMS AND CONDITIONS
+
+ APPENDIX: How to apply the Apache License to your work.
+
+ To apply the Apache License to your work, attach the following
+ boilerplate notice, with the fields enclosed by brackets "[]"
+ replaced with your own identifying information. (Don't include
+ the brackets!) The text should be enclosed in the appropriate
+ comment syntax for the file format. We also recommend that a
+ file or class name and description of purpose be included on the
+ same "printed page" as the copyright notice for easier
+ identification within third-party archives.
+
+ Copyright [yyyy] [name of copyright owner]
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
diff --git a/vendor/github.com/go-openapi/swag/jsonname/doc.go b/vendor/github.com/go-openapi/swag/jsonname/doc.go
new file mode 100644
index 00000000..79232eac
--- /dev/null
+++ b/vendor/github.com/go-openapi/swag/jsonname/doc.go
@@ -0,0 +1,5 @@
+// SPDX-FileCopyrightText: Copyright 2015-2025 go-swagger maintainers
+// SPDX-License-Identifier: Apache-2.0
+
+// Package jsonname is a provider of json property names from go properties.
+package jsonname
diff --git a/vendor/github.com/go-openapi/swag/jsonname/name_provider.go b/vendor/github.com/go-openapi/swag/jsonname/name_provider.go
new file mode 100644
index 00000000..8eaf1bec
--- /dev/null
+++ b/vendor/github.com/go-openapi/swag/jsonname/name_provider.go
@@ -0,0 +1,138 @@
+// SPDX-FileCopyrightText: Copyright 2015-2025 go-swagger maintainers
+// SPDX-License-Identifier: Apache-2.0
+
+package jsonname
+
+import (
+ "reflect"
+ "strings"
+ "sync"
+)
+
+// DefaultJSONNameProvider is the default cache for types.
+var DefaultJSONNameProvider = NewNameProvider()
+
+// NameProvider represents an object capable of translating from go property names
+// to json property names.
+//
+// This type is thread-safe.
+//
+// See [github.com/go-openapi/jsonpointer.Pointer] for an example.
+type NameProvider struct {
+ lock *sync.Mutex
+ index map[reflect.Type]nameIndex
+}
+
+type nameIndex struct {
+ jsonNames map[string]string
+ goNames map[string]string
+}
+
+// NewNameProvider creates a new name provider
+func NewNameProvider() *NameProvider {
+ return &NameProvider{
+ lock: &sync.Mutex{},
+ index: make(map[reflect.Type]nameIndex),
+ }
+}
+
+func buildnameIndex(tpe reflect.Type, idx, reverseIdx map[string]string) {
+ for i := 0; i < tpe.NumField(); i++ {
+ targetDes := tpe.Field(i)
+
+ if targetDes.PkgPath != "" { // unexported
+ continue
+ }
+
+ if targetDes.Anonymous { // walk embedded structures tree down first
+ buildnameIndex(targetDes.Type, idx, reverseIdx)
+ continue
+ }
+
+ if tag := targetDes.Tag.Get("json"); tag != "" {
+
+ parts := strings.Split(tag, ",")
+ if len(parts) == 0 {
+ continue
+ }
+
+ nm := parts[0]
+ if nm == "-" {
+ continue
+ }
+ if nm == "" { // empty string means we want to use the Go name
+ nm = targetDes.Name
+ }
+
+ idx[nm] = targetDes.Name
+ reverseIdx[targetDes.Name] = nm
+ }
+ }
+}
+
+func newNameIndex(tpe reflect.Type) nameIndex {
+ var idx = make(map[string]string, tpe.NumField())
+ var reverseIdx = make(map[string]string, tpe.NumField())
+
+ buildnameIndex(tpe, idx, reverseIdx)
+ return nameIndex{jsonNames: idx, goNames: reverseIdx}
+}
+
+// GetJSONNames gets all the json property names for a type
+func (n *NameProvider) GetJSONNames(subject any) []string {
+ n.lock.Lock()
+ defer n.lock.Unlock()
+ tpe := reflect.Indirect(reflect.ValueOf(subject)).Type()
+ names, ok := n.index[tpe]
+ if !ok {
+ names = n.makeNameIndex(tpe)
+ }
+
+ res := make([]string, 0, len(names.jsonNames))
+ for k := range names.jsonNames {
+ res = append(res, k)
+ }
+ return res
+}
+
+// GetJSONName gets the json name for a go property name
+func (n *NameProvider) GetJSONName(subject any, name string) (string, bool) {
+ tpe := reflect.Indirect(reflect.ValueOf(subject)).Type()
+ return n.GetJSONNameForType(tpe, name)
+}
+
+// GetJSONNameForType gets the json name for a go property name on a given type
+func (n *NameProvider) GetJSONNameForType(tpe reflect.Type, name string) (string, bool) {
+ n.lock.Lock()
+ defer n.lock.Unlock()
+ names, ok := n.index[tpe]
+ if !ok {
+ names = n.makeNameIndex(tpe)
+ }
+ nme, ok := names.goNames[name]
+ return nme, ok
+}
+
+// GetGoName gets the go name for a json property name
+func (n *NameProvider) GetGoName(subject any, name string) (string, bool) {
+ tpe := reflect.Indirect(reflect.ValueOf(subject)).Type()
+ return n.GetGoNameForType(tpe, name)
+}
+
+// GetGoNameForType gets the go name for a given type for a json property name
+func (n *NameProvider) GetGoNameForType(tpe reflect.Type, name string) (string, bool) {
+ n.lock.Lock()
+ defer n.lock.Unlock()
+ names, ok := n.index[tpe]
+ if !ok {
+ names = n.makeNameIndex(tpe)
+ }
+ nme, ok := names.jsonNames[name]
+ return nme, ok
+}
+
+func (n *NameProvider) makeNameIndex(tpe reflect.Type) nameIndex {
+ names := newNameIndex(tpe)
+ n.index[tpe] = names
+ return names
+}
diff --git a/vendor/github.com/go-openapi/swag/jsonutils/LICENSE b/vendor/github.com/go-openapi/swag/jsonutils/LICENSE
new file mode 100644
index 00000000..d6456956
--- /dev/null
+++ b/vendor/github.com/go-openapi/swag/jsonutils/LICENSE
@@ -0,0 +1,202 @@
+
+ Apache License
+ Version 2.0, January 2004
+ http://www.apache.org/licenses/
+
+ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+ 1. Definitions.
+
+ "License" shall mean the terms and conditions for use, reproduction,
+ and distribution as defined by Sections 1 through 9 of this document.
+
+ "Licensor" shall mean the copyright owner or entity authorized by
+ the copyright owner that is granting the License.
+
+ "Legal Entity" shall mean the union of the acting entity and all
+ other entities that control, are controlled by, or are under common
+ control with that entity. For the purposes of this definition,
+ "control" means (i) the power, direct or indirect, to cause the
+ direction or management of such entity, whether by contract or
+ otherwise, or (ii) ownership of fifty percent (50%) or more of the
+ outstanding shares, or (iii) beneficial ownership of such entity.
+
+ "You" (or "Your") shall mean an individual or Legal Entity
+ exercising permissions granted by this License.
+
+ "Source" form shall mean the preferred form for making modifications,
+ including but not limited to software source code, documentation
+ source, and configuration files.
+
+ "Object" form shall mean any form resulting from mechanical
+ transformation or translation of a Source form, including but
+ not limited to compiled object code, generated documentation,
+ and conversions to other media types.
+
+ "Work" shall mean the work of authorship, whether in Source or
+ Object form, made available under the License, as indicated by a
+ copyright notice that is included in or attached to the work
+ (an example is provided in the Appendix below).
+
+ "Derivative Works" shall mean any work, whether in Source or Object
+ form, that is based on (or derived from) the Work and for which the
+ editorial revisions, annotations, elaborations, or other modifications
+ represent, as a whole, an original work of authorship. For the purposes
+ of this License, Derivative Works shall not include works that remain
+ separable from, or merely link (or bind by name) to the interfaces of,
+ the Work and Derivative Works thereof.
+
+ "Contribution" shall mean any work of authorship, including
+ the original version of the Work and any modifications or additions
+ to that Work or Derivative Works thereof, that is intentionally
+ submitted to Licensor for inclusion in the Work by the copyright owner
+ or by an individual or Legal Entity authorized to submit on behalf of
+ the copyright owner. For the purposes of this definition, "submitted"
+ means any form of electronic, verbal, or written communication sent
+ to the Licensor or its representatives, including but not limited to
+ communication on electronic mailing lists, source code control systems,
+ and issue tracking systems that are managed by, or on behalf of, the
+ Licensor for the purpose of discussing and improving the Work, but
+ excluding communication that is conspicuously marked or otherwise
+ designated in writing by the copyright owner as "Not a Contribution."
+
+ "Contributor" shall mean Licensor and any individual or Legal Entity
+ on behalf of whom a Contribution has been received by Licensor and
+ subsequently incorporated within the Work.
+
+ 2. Grant of Copyright License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ copyright license to reproduce, prepare Derivative Works of,
+ publicly display, publicly perform, sublicense, and distribute the
+ Work and such Derivative Works in Source or Object form.
+
+ 3. Grant of Patent License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ (except as stated in this section) patent license to make, have made,
+ use, offer to sell, sell, import, and otherwise transfer the Work,
+ where such license applies only to those patent claims licensable
+ by such Contributor that are necessarily infringed by their
+ Contribution(s) alone or by combination of their Contribution(s)
+ with the Work to which such Contribution(s) was submitted. If You
+ institute patent litigation against any entity (including a
+ cross-claim or counterclaim in a lawsuit) alleging that the Work
+ or a Contribution incorporated within the Work constitutes direct
+ or contributory patent infringement, then any patent licenses
+ granted to You under this License for that Work shall terminate
+ as of the date such litigation is filed.
+
+ 4. Redistribution. You may reproduce and distribute copies of the
+ Work or Derivative Works thereof in any medium, with or without
+ modifications, and in Source or Object form, provided that You
+ meet the following conditions:
+
+ (a) You must give any other recipients of the Work or
+ Derivative Works a copy of this License; and
+
+ (b) You must cause any modified files to carry prominent notices
+ stating that You changed the files; and
+
+ (c) You must retain, in the Source form of any Derivative Works
+ that You distribute, all copyright, patent, trademark, and
+ attribution notices from the Source form of the Work,
+ excluding those notices that do not pertain to any part of
+ the Derivative Works; and
+
+ (d) If the Work includes a "NOTICE" text file as part of its
+ distribution, then any Derivative Works that You distribute must
+ include a readable copy of the attribution notices contained
+ within such NOTICE file, excluding those notices that do not
+ pertain to any part of the Derivative Works, in at least one
+ of the following places: within a NOTICE text file distributed
+ as part of the Derivative Works; within the Source form or
+ documentation, if provided along with the Derivative Works; or,
+ within a display generated by the Derivative Works, if and
+ wherever such third-party notices normally appear. The contents
+ of the NOTICE file are for informational purposes only and
+ do not modify the License. You may add Your own attribution
+ notices within Derivative Works that You distribute, alongside
+ or as an addendum to the NOTICE text from the Work, provided
+ that such additional attribution notices cannot be construed
+ as modifying the License.
+
+ You may add Your own copyright statement to Your modifications and
+ may provide additional or different license terms and conditions
+ for use, reproduction, or distribution of Your modifications, or
+ for any such Derivative Works as a whole, provided Your use,
+ reproduction, and distribution of the Work otherwise complies with
+ the conditions stated in this License.
+
+ 5. Submission of Contributions. Unless You explicitly state otherwise,
+ any Contribution intentionally submitted for inclusion in the Work
+ by You to the Licensor shall be under the terms and conditions of
+ this License, without any additional terms or conditions.
+ Notwithstanding the above, nothing herein shall supersede or modify
+ the terms of any separate license agreement you may have executed
+ with Licensor regarding such Contributions.
+
+ 6. Trademarks. This License does not grant permission to use the trade
+ names, trademarks, service marks, or product names of the Licensor,
+ except as required for reasonable and customary use in describing the
+ origin of the Work and reproducing the content of the NOTICE file.
+
+ 7. Disclaimer of Warranty. Unless required by applicable law or
+ agreed to in writing, Licensor provides the Work (and each
+ Contributor provides its Contributions) on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ implied, including, without limitation, any warranties or conditions
+ of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+ PARTICULAR PURPOSE. You are solely responsible for determining the
+ appropriateness of using or redistributing the Work and assume any
+ risks associated with Your exercise of permissions under this License.
+
+ 8. Limitation of Liability. In no event and under no legal theory,
+ whether in tort (including negligence), contract, or otherwise,
+ unless required by applicable law (such as deliberate and grossly
+ negligent acts) or agreed to in writing, shall any Contributor be
+ liable to You for damages, including any direct, indirect, special,
+ incidental, or consequential damages of any character arising as a
+ result of this License or out of the use or inability to use the
+ Work (including but not limited to damages for loss of goodwill,
+ work stoppage, computer failure or malfunction, or any and all
+ other commercial damages or losses), even if such Contributor
+ has been advised of the possibility of such damages.
+
+ 9. Accepting Warranty or Additional Liability. While redistributing
+ the Work or Derivative Works thereof, You may choose to offer,
+ and charge a fee for, acceptance of support, warranty, indemnity,
+ or other liability obligations and/or rights consistent with this
+ License. However, in accepting such obligations, You may act only
+ on Your own behalf and on Your sole responsibility, not on behalf
+ of any other Contributor, and only if You agree to indemnify,
+ defend, and hold each Contributor harmless for any liability
+ incurred by, or claims asserted against, such Contributor by reason
+ of your accepting any such warranty or additional liability.
+
+ END OF TERMS AND CONDITIONS
+
+ APPENDIX: How to apply the Apache License to your work.
+
+ To apply the Apache License to your work, attach the following
+ boilerplate notice, with the fields enclosed by brackets "[]"
+ replaced with your own identifying information. (Don't include
+ the brackets!) The text should be enclosed in the appropriate
+ comment syntax for the file format. We also recommend that a
+ file or class name and description of purpose be included on the
+ same "printed page" as the copyright notice for easier
+ identification within third-party archives.
+
+ Copyright [yyyy] [name of copyright owner]
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
diff --git a/vendor/github.com/go-openapi/swag/jsonutils/README.md b/vendor/github.com/go-openapi/swag/jsonutils/README.md
new file mode 100644
index 00000000..d745cdb4
--- /dev/null
+++ b/vendor/github.com/go-openapi/swag/jsonutils/README.md
@@ -0,0 +1,108 @@
+ # jsonutils
+
+`jsonutils` exposes a few tools to work with JSON:
+
+- a fast, simple `Concat` to concatenate (not merge) JSON objects and arrays
+- `FromDynamicJSON` to convert a data structure into a "dynamic JSON" data structure
+- `ReadJSON` and `WriteJSON` behave like `json.Unmarshal` and `json.Marshal`,
+ with the ability to use another underlying serialization library through an `Adapter`
+ configured at runtime
+- a `JSONMapSlice` structure that may be used to store JSON objects with the order of keys maintained
+
+## Dynamic JSON
+
+We call "dynamic JSON" the go data structure that results from unmarshaling JSON like this:
+
+```go
+ var value any
+ jsonBytes := `{"a": 1, ... }`
+ _ = json.Unmarshal(jsonBytes, &value)
+```
+
+In this configuration, the standard library mappings are as follows:
+
+| JSON | go |
+|-----------|------------------|
+| `number` | `float64` |
+| `string` | `string` |
+| `boolean` | `bool` |
+| `null` | `nil` |
+| `object` | `map[string]any` |
+| `array` | `[]any` |
+
+## Map slices
+
+When using `JSONMapSlice`, the ordering of keys is ensured by replacing
+mappings to `map[string]any` by a `JSONMapSlice` which is an (ordered)
+slice of `JSONMapItem`s.
+
+Notice that a similar feature is available for YAML (see [`yamlutils`](../yamlutils)),
+with a `YAMLMapSlice` type based on the `JSONMapSlice`.
+
+`JSONMapSlice` is similar to an ordered map, but the keys are not retrieved
+in constant time.
+
+Another difference with the the above standard mappings is that numbers don't always map
+to a `float64`: if the value is a JSON integer, it unmarshals to `int64`.
+
+See also [some examples](https://pkg.go.dev/github.com/go-openapi/swag/jsonutils#pkg-examples)
+
+## Adapters
+
+`ReadJSON`, `WriteJSON` and `FromDynamicJSON` (which is a combination of the latter two)
+are wrappers on top of `json.Unmarshal` and `json.Marshal`.
+
+By default, the adapter merely wraps the standard library.
+
+The adapter may be used to register other JSON serialization libraries,
+possibly several ones at the same time.
+
+If the value passed is identified as an "ordered map" (i.e. implements `ifaces.Ordered`
+or `ifaces.SetOrdered`, the adapter favors the "ordered" JSON behavior and tries to
+find a registered implementation that support ordered keys in objects.
+
+Our standard library implementation supports this.
+
+As of `v0.25.0`, we support through such an adapter the popular `mailru/easyjson`
+library, which kicks in when the passed values support the `easyjson.Unmarshaler`
+or `easyjson.Marshaler` interfaces.
+
+In the future, we plan to add more similar libraries that compete on the go JSON
+serializers scene.
+
+## Registering an adapter
+
+In package `github.com/go-openapi/swag/easyjson/adapters`, several adapters are available.
+
+Each adapter is an independent go module. Hence you'll pick its dependencies only if you import it.
+
+At this moment we provide:
+* `stdlib`: JSON adapter based on the standard library
+* `easyjson`: JSON adapter based on the `github.com/mailru/easyjson`
+
+The adapters provide the basic `Marshal` and `Unmarshal` capabilities, plus an implementation
+of the `MapSlice` pattern.
+
+You may also build your own adapter based on your specific use-case. An adapter is not required to implement
+all capabilities.
+
+Every adapter comes with a `Register` function, possibly with some options, to register the adapter
+to a global registry.
+
+For example, to enable `easyjson` to be used in `ReadJSON` and `WriteJSON`, you would write something like:
+
+```go
+ import (
+ "github.com/go-openapi/swag/jsonutils/adapters"
+ easyjson "github.com/go-openapi/swag/jsonutils/adapters/easyjson/json"
+ )
+
+ func init() {
+ easyjson.Register(adapters.Registry)
+ }
+```
+
+You may register several adapters. In this case, capability matching is evaluated from the last registered
+adapters (LIFO).
+
+## [Benchmarks](./adapters/testintegration/benchmarks/README.md)
diff --git a/vendor/github.com/go-openapi/swag/jsonutils/adapters/doc.go b/vendor/github.com/go-openapi/swag/jsonutils/adapters/doc.go
new file mode 100644
index 00000000..76d3898f
--- /dev/null
+++ b/vendor/github.com/go-openapi/swag/jsonutils/adapters/doc.go
@@ -0,0 +1,8 @@
+// SPDX-FileCopyrightText: Copyright 2015-2025 go-swagger maintainers
+// SPDX-License-Identifier: Apache-2.0
+
+// Package adapters exposes a registry of adapters to multiple
+// JSON serialization libraries.
+//
+// All interfaces are defined in package [ifaces.Adapter].
+package adapters
diff --git a/vendor/github.com/go-openapi/swag/jsonutils/adapters/ifaces/doc.go b/vendor/github.com/go-openapi/swag/jsonutils/adapters/ifaces/doc.go
new file mode 100644
index 00000000..1fd43a1f
--- /dev/null
+++ b/vendor/github.com/go-openapi/swag/jsonutils/adapters/ifaces/doc.go
@@ -0,0 +1,5 @@
+// SPDX-FileCopyrightText: Copyright 2015-2025 go-swagger maintainers
+// SPDX-License-Identifier: Apache-2.0
+
+// Package ifaces exposes all interfaces to work with adapters.
+package ifaces
diff --git a/vendor/github.com/go-openapi/swag/jsonutils/adapters/ifaces/ifaces.go b/vendor/github.com/go-openapi/swag/jsonutils/adapters/ifaces/ifaces.go
new file mode 100644
index 00000000..7805e5e5
--- /dev/null
+++ b/vendor/github.com/go-openapi/swag/jsonutils/adapters/ifaces/ifaces.go
@@ -0,0 +1,84 @@
+// SPDX-FileCopyrightText: Copyright 2015-2025 go-swagger maintainers
+// SPDX-License-Identifier: Apache-2.0
+
+package ifaces
+
+import (
+ _ "encoding/json" // for documentation purpose
+ "iter"
+)
+
+// Ordered knows how to iterate over the (key,value) pairs of a JSON object.
+type Ordered interface {
+ OrderedItems() iter.Seq2[string, any]
+}
+
+// SetOrdered knows how to append or update the keys of a JSON object,
+// given an iterator over (key,value) pairs.
+//
+// If the provided iterator is nil then the receiver should be set to nil.
+type SetOrdered interface {
+ SetOrderedItems(iter.Seq2[string, any])
+}
+
+// OrderedMap represent a JSON object (i.e. like a map[string,any]),
+// and knows how to serialize and deserialize JSON with the order of keys maintained.
+type OrderedMap interface {
+ Ordered
+ SetOrdered
+
+ OrderedMarshalJSON() ([]byte, error)
+ OrderedUnmarshalJSON([]byte) error
+}
+
+// MarshalAdapter behaves likes the standard library [json.Marshal].
+type MarshalAdapter interface {
+ Poolable
+
+ Marshal(any) ([]byte, error)
+}
+
+// OrderedMarshalAdapter behaves likes the standard library [json.Marshal], preserving the order of keys in objects.
+type OrderedMarshalAdapter interface {
+ Poolable
+
+ OrderedMarshal(Ordered) ([]byte, error)
+}
+
+// UnmarshalAdapter behaves likes the standard library [json.Unmarshal].
+type UnmarshalAdapter interface {
+ Poolable
+
+ Unmarshal([]byte, any) error
+}
+
+// OrderedUnmarshalAdapter behaves likes the standard library [json.Unmarshal], preserving the order of keys in objects.
+type OrderedUnmarshalAdapter interface {
+ Poolable
+
+ OrderedUnmarshal([]byte, SetOrdered) error
+}
+
+// Adapter exposes an interface like the standard [json] library.
+type Adapter interface {
+ MarshalAdapter
+ UnmarshalAdapter
+
+ OrderedAdapter
+}
+
+// OrderedAdapter exposes interfaces to process JSON and keep the order of object keys.
+type OrderedAdapter interface {
+ OrderedMarshalAdapter
+ OrderedUnmarshalAdapter
+ NewOrderedMap(capacity int) OrderedMap
+}
+
+type Poolable interface {
+ // Self-redeem: for [Adapter] s that are allocated from a pool.
+ // The [Adapter] must not be used after calling [Redeem].
+ Redeem()
+
+ // Reset the state of the [Adapter], if any.
+ Reset()
+}
diff --git a/vendor/github.com/go-openapi/swag/jsonutils/adapters/ifaces/registry_iface.go b/vendor/github.com/go-openapi/swag/jsonutils/adapters/ifaces/registry_iface.go
new file mode 100644
index 00000000..2d6c69f4
--- /dev/null
+++ b/vendor/github.com/go-openapi/swag/jsonutils/adapters/ifaces/registry_iface.go
@@ -0,0 +1,91 @@
+// SPDX-FileCopyrightText: Copyright 2015-2025 go-swagger maintainers
+// SPDX-License-Identifier: Apache-2.0
+
+package ifaces
+
+import (
+ "strings"
+)
+
+// Capability indicates what a JSON adapter is capable of.
+type Capability uint8
+
+const (
+ CapabilityMarshalJSON Capability = 1 << iota
+ CapabilityUnmarshalJSON
+ CapabilityOrderedMarshalJSON
+ CapabilityOrderedUnmarshalJSON
+ CapabilityOrderedMap
+)
+
+func (c Capability) String() string {
+ switch c {
+ case CapabilityMarshalJSON:
+ return "MarshalJSON"
+ case CapabilityUnmarshalJSON:
+ return "UnmarshalJSON"
+ case CapabilityOrderedMarshalJSON:
+ return "OrderedMarshalJSON"
+ case CapabilityOrderedUnmarshalJSON:
+ return "OrderedUnmarshalJSON"
+ case CapabilityOrderedMap:
+ return "OrderedMap"
+ default:
+ return ""
+ }
+}
+
+// Capabilities holds several unitary capability flags
+type Capabilities uint8
+
+// Has some capability flag enabled.
+func (c Capabilities) Has(capability Capability) bool {
+ return Capability(c)&capability > 0
+}
+
+func (c Capabilities) String() string {
+ var w strings.Builder
+
+ first := true
+ for _, capability := range []Capability{
+ CapabilityMarshalJSON,
+ CapabilityUnmarshalJSON,
+ CapabilityOrderedMarshalJSON,
+ CapabilityOrderedUnmarshalJSON,
+ CapabilityOrderedMap,
+ } {
+ if c.Has(capability) {
+ if !first {
+ w.WriteByte('|')
+ } else {
+ first = false
+ }
+ w.WriteString(capability.String())
+ }
+ }
+
+ return w.String()
+}
+
+const (
+ AllCapabilities Capabilities = Capabilities(uint8(CapabilityMarshalJSON) |
+ uint8(CapabilityUnmarshalJSON) |
+ uint8(CapabilityOrderedMarshalJSON) |
+ uint8(CapabilityOrderedUnmarshalJSON) |
+ uint8(CapabilityOrderedMap))
+
+ AllUnorderedCapabilities Capabilities = Capabilities(uint8(CapabilityMarshalJSON) | uint8(CapabilityUnmarshalJSON))
+)
+
+// RegistryEntry describes how any given adapter registers its capabilities to the [Registrar].
+type RegistryEntry struct {
+ Who string
+ What Capabilities
+ Constructor func() Adapter
+ Support func(what Capability, value any) bool
+}
+
+// Registrar is a type that knows how to keep registration calls from adapters.
+type Registrar interface {
+ RegisterFor(RegistryEntry)
+}
diff --git a/vendor/github.com/go-openapi/swag/jsonutils/adapters/registry.go b/vendor/github.com/go-openapi/swag/jsonutils/adapters/registry.go
new file mode 100644
index 00000000..3062acaf
--- /dev/null
+++ b/vendor/github.com/go-openapi/swag/jsonutils/adapters/registry.go
@@ -0,0 +1,229 @@
+// SPDX-FileCopyrightText: Copyright 2015-2025 go-swagger maintainers
+// SPDX-License-Identifier: Apache-2.0
+
+package adapters
+
+import (
+ "fmt"
+ "reflect"
+ "slices"
+ "sync"
+
+ "github.com/go-openapi/swag/jsonutils/adapters/ifaces"
+ stdlib "github.com/go-openapi/swag/jsonutils/adapters/stdlib/json"
+)
+
+// Registry holds the global registry for registered adapters.
+var Registry = NewRegistrar()
+
+var (
+ defaultRegistered = stdlib.Register
+
+ _ ifaces.Registrar = &Registrar{}
+)
+
+type registryError string
+
+func (e registryError) Error() string {
+ return string(e)
+}
+
+// ErrRegistry indicates an error returned by the [Registrar].
+var ErrRegistry registryError = "JSON adapters registry error"
+
+type registry []*ifaces.RegistryEntry
+
+// Registrar holds registered [ifaces.Adapters] for different serialization capabilities.
+//
+// Internally, it maintains a cache for data types that favor a given adapter.
+type Registrar struct {
+ marshalerRegistry registry
+ unmarshalerRegistry registry
+ orderedMarshalerRegistry registry
+ orderedUnmarshalerRegistry registry
+ orderedMapRegistry registry
+
+ gmx sync.RWMutex
+
+ // cache indexed by value type, so we don't have to lookup
+ marshalerCache map[reflect.Type]*ifaces.RegistryEntry
+ unmarshalerCache map[reflect.Type]*ifaces.RegistryEntry
+ orderedMarshalerCache map[reflect.Type]*ifaces.RegistryEntry
+ orderedUnmarshalerCache map[reflect.Type]*ifaces.RegistryEntry
+ orderedMapCache map[reflect.Type]*ifaces.RegistryEntry
+}
+
+func NewRegistrar() *Registrar {
+ r := &Registrar{}
+
+ r.marshalerRegistry = make(registry, 0, 1)
+ r.unmarshalerRegistry = make(registry, 0, 1)
+ r.orderedMarshalerRegistry = make(registry, 0, 1)
+ r.orderedUnmarshalerRegistry = make(registry, 0, 1)
+ r.orderedMapRegistry = make(registry, 0, 1)
+
+ r.marshalerCache = make(map[reflect.Type]*ifaces.RegistryEntry)
+ r.unmarshalerCache = make(map[reflect.Type]*ifaces.RegistryEntry)
+ r.orderedMarshalerCache = make(map[reflect.Type]*ifaces.RegistryEntry)
+ r.orderedUnmarshalerCache = make(map[reflect.Type]*ifaces.RegistryEntry)
+ r.orderedMapCache = make(map[reflect.Type]*ifaces.RegistryEntry)
+
+ defaultRegistered(r)
+
+ return r
+}
+
+// ClearCache resets the internal type cache.
+func (r *Registrar) ClearCache() {
+ r.gmx.Lock()
+ r.clearCache()
+ r.gmx.Unlock()
+}
+
+// Reset the [Registrar] to its defaults.
+func (r *Registrar) Reset() {
+ r.gmx.Lock()
+ r.clearCache()
+ r.marshalerRegistry = r.marshalerRegistry[:0]
+ r.unmarshalerRegistry = r.unmarshalerRegistry[:0]
+ r.orderedMarshalerRegistry = r.orderedMarshalerRegistry[:0]
+ r.orderedUnmarshalerRegistry = r.orderedUnmarshalerRegistry[:0]
+ r.orderedMapRegistry = r.orderedMapRegistry[:0]
+ r.gmx.Unlock()
+
+ defaultRegistered(r)
+}
+
+// RegisterFor registers an adapter for some JSON capabilities.
+func (r *Registrar) RegisterFor(entry ifaces.RegistryEntry) {
+ r.gmx.Lock()
+ if entry.What.Has(ifaces.CapabilityMarshalJSON) {
+ e := entry
+ e.What &= ifaces.Capabilities(ifaces.CapabilityMarshalJSON)
+ r.marshalerRegistry = slices.Insert(r.marshalerRegistry, 0, &e)
+ }
+ if entry.What.Has(ifaces.CapabilityUnmarshalJSON) {
+ e := entry
+ e.What &= ifaces.Capabilities(ifaces.CapabilityUnmarshalJSON)
+ r.unmarshalerRegistry = slices.Insert(r.unmarshalerRegistry, 0, &e)
+ }
+ if entry.What.Has(ifaces.CapabilityOrderedMarshalJSON) {
+ e := entry
+ e.What &= ifaces.Capabilities(ifaces.CapabilityOrderedMarshalJSON)
+ r.orderedMarshalerRegistry = slices.Insert(r.orderedMarshalerRegistry, 0, &e)
+ }
+ if entry.What.Has(ifaces.CapabilityOrderedUnmarshalJSON) {
+ e := entry
+ e.What &= ifaces.Capabilities(ifaces.CapabilityOrderedUnmarshalJSON)
+ r.orderedUnmarshalerRegistry = slices.Insert(r.orderedUnmarshalerRegistry, 0, &e)
+ }
+ if entry.What.Has(ifaces.CapabilityOrderedMap) {
+ e := entry
+ e.What &= ifaces.Capabilities(ifaces.CapabilityOrderedMap)
+ r.orderedMapRegistry = slices.Insert(r.orderedMapRegistry, 0, &e)
+ }
+ r.gmx.Unlock()
+}
+
+// AdapterFor returns an [ifaces.Adapter] that supports this capability for this type of value.
+//
+// The [ifaces.Adapter] may be redeemed to its pool using its Redeem() method, for adapters that support global
+// pooling. When this is not the case, the redeem function is just a no-operation.
+func (r *Registrar) AdapterFor(capability ifaces.Capability, value any) ifaces.Adapter {
+ entry := r.findFirstFor(capability, value)
+ if entry == nil {
+ return nil
+ }
+
+ return entry.Constructor()
+}
+
+func (r *Registrar) clearCache() {
+ clear(r.marshalerCache)
+ clear(r.unmarshalerCache)
+ clear(r.orderedMarshalerCache)
+ clear(r.orderedUnmarshalerCache)
+ clear(r.orderedMapCache)
+}
+
+func (r *Registrar) findFirstFor(capability ifaces.Capability, value any) *ifaces.RegistryEntry {
+ switch capability {
+ case ifaces.CapabilityMarshalJSON:
+ return r.findFirstInRegistryFor(r.marshalerRegistry, r.marshalerCache, capability, value)
+ case ifaces.CapabilityUnmarshalJSON:
+ return r.findFirstInRegistryFor(r.unmarshalerRegistry, r.unmarshalerCache, capability, value)
+ case ifaces.CapabilityOrderedMarshalJSON:
+ return r.findFirstInRegistryFor(r.orderedMarshalerRegistry, r.orderedMarshalerCache, capability, value)
+ case ifaces.CapabilityOrderedUnmarshalJSON:
+ return r.findFirstInRegistryFor(r.orderedUnmarshalerRegistry, r.orderedUnmarshalerCache, capability, value)
+ case ifaces.CapabilityOrderedMap:
+ return r.findFirstInRegistryFor(r.orderedMapRegistry, r.orderedMapCache, capability, value)
+ default:
+ panic(fmt.Errorf("unsupported capability %d: %w", capability, ErrRegistry))
+ }
+}
+
+func (r *Registrar) findFirstInRegistryFor(reg registry, cache map[reflect.Type]*ifaces.RegistryEntry, capability ifaces.Capability, value any) *ifaces.RegistryEntry {
+ r.gmx.RLock()
+ if len(reg) > 1 {
+ if entry, ok := cache[reflect.TypeOf(value)]; ok {
+ // cache hit
+ r.gmx.RUnlock()
+ return entry
+ }
+ }
+
+ for _, entry := range reg {
+ if !entry.Support(capability, value) {
+ continue
+ }
+
+ r.gmx.RUnlock()
+
+ // update the internal cache
+ r.gmx.Lock()
+ cache[reflect.TypeOf(value)] = entry
+ r.gmx.Unlock()
+
+ return entry
+ }
+
+ // no adapter found
+ r.gmx.RUnlock()
+
+ return nil
+}
+
+// MarshalAdapterFor returns the first adapter that knows how to Marshal this type of value.
+func MarshalAdapterFor(value any) ifaces.MarshalAdapter {
+ return Registry.AdapterFor(ifaces.CapabilityMarshalJSON, value)
+}
+
+// OrderedMarshalAdapterFor returns the first adapter that knows how to OrderedMarshal this type of value.
+func OrderedMarshalAdapterFor(value ifaces.Ordered) ifaces.OrderedMarshalAdapter {
+ return Registry.AdapterFor(ifaces.CapabilityOrderedMarshalJSON, value)
+}
+
+// UnmarshalAdapterFor returns the first adapter that knows how to Unmarshal this type of value.
+func UnmarshalAdapterFor(value any) ifaces.UnmarshalAdapter {
+ return Registry.AdapterFor(ifaces.CapabilityUnmarshalJSON, value)
+}
+
+// OrderedUnmarshalAdapterFor provides the first adapter that knows how to OrderedUnmarshal this type of value.
+func OrderedUnmarshalAdapterFor(value ifaces.SetOrdered) ifaces.OrderedUnmarshalAdapter {
+ return Registry.AdapterFor(ifaces.CapabilityOrderedUnmarshalJSON, value)
+}
+
+// NewOrderedMap provides the "ordered map" implementation provided by the registry.
+func NewOrderedMap(capacity int) ifaces.OrderedMap {
+ var v any
+ adapter := Registry.AdapterFor(ifaces.CapabilityOrderedUnmarshalJSON, v)
+ if adapter == nil {
+ return nil
+ }
+
+ defer adapter.Redeem()
+ return adapter.NewOrderedMap(capacity)
+}
+
+func noopRedeemer() {}
diff --git a/vendor/github.com/go-openapi/swag/jsonutils/adapters/stdlib/json/adapter.go b/vendor/github.com/go-openapi/swag/jsonutils/adapters/stdlib/json/adapter.go
new file mode 100644
index 00000000..0213ff5c
--- /dev/null
+++ b/vendor/github.com/go-openapi/swag/jsonutils/adapters/stdlib/json/adapter.go
@@ -0,0 +1,115 @@
+// SPDX-FileCopyrightText: Copyright 2015-2025 go-swagger maintainers
+// SPDX-License-Identifier: Apache-2.0
+
+package json
+
+import (
+ stdjson "encoding/json"
+
+ "github.com/go-openapi/swag/jsonutils/adapters/ifaces"
+ "github.com/go-openapi/swag/typeutils"
+)
+
+const sensibleBufferSize = 8192
+
+type jsonError string
+
+func (e jsonError) Error() string {
+ return string(e)
+}
+
+// ErrStdlib indicates that an error comes from the stdlib JSON adapter
+var ErrStdlib jsonError = "error from the JSON adapter stdlib"
+
+var _ ifaces.Adapter = &Adapter{}
+
+type Adapter struct {
+}
+
+// NewAdapter yields an [ifaces.Adapter] using the standard library.
+func NewAdapter() *Adapter {
+ return &Adapter{}
+}
+
+func (a *Adapter) Marshal(value any) ([]byte, error) {
+ return stdjson.Marshal(value)
+}
+
+func (a *Adapter) Unmarshal(data []byte, value any) error {
+ return stdjson.Unmarshal(data, value)
+}
+
+func (a *Adapter) OrderedMarshal(value ifaces.Ordered) ([]byte, error) {
+ w := poolOfWriters.Borrow()
+ defer func() {
+ poolOfWriters.Redeem(w)
+ }()
+
+ if typeutils.IsNil(value) {
+ w.RawString("null")
+
+ return w.BuildBytes()
+ }
+
+ w.RawByte('{')
+ first := true
+ for k, v := range value.OrderedItems() {
+ if first {
+ first = false
+ } else {
+ w.RawByte(',')
+ }
+
+ w.String(k)
+ w.RawByte(':')
+
+ switch val := v.(type) {
+ case ifaces.Ordered:
+ w.Raw(a.OrderedMarshal(val))
+ default:
+ w.Raw(stdjson.Marshal(v))
+ }
+ }
+
+ w.RawByte('}')
+
+ return w.BuildBytes()
+}
+
+func (a *Adapter) OrderedUnmarshal(data []byte, value ifaces.SetOrdered) error {
+ var m MapSlice
+ if err := m.OrderedUnmarshalJSON(data); err != nil {
+ return err
+ }
+
+ if typeutils.IsNil(m) {
+ // force input value to nil
+ value.SetOrderedItems(nil)
+
+ return nil
+ }
+
+ value.SetOrderedItems(m.OrderedItems())
+
+ return nil
+}
+
+func (a *Adapter) NewOrderedMap(capacity int) ifaces.OrderedMap {
+ m := make(MapSlice, 0, capacity)
+
+ return &m
+}
+
+// Redeem the [Adapter] when it comes from a pool.
+//
+// The adapter becomes immediately unusable once redeemed.
+func (a *Adapter) Redeem() {
+ if a == nil {
+ return
+ }
+
+ RedeemAdapter(a)
+}
+
+func (a *Adapter) Reset() {
+}
diff --git a/vendor/github.com/go-openapi/swag/jsonutils/adapters/stdlib/json/doc.go b/vendor/github.com/go-openapi/swag/jsonutils/adapters/stdlib/json/doc.go
new file mode 100644
index 00000000..5ea1b440
--- /dev/null
+++ b/vendor/github.com/go-openapi/swag/jsonutils/adapters/stdlib/json/doc.go
@@ -0,0 +1,5 @@
+// SPDX-FileCopyrightText: Copyright 2015-2025 go-swagger maintainers
+// SPDX-License-Identifier: Apache-2.0
+
+// Package json implements an [ifaces.Adapter] using the standard library.
+package json
diff --git a/vendor/github.com/go-openapi/swag/jsonutils/adapters/stdlib/json/lexer.go b/vendor/github.com/go-openapi/swag/jsonutils/adapters/stdlib/json/lexer.go
new file mode 100644
index 00000000..b5aa1c79
--- /dev/null
+++ b/vendor/github.com/go-openapi/swag/jsonutils/adapters/stdlib/json/lexer.go
@@ -0,0 +1,320 @@
+// SPDX-FileCopyrightText: Copyright 2015-2025 go-swagger maintainers
+// SPDX-License-Identifier: Apache-2.0
+
+package json
+
+import (
+ stdjson "encoding/json"
+ "errors"
+ "fmt"
+ "io"
+ "math"
+ "strconv"
+
+ "github.com/go-openapi/swag/conv"
+)
+
+type token struct {
+ stdjson.Token
+}
+
+func (t token) String() string {
+ if t == invalidToken {
+ return "invalid token"
+ }
+ if t == eofToken {
+ return "EOF"
+ }
+
+ return fmt.Sprintf("%v", t.Token)
+}
+
+func (t token) Kind() tokenKind {
+ switch t.Token.(type) {
+ case nil:
+ return tokenNull
+ case stdjson.Delim:
+ return tokenDelim
+ case bool:
+ return tokenBool
+ case float64:
+ return tokenFloat
+ case stdjson.Number:
+ return tokenNumber
+ case string:
+ return tokenString
+ default:
+ return tokenUndef
+ }
+}
+
+func (t token) Delim() byte {
+ r, ok := t.Token.(stdjson.Delim)
+ if !ok {
+ return 0
+ }
+
+ return byte(r)
+}
+
+type tokenKind uint8
+
+const (
+ tokenUndef tokenKind = iota
+ tokenString
+ tokenNumber
+ tokenFloat
+ tokenBool
+ tokenNull
+ tokenDelim
+)
+
+var (
+ invalidToken = token{
+ Token: stdjson.Token(struct{}{}),
+ }
+
+ eofToken = token{
+ Token: stdjson.Token(&struct{}{}),
+ }
+
+ undefToken = token{
+ Token: stdjson.Token(uint8(0)),
+ }
+)
+
+// jlexer apes easyjson's jlexer, but uses the standard library decoder under the hood.
+type jlexer struct {
+ buf *bytesReader
+ dec *stdjson.Decoder
+ err error
+ // current token
+ next token
+ // started bool
+}
+
+type bytesReader struct {
+ buf []byte
+ offset int
+}
+
+func (b *bytesReader) Reset() {
+ b.buf = nil
+ b.offset = 0
+}
+
+func (b *bytesReader) Read(p []byte) (int, error) {
+ if b.offset >= len(b.buf) {
+ return 0, io.EOF
+ }
+
+ n := len(p)
+ buf := b.buf[b.offset:]
+ m := len(buf)
+
+ if n >= m {
+ copy(p, buf)
+ b.offset += m
+
+ return m, nil
+ }
+
+ copy(p, buf[:n])
+ b.offset += n
+
+ return n, nil
+}
+
+var _ io.Reader = &bytesReader{}
+
+func newLexer(data []byte) *jlexer {
+ l := &jlexer{
+ // current: undefToken,
+ next: undefToken,
+ }
+ l.buf = &bytesReader{
+ buf: data,
+ }
+ l.dec = stdjson.NewDecoder(l.buf) // unfortunately, cannot pool this
+
+ return l
+}
+
+func (l *jlexer) Reset() {
+ l.err = nil
+ l.next = undefToken
+ // leave l.dec and l.buf alone, since they are replaced at every Borrow
+}
+
+func (l *jlexer) Error() error {
+ return l.err
+}
+
+func (l *jlexer) SetErr(err error) {
+ l.err = err
+}
+
+func (l *jlexer) Ok() bool {
+ return l.err == nil
+}
+
+// NextToken consumes a token
+func (l *jlexer) NextToken() token {
+ if !l.Ok() {
+ return invalidToken
+ }
+
+ if l.next != undefToken {
+ next := l.next
+ l.next = undefToken
+
+ return next
+ }
+
+ return l.fetchToken()
+}
+
+// PeekToken returns the next token without consuming it
+func (l *jlexer) PeekToken() token {
+ if l.next == undefToken {
+ l.next = l.fetchToken()
+ }
+
+ return l.next
+}
+
+func (l *jlexer) Skip() {
+ _ = l.NextToken()
+}
+
+func (l *jlexer) IsDelim(c byte) bool {
+ if !l.Ok() {
+ return false
+ }
+
+ next := l.PeekToken()
+ if next.Kind() != tokenDelim {
+ return false
+ }
+
+ if next.Delim() != c {
+ return false
+ }
+
+ return true
+}
+
+func (l *jlexer) IsNull() bool {
+ if !l.Ok() {
+ return false
+ }
+
+ next := l.PeekToken()
+
+ return next.Kind() == tokenNull
+}
+
+func (l *jlexer) Delim(c byte) {
+ if !l.Ok() {
+ return
+ }
+
+ tok := l.NextToken()
+ if tok.Kind() != tokenDelim {
+ l.err = fmt.Errorf("expected a delimiter token but got '%v': %w", tok, ErrStdlib)
+
+ return
+ }
+
+ if tok.Delim() != c {
+ l.err = fmt.Errorf("expected delimiter '%q' but got '%q': %w", c, tok.Delim(), ErrStdlib)
+ }
+}
+
+func (l *jlexer) Null() {
+ if !l.Ok() {
+ return
+ }
+
+ tok := l.NextToken()
+ if tok.Kind() != tokenNull {
+ l.err = fmt.Errorf("expected a null token but got '%v': %w", tok, ErrStdlib)
+ }
+}
+
+func (l *jlexer) Number() any {
+ if !l.Ok() {
+ return 0
+ }
+
+ tok := l.NextToken()
+
+ switch tok.Kind() { //nolint:exhaustive
+ case tokenNumber:
+ n := tok.Token.(stdjson.Number).String()
+ f, _ := strconv.ParseFloat(n, 64)
+ if conv.IsFloat64AJSONInteger(f) {
+ return int64(math.Trunc(f))
+ }
+
+ return f
+
+ case tokenFloat:
+ f := tok.Token.(float64)
+ if conv.IsFloat64AJSONInteger(f) {
+ return int64(math.Trunc(f))
+ }
+
+ return f
+
+ default:
+ l.err = fmt.Errorf("expected a number token but got '%v': %w", tok, ErrStdlib)
+
+ return 0
+ }
+}
+
+func (l *jlexer) Bool() bool {
+ if !l.Ok() {
+ return false
+ }
+
+ tok := l.NextToken()
+ if tok.Kind() != tokenBool {
+ l.err = fmt.Errorf("expected a bool token but got '%v': %w", tok, ErrStdlib)
+
+ return false
+ }
+
+ return tok.Token.(bool)
+}
+
+func (l *jlexer) String() string {
+ if !l.Ok() {
+ return ""
+ }
+
+ tok := l.NextToken()
+ if tok.Kind() != tokenString {
+ l.err = fmt.Errorf("expected a string token but got '%v': %w", tok, ErrStdlib)
+
+ return ""
+ }
+
+ return tok.Token.(string)
+}
+
+// Commas and colons are elided.
+func (l *jlexer) fetchToken() token {
+ jtok, err := l.dec.Token()
+ if err != nil {
+ if errors.Is(err, io.EOF) {
+ return eofToken
+ }
+
+ l.err = errors.Join(err, ErrStdlib)
+ return invalidToken
+ }
+
+ return token{Token: jtok}
+}
diff --git a/vendor/github.com/go-openapi/swag/jsonutils/adapters/stdlib/json/ordered_map.go b/vendor/github.com/go-openapi/swag/jsonutils/adapters/stdlib/json/ordered_map.go
new file mode 100644
index 00000000..54deef40
--- /dev/null
+++ b/vendor/github.com/go-openapi/swag/jsonutils/adapters/stdlib/json/ordered_map.go
@@ -0,0 +1,266 @@
+// SPDX-FileCopyrightText: Copyright 2015-2025 go-swagger maintainers
+// SPDX-License-Identifier: Apache-2.0
+
+package json
+
+import (
+ stdjson "encoding/json"
+ "fmt"
+ "iter"
+
+ "github.com/go-openapi/swag/jsonutils/adapters/ifaces"
+)
+
+var _ ifaces.OrderedMap = &MapSlice{}
+
+// MapSlice represents a JSON object, with the order of keys maintained.
+type MapSlice []MapItem
+
+func (s MapSlice) OrderedItems() iter.Seq2[string, any] {
+ return func(yield func(string, any) bool) {
+ for _, item := range s {
+ if !yield(item.Key, item.Value) {
+ return
+ }
+ }
+ }
+}
+
+func (s *MapSlice) SetOrderedItems(items iter.Seq2[string, any]) {
+ if items == nil {
+ *s = nil
+
+ return
+ }
+
+ m := *s
+ if len(m) > 0 {
+ // update mode
+ idx := make(map[string]int, len(m))
+
+ for i, item := range m {
+ idx[item.Key] = i
+ }
+
+ for k, v := range items {
+ idx, ok := idx[k]
+ if ok {
+ m[idx].Value = v
+
+ continue
+ }
+ m = append(m, MapItem{Key: k, Value: v})
+ }
+
+ *s = m
+
+ return
+ }
+
+ for k, v := range items {
+ m = append(m, MapItem{Key: k, Value: v})
+ }
+
+ *s = m
+}
+
+// MarshalJSON renders a [MapSlice] as JSON bytes, preserving the order of keys.
+func (s MapSlice) MarshalJSON() ([]byte, error) {
+ return s.OrderedMarshalJSON()
+}
+
+func (s MapSlice) OrderedMarshalJSON() ([]byte, error) {
+ w := poolOfWriters.Borrow()
+ defer func() {
+ poolOfWriters.Redeem(w)
+ }()
+
+ s.marshalObject(w)
+
+ return w.BuildBytes() // this clones data, so it's okay to redeem the writer and its buffer
+}
+
+// UnmarshalJSON builds a [MapSlice] from JSON bytes, preserving the order of keys.
+//
+// Inner objects are unmarshaled as [MapSlice] slices and not map[string]any.
+func (s *MapSlice) UnmarshalJSON(data []byte) error {
+ return s.OrderedUnmarshalJSON(data)
+}
+
+func (s *MapSlice) OrderedUnmarshalJSON(data []byte) error {
+ l := poolOfLexers.Borrow(data)
+ defer func() {
+ poolOfLexers.Redeem(l)
+ }()
+
+ s.unmarshalObject(l)
+
+ return l.Error()
+}
+
+func (s MapSlice) marshalObject(w *jwriter) {
+ if s == nil {
+ w.RawString("null")
+
+ return
+ }
+
+ w.RawByte('{')
+
+ if len(s) == 0 {
+ w.RawByte('}')
+
+ return
+ }
+
+ s[0].marshalJSON(w)
+
+ for i := 1; i < len(s); i++ {
+ w.RawByte(',')
+ s[i].marshalJSON(w)
+ }
+
+ w.RawByte('}')
+}
+
+func (s *MapSlice) unmarshalObject(in *jlexer) {
+ if in.IsNull() {
+ in.Skip()
+
+ return
+ }
+
+ in.Delim('{') // consume token
+ if !in.Ok() {
+ return
+ }
+
+ result := make(MapSlice, 0)
+
+ for in.Ok() && !in.IsDelim('}') {
+ var mi MapItem
+
+ mi.unmarshalKeyValue(in)
+ result = append(result, mi)
+ }
+
+ in.Delim('}')
+
+ if !in.Ok() {
+ return
+ }
+
+ *s = result
+}
+
+// MapItem represents the value of a key in a JSON object held by [MapSlice].
+//
+// Notice that [MapItem] should not be marshaled to or unmarshaled from JSON directly,
+// use this type as part of a [MapSlice] when dealing with JSON bytes.
+type MapItem struct {
+ Key string
+ Value any
+}
+
+func (s MapItem) marshalJSON(w *jwriter) {
+ w.String(s.Key)
+ w.RawByte(':')
+ w.Raw(stdjson.Marshal(s.Value))
+}
+
+func (s *MapItem) unmarshalKeyValue(in *jlexer) {
+ key := in.String() // consume string
+ value := s.asInterface(in) // consume any value, including termination tokens '}' or ']'
+
+ if !in.Ok() {
+ return
+ }
+
+ s.Key = key
+ s.Value = value
+}
+
+func (s *MapItem) unmarshalArray(in *jlexer) []any {
+ if in.IsNull() {
+ in.Skip()
+
+ return nil
+ }
+
+ in.Delim('[') // consume token
+ if !in.Ok() {
+ return nil
+ }
+
+ ret := make([]any, 0)
+
+ for in.Ok() && !in.IsDelim(']') {
+ ret = append(ret, s.asInterface(in))
+ }
+
+ in.Delim(']')
+ if !in.Ok() {
+ return nil
+ }
+
+ return ret
+}
+
+// asInterface is very much like [jlexer.Lexer.Interface], but unmarshals an object
+// into a [MapSlice], not a map[string]any.
+//
+// We have to force parsing errors somehow, since [jlexer.Lexer] doesn't let us
+// set a parsing error directly.
+func (s *MapItem) asInterface(in *jlexer) any {
+ if !in.Ok() {
+ return nil
+ }
+
+ tok := in.PeekToken() // look-ahead what the next token looks like
+ kind := tok.Kind()
+
+ switch kind {
+ case tokenString:
+ return in.String() // consume string
+
+ case tokenNumber, tokenFloat:
+ return in.Number()
+
+ case tokenBool:
+ return in.Bool()
+
+ case tokenNull:
+ in.Null()
+
+ return nil
+
+ case tokenDelim:
+ switch tok.Delim() {
+ case '{': // not consumed yet
+ ret := make(MapSlice, 0)
+ ret.unmarshalObject(in) // consumes the terminating '}'
+
+ if in.Ok() {
+ return ret
+ }
+
+ // lexer is in an error state: will exhaust
+ return nil
+
+ case '[': // not consumed yet
+ return s.unmarshalArray(in) // consumes the terminating ']'
+ default:
+ in.SetErr(fmt.Errorf("unexpected delimiter: %v: %w", tok, ErrStdlib)) // force error
+ return nil
+ }
+
+ case tokenUndef:
+ fallthrough
+ default:
+ if in.Ok() {
+ in.SetErr(fmt.Errorf("unexpected token: %v: %w", tok, ErrStdlib)) // force error
+ }
+
+ return nil
+ }
+}
diff --git a/vendor/github.com/go-openapi/swag/jsonutils/adapters/stdlib/json/pool.go b/vendor/github.com/go-openapi/swag/jsonutils/adapters/stdlib/json/pool.go
new file mode 100644
index 00000000..709b97c3
--- /dev/null
+++ b/vendor/github.com/go-openapi/swag/jsonutils/adapters/stdlib/json/pool.go
@@ -0,0 +1,143 @@
+// SPDX-FileCopyrightText: Copyright 2015-2025 go-swagger maintainers
+// SPDX-License-Identifier: Apache-2.0
+
+package json
+
+import (
+ "encoding/json"
+ "sync"
+
+ "github.com/go-openapi/swag/jsonutils/adapters/ifaces"
+)
+
+type adaptersPool struct {
+ sync.Pool
+}
+
+func (p *adaptersPool) Borrow() *Adapter {
+ return p.Get().(*Adapter)
+}
+
+func (p *adaptersPool) BorrowIface() ifaces.Adapter {
+ return p.Get().(*Adapter)
+}
+
+func (p *adaptersPool) Redeem(a *Adapter) {
+ p.Put(a)
+}
+
+type writersPool struct {
+ sync.Pool
+}
+
+func (p *writersPool) Borrow() *jwriter {
+ ptr := p.Get()
+
+ jw := ptr.(*jwriter)
+ jw.Reset()
+
+ return jw
+}
+
+func (p *writersPool) Redeem(w *jwriter) {
+ p.Put(w)
+}
+
+type lexersPool struct {
+ sync.Pool
+}
+
+func (p *lexersPool) Borrow(data []byte) *jlexer {
+ ptr := p.Get()
+
+ l := ptr.(*jlexer)
+ l.buf = poolOfReaders.Borrow(data)
+ l.dec = json.NewDecoder(l.buf) // cannot pool, not exposed by the encoding/json API
+ l.Reset()
+
+ return l
+}
+
+func (p *lexersPool) Redeem(l *jlexer) {
+ l.dec = nil
+ discard := l.buf
+ l.buf = nil
+ poolOfReaders.Redeem(discard)
+ p.Put(l)
+}
+
+type readersPool struct {
+ sync.Pool
+}
+
+func (p *readersPool) Borrow(data []byte) *bytesReader {
+ ptr := p.Get()
+
+ b := ptr.(*bytesReader)
+ b.Reset()
+ b.buf = data
+
+ return b
+}
+
+func (p *readersPool) Redeem(b *bytesReader) {
+ p.Put(b)
+}
+
+var (
+ poolOfAdapters = &adaptersPool{
+ Pool: sync.Pool{
+ New: func() any {
+ return NewAdapter()
+ },
+ },
+ }
+
+ poolOfWriters = &writersPool{
+ Pool: sync.Pool{
+ New: func() any {
+ return newJWriter()
+ },
+ },
+ }
+
+ poolOfLexers = &lexersPool{
+ Pool: sync.Pool{
+ New: func() any {
+ return newLexer(nil)
+ },
+ },
+ }
+
+ poolOfReaders = &readersPool{
+ Pool: sync.Pool{
+ New: func() any {
+ return &bytesReader{}
+ },
+ },
+ }
+)
+
+// BorrowAdapter borrows an [Adapter] from the pool, recycling already allocated instances.
+func BorrowAdapter() *Adapter {
+ return poolOfAdapters.Borrow()
+}
+
+// BorrowAdapterIface borrows a stdlib [Adapter] and converts it directly
+// to [ifaces.Adapter]. This is useful to avoid further allocations when
+// translating the concrete type into an interface.
+func BorrowAdapterIface() ifaces.Adapter {
+ return poolOfAdapters.BorrowIface()
+}
+
+// RedeemAdapter redeems an [Adapter] to the pool, so it may be recycled.
+func RedeemAdapter(a *Adapter) {
+ poolOfAdapters.Redeem(a)
+}
+
+func RedeemAdapterIface(a ifaces.Adapter) {
+ concrete, ok := a.(*Adapter)
+ if ok {
+ poolOfAdapters.Redeem(concrete)
+ }
+}
diff --git a/vendor/github.com/go-openapi/swag/jsonutils/adapters/stdlib/json/register.go b/vendor/github.com/go-openapi/swag/jsonutils/adapters/stdlib/json/register.go
new file mode 100644
index 00000000..fc881869
--- /dev/null
+++ b/vendor/github.com/go-openapi/swag/jsonutils/adapters/stdlib/json/register.go
@@ -0,0 +1,26 @@
+// SPDX-FileCopyrightText: Copyright 2015-2025 go-swagger maintainers
+// SPDX-License-Identifier: Apache-2.0
+
+package json
+
+import (
+ "fmt"
+ "reflect"
+
+ "github.com/go-openapi/swag/jsonutils/adapters/ifaces"
+)
+
+func Register(dispatcher ifaces.Registrar) {
+ t := reflect.TypeOf(Adapter{})
+ dispatcher.RegisterFor(
+ ifaces.RegistryEntry{
+ Who: fmt.Sprintf("%s.%s", t.PkgPath(), t.Name()),
+ What: ifaces.AllCapabilities,
+ Constructor: BorrowAdapterIface,
+ Support: support,
+ })
+}
+
+func support(_ ifaces.Capability, _ any) bool {
+ return true
+}
diff --git a/vendor/github.com/go-openapi/swag/jsonutils/adapters/stdlib/json/writer.go b/vendor/github.com/go-openapi/swag/jsonutils/adapters/stdlib/json/writer.go
new file mode 100644
index 00000000..dc2325c1
--- /dev/null
+++ b/vendor/github.com/go-openapi/swag/jsonutils/adapters/stdlib/json/writer.go
@@ -0,0 +1,75 @@
+// SPDX-FileCopyrightText: Copyright 2015-2025 go-swagger maintainers
+// SPDX-License-Identifier: Apache-2.0
+
+package json
+
+import (
+ "bytes"
+ "encoding/json"
+ "strings"
+)
+
+type jwriter struct {
+ buf *bytes.Buffer
+ err error
+}
+
+func newJWriter() *jwriter {
+ buf := make([]byte, 0, sensibleBufferSize)
+
+ return &jwriter{buf: bytes.NewBuffer(buf)}
+}
+
+func (w *jwriter) Reset() {
+ w.buf.Reset()
+ w.err = nil
+}
+
+func (w *jwriter) RawString(s string) {
+ if w.err != nil {
+ return
+ }
+ w.buf.WriteString(s)
+}
+
+func (w *jwriter) Raw(b []byte, err error) {
+ if w.err != nil {
+ return
+ }
+ if err != nil {
+ w.err = err
+ return
+ }
+
+ _, _ = w.buf.Write(b)
+}
+
+func (w *jwriter) RawByte(c byte) {
+ if w.err != nil {
+ return
+ }
+ w.buf.WriteByte(c)
+}
+
+var quoteReplacer = strings.NewReplacer(`"`, `\"`, `\`, `\\`)
+
+func (w *jwriter) String(s string) {
+ if w.err != nil {
+ return
+ }
+ // escape quotes and \
+ s = quoteReplacer.Replace(s)
+
+ _ = w.buf.WriteByte('"')
+ json.HTMLEscape(w.buf, []byte(s))
+ _ = w.buf.WriteByte('"')
+}
+
+// BuildBytes returns a clone of the internal buffer.
+func (w *jwriter) BuildBytes() ([]byte, error) {
+ if w.err != nil {
+ return nil, w.err
+ }
+
+ return bytes.Clone(w.buf.Bytes()), nil
+}
diff --git a/vendor/github.com/go-openapi/swag/jsonutils/concat.go b/vendor/github.com/go-openapi/swag/jsonutils/concat.go
new file mode 100644
index 00000000..2068503a
--- /dev/null
+++ b/vendor/github.com/go-openapi/swag/jsonutils/concat.go
@@ -0,0 +1,92 @@
+// SPDX-FileCopyrightText: Copyright 2015-2025 go-swagger maintainers
+// SPDX-License-Identifier: Apache-2.0
+
+package jsonutils
+
+import (
+ "bytes"
+)
+
+// nullJSON represents a JSON object with null type
+var nullJSON = []byte("null")
+
+const comma = byte(',')
+
+var closers map[byte]byte
+
+func init() {
+ closers = map[byte]byte{
+ '{': '}',
+ '[': ']',
+ }
+}
+
+// ConcatJSON concatenates multiple json objects or arrays efficiently.
+//
+// Note that [ConcatJSON] performs a very simple (and fast) concatenation
+// operation: it does not attempt to merge objects.
+func ConcatJSON(blobs ...[]byte) []byte {
+ if len(blobs) == 0 {
+ return nil
+ }
+
+ last := len(blobs) - 1
+ for blobs[last] == nil || bytes.Equal(blobs[last], nullJSON) {
+ // strips trailing null objects
+ last--
+ if last < 0 {
+ // there was nothing but "null"s or nil...
+ return nil
+ }
+ }
+ if last == 0 {
+ return blobs[0]
+ }
+
+ var opening, closing byte
+ var idx, a int
+ buf := bytes.NewBuffer(nil)
+
+ for i, b := range blobs[:last+1] {
+ if b == nil || bytes.Equal(b, nullJSON) {
+ // a null object is in the list: skip it
+ continue
+ }
+ if len(b) > 0 && opening == 0 { // is this an array or an object?
+ opening, closing = b[0], closers[b[0]]
+ }
+
+ if opening != '{' && opening != '[' {
+ continue // don't know how to concatenate non container objects
+ }
+
+ const minLengthIfNotEmpty = 3
+ if len(b) < minLengthIfNotEmpty { // yep empty but also the last one, so closing this thing
+ if i == last && a > 0 {
+ _ = buf.WriteByte(closing) // never returns err != nil
+ }
+ continue
+ }
+
+ idx = 0
+ if a > 0 { // we need to join with a comma for everything beyond the first non-empty item
+ _ = buf.WriteByte(comma) // never returns err != nil
+ idx = 1 // this is not the first or the last so we want to drop the leading bracket
+ }
+
+ if i != last { // not the last one, strip brackets
+ _, _ = buf.Write(b[idx : len(b)-1]) // never returns err != nil
+ } else { // last one, strip only the leading bracket
+ _, _ = buf.Write(b[idx:])
+ }
+ a++
+ }
+
+ // somehow it ended up being empty, so provide a default value
+ if buf.Len() == 0 && (opening == '{' || opening == '[') {
+ _ = buf.WriteByte(opening) // never returns err != nil
+ _ = buf.WriteByte(closing)
+ }
+
+ return buf.Bytes()
+}
diff --git a/vendor/github.com/go-openapi/swag/jsonutils/doc.go b/vendor/github.com/go-openapi/swag/jsonutils/doc.go
new file mode 100644
index 00000000..3926cc58
--- /dev/null
+++ b/vendor/github.com/go-openapi/swag/jsonutils/doc.go
@@ -0,0 +1,7 @@
+// SPDX-FileCopyrightText: Copyright 2015-2025 go-swagger maintainers
+// SPDX-License-Identifier: Apache-2.0
+
+// Package jsonutils provides helpers to work with JSON.
+//
+// These utilities work with dynamic go structures to and from JSON.
+package jsonutils
diff --git a/vendor/github.com/go-openapi/swag/jsonutils/json.go b/vendor/github.com/go-openapi/swag/jsonutils/json.go
new file mode 100644
index 00000000..40753ce0
--- /dev/null
+++ b/vendor/github.com/go-openapi/swag/jsonutils/json.go
@@ -0,0 +1,116 @@
+// SPDX-FileCopyrightText: Copyright 2015-2025 go-swagger maintainers
+// SPDX-License-Identifier: Apache-2.0
+
+package jsonutils
+
+import (
+ "bytes"
+ "encoding/json"
+
+ "github.com/go-openapi/swag/jsonutils/adapters"
+ "github.com/go-openapi/swag/jsonutils/adapters/ifaces"
+)
+
+// WriteJSON marshals a data structure as JSON.
+//
+// The difference with [json.Marshal] is that it may check among several alternatives
+// to do so.
+//
+// See [adapters.Registrar] for more details about how to configure
+// multiple serialization alternatives.
+//
+// NOTE: to allow types that are [easyjson.Marshaler] s to use that route to process JSON,
+// you now need to register the adapter for easyjson at runtime.
+func WriteJSON(value any) ([]byte, error) {
+ if orderedMap, isOrdered := value.(ifaces.Ordered); isOrdered {
+ orderedMarshaler := adapters.OrderedMarshalAdapterFor(orderedMap)
+
+ if orderedMarshaler != nil {
+ defer orderedMarshaler.Redeem()
+
+ return orderedMarshaler.OrderedMarshal(orderedMap)
+ }
+
+ // no support found in registered adapters, fallback to the default (unordered) case
+ }
+
+ marshaler := adapters.MarshalAdapterFor(value)
+ if marshaler != nil {
+ defer marshaler.Redeem()
+
+ return marshaler.Marshal(value)
+ }
+
+ // no support found in registered adapters, fallback to the default standard library.
+ //
+ // This only happens when tinkering with the global registry of adapters, since the default handles all the above cases.
+ return json.Marshal(value) // Codecov ignore // this is a safeguard not easily simulated in tests
+}
+
+// ReadJSON unmarshals JSON data into a data structure.
+//
+// The difference with [json.Unmarshal] is that it may check among several alternatives
+// to do so.
+//
+// See [adapters.Registrar] for more details about how to configure
+// multiple serialization alternatives.
+//
+// NOTE: value must be a pointer.
+//
+// If the provided value implements [ifaces.SetOrdered], it is a considered an "ordered map" and [ReadJSON]
+// will favor an adapter that supports the [ifaces.OrderedUnmarshal] feature, or fallback to
+// an unordered behavior if none is found.
+//
+// NOTE: to allow types that are [easyjson.Unmarshaler] s to use that route to process JSON,
+// you now need to register the adapter for easyjson at runtime.
+func ReadJSON(data []byte, value any) error {
+ trimmedData := bytes.Trim(data, "\x00")
+
+ if orderedMap, isOrdered := value.(ifaces.SetOrdered); isOrdered {
+ // if the value is an ordered map, favors support for OrderedUnmarshal.
+
+ orderedUnmarshaler := adapters.OrderedUnmarshalAdapterFor(orderedMap)
+
+ if orderedUnmarshaler != nil {
+ defer orderedUnmarshaler.Redeem()
+
+ return orderedUnmarshaler.OrderedUnmarshal(trimmedData, orderedMap)
+ }
+
+ // no support found in registered adapters, fallback to the default (unordered) case
+ }
+
+ unmarshaler := adapters.UnmarshalAdapterFor(value)
+ if unmarshaler != nil {
+ defer unmarshaler.Redeem()
+
+ return unmarshaler.Unmarshal(trimmedData, value)
+ }
+
+ // no support found in registered adapters, fallback to the default standard library.
+ //
+ // This only happens when tinkering with the global registry of adapters, since the default handles all the above cases.
+ return json.Unmarshal(trimmedData, value) // Codecov ignore // this is a safeguard not easily simulated in tests
+}
+
+// FromDynamicJSON turns a go value into a properly JSON typed structure.
+//
+// "Dynamic JSON" refers to what you get when unmarshaling JSON into an untyped any,
+// i.e. objects are represented by map[string]any, arrays by []any, and
+// all numbers are represented as float64.
+//
+// NOTE: target must be a pointer.
+//
+// # Maintaining the order of keys in objects
+//
+// If source and target implement [ifaces.Ordered] and [ifaces.SetOrdered] respectively,
+// they are considered "ordered maps" and the order of keys is maintained in the
+// "jsonification" process. In that case, map[string]any values are replaced by (ordered) [JSONMapSlice] ones.
+func FromDynamicJSON(source, target any) error {
+ b, err := WriteJSON(source)
+ if err != nil {
+ return err
+ }
+
+ return ReadJSON(b, target)
+}
diff --git a/vendor/github.com/go-openapi/swag/jsonutils/ordered_map.go b/vendor/github.com/go-openapi/swag/jsonutils/ordered_map.go
new file mode 100644
index 00000000..38dd3e24
--- /dev/null
+++ b/vendor/github.com/go-openapi/swag/jsonutils/ordered_map.go
@@ -0,0 +1,114 @@
+// SPDX-FileCopyrightText: Copyright 2015-2025 go-swagger maintainers
+// SPDX-License-Identifier: Apache-2.0
+
+package jsonutils
+
+import (
+ "iter"
+
+ "github.com/go-openapi/swag/jsonutils/adapters"
+ "github.com/go-openapi/swag/typeutils"
+)
+
+// JSONMapSlice represents a JSON object, with the order of keys maintained.
+//
+// It behaves like an ordered map, but keys can't be accessed in constant time.
+type JSONMapSlice []JSONMapItem
+
+// OrderedItems iterates over all (key,value) pairs with the order of keys maintained.
+//
+// This implements the [ifaces.Ordered] interface, so that [ifaces.Adapter] s know how to marshal
+// keys in the desired order.
+func (s JSONMapSlice) OrderedItems() iter.Seq2[string, any] {
+ return func(yield func(string, any) bool) {
+ for _, item := range s {
+ if !yield(item.Key, item.Value) {
+ return
+ }
+ }
+ }
+}
+
+// SetOrderedItems sets keys in the [JSONMapSlice] objects, as presented by
+// the provided iterator.
+//
+// As a special case, if items is nil, this sets to receiver to a nil slice.
+//
+// This implements the [ifaces.SetOrdered] interface, so that [ifaces.Adapter] s know how to unmarshal
+// keys in the desired order.
+func (s *JSONMapSlice) SetOrderedItems(items iter.Seq2[string, any]) {
+ if items == nil {
+ // force receiver to be a nil slice
+ *s = nil
+
+ return
+ }
+
+ m := *s
+ if len(m) > 0 {
+ // update mode: short-circuited when unmarshaling fresh data structures
+ idx := make(map[string]int, len(m))
+
+ for i, item := range m {
+ idx[item.Key] = i
+ }
+
+ for k, v := range items {
+ idx, ok := idx[k]
+ if ok {
+ m[idx].Value = v
+
+ continue
+ }
+
+ m = append(m, JSONMapItem{Key: k, Value: v})
+ }
+
+ *s = m
+
+ return
+ }
+
+ for k, v := range items {
+ m = append(m, JSONMapItem{Key: k, Value: v})
+ }
+
+ *s = m
+}
+
+// MarshalJSON renders a [JSONMapSlice] as JSON bytes, preserving the order of keys.
+//
+// It will pick the JSON library currently configured by the [adapters.Registry] (defaults to the standard library).
+func (s JSONMapSlice) MarshalJSON() ([]byte, error) {
+ orderedMarshaler := adapters.OrderedMarshalAdapterFor(s)
+ defer orderedMarshaler.Redeem()
+
+ return orderedMarshaler.OrderedMarshal(s)
+}
+
+// UnmarshalJSON builds a [JSONMapSlice] from JSON bytes, preserving the order of keys.
+//
+// Inner objects are unmarshaled as ordered [JSONMapSlice] slices and not map[string]any.
+//
+// It will pick the JSON library currently configured by the [adapters.Registry] (defaults to the standard library).
+func (s *JSONMapSlice) UnmarshalJSON(data []byte) error {
+ if typeutils.IsNil(*s) {
+ // allow to unmarshal with a simple var declaration (nil slice)
+ *s = JSONMapSlice{}
+ }
+
+ orderedUnmarshaler := adapters.OrderedUnmarshalAdapterFor(s)
+ defer orderedUnmarshaler.Redeem()
+
+ return orderedUnmarshaler.OrderedUnmarshal(data, s)
+}
+
+// JSONMapItem represents the value of a key in a JSON object held by [JSONMapSlice].
+//
+// Notice that JSONMapItem should not be marshaled to or unmarshaled from JSON directly.
+//
+// Use this type as part of a [JSONMapSlice] when dealing with JSON bytes.
+type JSONMapItem struct {
+ Key string
+ Value any
+}
diff --git a/vendor/github.com/go-openapi/swag/loading/LICENSE b/vendor/github.com/go-openapi/swag/loading/LICENSE
new file mode 100644
index 00000000..d6456956
--- /dev/null
+++ b/vendor/github.com/go-openapi/swag/loading/LICENSE
@@ -0,0 +1,202 @@
+
+ Apache License
+ Version 2.0, January 2004
+ http://www.apache.org/licenses/
+
+ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+ 1. Definitions.
+
+ "License" shall mean the terms and conditions for use, reproduction,
+ and distribution as defined by Sections 1 through 9 of this document.
+
+ "Licensor" shall mean the copyright owner or entity authorized by
+ the copyright owner that is granting the License.
+
+ "Legal Entity" shall mean the union of the acting entity and all
+ other entities that control, are controlled by, or are under common
+ control with that entity. For the purposes of this definition,
+ "control" means (i) the power, direct or indirect, to cause the
+ direction or management of such entity, whether by contract or
+ otherwise, or (ii) ownership of fifty percent (50%) or more of the
+ outstanding shares, or (iii) beneficial ownership of such entity.
+
+ "You" (or "Your") shall mean an individual or Legal Entity
+ exercising permissions granted by this License.
+
+ "Source" form shall mean the preferred form for making modifications,
+ including but not limited to software source code, documentation
+ source, and configuration files.
+
+ "Object" form shall mean any form resulting from mechanical
+ transformation or translation of a Source form, including but
+ not limited to compiled object code, generated documentation,
+ and conversions to other media types.
+
+ "Work" shall mean the work of authorship, whether in Source or
+ Object form, made available under the License, as indicated by a
+ copyright notice that is included in or attached to the work
+ (an example is provided in the Appendix below).
+
+ "Derivative Works" shall mean any work, whether in Source or Object
+ form, that is based on (or derived from) the Work and for which the
+ editorial revisions, annotations, elaborations, or other modifications
+ represent, as a whole, an original work of authorship. For the purposes
+ of this License, Derivative Works shall not include works that remain
+ separable from, or merely link (or bind by name) to the interfaces of,
+ the Work and Derivative Works thereof.
+
+ "Contribution" shall mean any work of authorship, including
+ the original version of the Work and any modifications or additions
+ to that Work or Derivative Works thereof, that is intentionally
+ submitted to Licensor for inclusion in the Work by the copyright owner
+ or by an individual or Legal Entity authorized to submit on behalf of
+ the copyright owner. For the purposes of this definition, "submitted"
+ means any form of electronic, verbal, or written communication sent
+ to the Licensor or its representatives, including but not limited to
+ communication on electronic mailing lists, source code control systems,
+ and issue tracking systems that are managed by, or on behalf of, the
+ Licensor for the purpose of discussing and improving the Work, but
+ excluding communication that is conspicuously marked or otherwise
+ designated in writing by the copyright owner as "Not a Contribution."
+
+ "Contributor" shall mean Licensor and any individual or Legal Entity
+ on behalf of whom a Contribution has been received by Licensor and
+ subsequently incorporated within the Work.
+
+ 2. Grant of Copyright License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ copyright license to reproduce, prepare Derivative Works of,
+ publicly display, publicly perform, sublicense, and distribute the
+ Work and such Derivative Works in Source or Object form.
+
+ 3. Grant of Patent License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ (except as stated in this section) patent license to make, have made,
+ use, offer to sell, sell, import, and otherwise transfer the Work,
+ where such license applies only to those patent claims licensable
+ by such Contributor that are necessarily infringed by their
+ Contribution(s) alone or by combination of their Contribution(s)
+ with the Work to which such Contribution(s) was submitted. If You
+ institute patent litigation against any entity (including a
+ cross-claim or counterclaim in a lawsuit) alleging that the Work
+ or a Contribution incorporated within the Work constitutes direct
+ or contributory patent infringement, then any patent licenses
+ granted to You under this License for that Work shall terminate
+ as of the date such litigation is filed.
+
+ 4. Redistribution. You may reproduce and distribute copies of the
+ Work or Derivative Works thereof in any medium, with or without
+ modifications, and in Source or Object form, provided that You
+ meet the following conditions:
+
+ (a) You must give any other recipients of the Work or
+ Derivative Works a copy of this License; and
+
+ (b) You must cause any modified files to carry prominent notices
+ stating that You changed the files; and
+
+ (c) You must retain, in the Source form of any Derivative Works
+ that You distribute, all copyright, patent, trademark, and
+ attribution notices from the Source form of the Work,
+ excluding those notices that do not pertain to any part of
+ the Derivative Works; and
+
+ (d) If the Work includes a "NOTICE" text file as part of its
+ distribution, then any Derivative Works that You distribute must
+ include a readable copy of the attribution notices contained
+ within such NOTICE file, excluding those notices that do not
+ pertain to any part of the Derivative Works, in at least one
+ of the following places: within a NOTICE text file distributed
+ as part of the Derivative Works; within the Source form or
+ documentation, if provided along with the Derivative Works; or,
+ within a display generated by the Derivative Works, if and
+ wherever such third-party notices normally appear. The contents
+ of the NOTICE file are for informational purposes only and
+ do not modify the License. You may add Your own attribution
+ notices within Derivative Works that You distribute, alongside
+ or as an addendum to the NOTICE text from the Work, provided
+ that such additional attribution notices cannot be construed
+ as modifying the License.
+
+ You may add Your own copyright statement to Your modifications and
+ may provide additional or different license terms and conditions
+ for use, reproduction, or distribution of Your modifications, or
+ for any such Derivative Works as a whole, provided Your use,
+ reproduction, and distribution of the Work otherwise complies with
+ the conditions stated in this License.
+
+ 5. Submission of Contributions. Unless You explicitly state otherwise,
+ any Contribution intentionally submitted for inclusion in the Work
+ by You to the Licensor shall be under the terms and conditions of
+ this License, without any additional terms or conditions.
+ Notwithstanding the above, nothing herein shall supersede or modify
+ the terms of any separate license agreement you may have executed
+ with Licensor regarding such Contributions.
+
+ 6. Trademarks. This License does not grant permission to use the trade
+ names, trademarks, service marks, or product names of the Licensor,
+ except as required for reasonable and customary use in describing the
+ origin of the Work and reproducing the content of the NOTICE file.
+
+ 7. Disclaimer of Warranty. Unless required by applicable law or
+ agreed to in writing, Licensor provides the Work (and each
+ Contributor provides its Contributions) on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ implied, including, without limitation, any warranties or conditions
+ of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+ PARTICULAR PURPOSE. You are solely responsible for determining the
+ appropriateness of using or redistributing the Work and assume any
+ risks associated with Your exercise of permissions under this License.
+
+ 8. Limitation of Liability. In no event and under no legal theory,
+ whether in tort (including negligence), contract, or otherwise,
+ unless required by applicable law (such as deliberate and grossly
+ negligent acts) or agreed to in writing, shall any Contributor be
+ liable to You for damages, including any direct, indirect, special,
+ incidental, or consequential damages of any character arising as a
+ result of this License or out of the use or inability to use the
+ Work (including but not limited to damages for loss of goodwill,
+ work stoppage, computer failure or malfunction, or any and all
+ other commercial damages or losses), even if such Contributor
+ has been advised of the possibility of such damages.
+
+ 9. Accepting Warranty or Additional Liability. While redistributing
+ the Work or Derivative Works thereof, You may choose to offer,
+ and charge a fee for, acceptance of support, warranty, indemnity,
+ or other liability obligations and/or rights consistent with this
+ License. However, in accepting such obligations, You may act only
+ on Your own behalf and on Your sole responsibility, not on behalf
+ of any other Contributor, and only if You agree to indemnify,
+ defend, and hold each Contributor harmless for any liability
+ incurred by, or claims asserted against, such Contributor by reason
+ of your accepting any such warranty or additional liability.
+
+ END OF TERMS AND CONDITIONS
+
+ APPENDIX: How to apply the Apache License to your work.
+
+ To apply the Apache License to your work, attach the following
+ boilerplate notice, with the fields enclosed by brackets "[]"
+ replaced with your own identifying information. (Don't include
+ the brackets!) The text should be enclosed in the appropriate
+ comment syntax for the file format. We also recommend that a
+ file or class name and description of purpose be included on the
+ same "printed page" as the copyright notice for easier
+ identification within third-party archives.
+
+ Copyright [yyyy] [name of copyright owner]
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
diff --git a/vendor/github.com/go-openapi/swag/loading/doc.go b/vendor/github.com/go-openapi/swag/loading/doc.go
new file mode 100644
index 00000000..8cf7bcb8
--- /dev/null
+++ b/vendor/github.com/go-openapi/swag/loading/doc.go
@@ -0,0 +1,5 @@
+// SPDX-FileCopyrightText: Copyright 2015-2025 go-swagger maintainers
+// SPDX-License-Identifier: Apache-2.0
+
+// Package loading provides tools to load a file from http or from a local file system.
+package loading
diff --git a/vendor/github.com/go-openapi/swag/loading/errors.go b/vendor/github.com/go-openapi/swag/loading/errors.go
new file mode 100644
index 00000000..b3964289
--- /dev/null
+++ b/vendor/github.com/go-openapi/swag/loading/errors.go
@@ -0,0 +1,15 @@
+// SPDX-FileCopyrightText: Copyright 2015-2025 go-swagger maintainers
+// SPDX-License-Identifier: Apache-2.0
+
+package loading
+
+type loadingError string
+
+const (
+ // ErrLoader is an error raised by the file loader utility
+ ErrLoader loadingError = "loader error"
+)
+
+func (e loadingError) Error() string {
+ return string(e)
+}
diff --git a/vendor/github.com/go-openapi/swag/loading/json.go b/vendor/github.com/go-openapi/swag/loading/json.go
new file mode 100644
index 00000000..59db12f5
--- /dev/null
+++ b/vendor/github.com/go-openapi/swag/loading/json.go
@@ -0,0 +1,25 @@
+// SPDX-FileCopyrightText: Copyright 2015-2025 go-swagger maintainers
+// SPDX-License-Identifier: Apache-2.0
+
+package loading
+
+import (
+ "encoding/json"
+ "errors"
+ "path/filepath"
+)
+
+// JSONMatcher matches json for a file loader.
+func JSONMatcher(path string) bool {
+ ext := filepath.Ext(path)
+ return ext == ".json" || ext == ".jsn" || ext == ".jso"
+}
+
+// JSONDoc loads a json document from either a file or a remote url.
+func JSONDoc(path string, opts ...Option) (json.RawMessage, error) {
+ data, err := LoadFromFileOrHTTP(path, opts...)
+ if err != nil {
+ return nil, errors.Join(err, ErrLoader)
+ }
+ return json.RawMessage(data), nil
+}
diff --git a/vendor/github.com/go-openapi/swag/loading.go b/vendor/github.com/go-openapi/swag/loading/loading.go
similarity index 61%
rename from vendor/github.com/go-openapi/swag/loading.go
rename to vendor/github.com/go-openapi/swag/loading/loading.go
index 658a24b7..269fb74d 100644
--- a/vendor/github.com/go-openapi/swag/loading.go
+++ b/vendor/github.com/go-openapi/swag/loading/loading.go
@@ -1,54 +1,26 @@
-// Copyright 2015 go-swagger maintainers
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
+// SPDX-FileCopyrightText: Copyright 2015-2025 go-swagger maintainers
+// SPDX-License-Identifier: Apache-2.0
-package swag
+package loading
import (
+ "context"
+ "embed"
"fmt"
"io"
"log"
"net/http"
"net/url"
- "os"
"path"
"path/filepath"
"runtime"
"strings"
- "time"
)
-// LoadHTTPTimeout the default timeout for load requests
-var LoadHTTPTimeout = 30 * time.Second
-
-// LoadHTTPBasicAuthUsername the username to use when load requests require basic auth
-var LoadHTTPBasicAuthUsername = ""
-
-// LoadHTTPBasicAuthPassword the password to use when load requests require basic auth
-var LoadHTTPBasicAuthPassword = ""
-
-// LoadHTTPCustomHeaders an optional collection of custom HTTP headers for load requests
-var LoadHTTPCustomHeaders = map[string]string{}
-
// LoadFromFileOrHTTP loads the bytes from a file or a remote http server based on the path passed in
-func LoadFromFileOrHTTP(pth string) ([]byte, error) {
- return LoadStrategy(pth, os.ReadFile, loadHTTPBytes(LoadHTTPTimeout))(pth)
-}
-
-// LoadFromFileOrHTTPWithTimeout loads the bytes from a file or a remote http server based on the path passed in
-// timeout arg allows for per request overriding of the request timeout
-func LoadFromFileOrHTTPWithTimeout(pth string, timeout time.Duration) ([]byte, error) {
- return LoadStrategy(pth, os.ReadFile, loadHTTPBytes(timeout))(pth)
+func LoadFromFileOrHTTP(pth string, opts ...Option) ([]byte, error) {
+ o := optionsWithDefaults(opts)
+ return LoadStrategy(pth, o.ReadFileFunc(), loadHTTPBytes(opts...), opts...)(pth)
}
// LoadStrategy returns a loader function for a given path or URI.
@@ -81,10 +53,12 @@ func LoadFromFileOrHTTPWithTimeout(pth string, timeout time.Duration) ([]byte, e
// - `file://host/folder/file` becomes an UNC path like `\\host\folder\file` (no port specification is supported)
// - `file:///c:/folder/file` becomes `C:\folder\file`
// - `file://c:/folder/file` is tolerated (without leading `/`) and becomes `c:\folder\file`
-func LoadStrategy(pth string, local, remote func(string) ([]byte, error)) func(string) ([]byte, error) {
+func LoadStrategy(pth string, local, remote func(string) ([]byte, error), opts ...Option) func(string) ([]byte, error) {
if strings.HasPrefix(pth, "http") {
return remote
}
+ o := optionsWithDefaults(opts)
+ _, isEmbedFS := o.fs.(embed.FS)
return func(p string) ([]byte, error) {
upth, err := url.PathUnescape(p)
@@ -92,19 +66,19 @@ func LoadStrategy(pth string, local, remote func(string) ([]byte, error)) func(s
return nil, err
}
- if !strings.HasPrefix(p, `file://`) {
+ cpth, hasPrefix := strings.CutPrefix(upth, "file://")
+ if !hasPrefix || isEmbedFS || runtime.GOOS != "windows" {
+ // crude processing: trim the file:// prefix. This leaves full URIs with a host with a (mostly) unexpected result
// regular file path provided: just normalize slashes
- return local(filepath.FromSlash(upth))
+ if isEmbedFS {
+ // on windows, we need to slash the path if FS is an embed FS.
+ return local(strings.TrimLeft(filepath.ToSlash(cpth), "./")) // remove invalid leading characters for embed FS
+ }
+
+ return local(filepath.FromSlash(cpth))
}
- if runtime.GOOS != "windows" {
- // crude processing: this leaves full URIs with a host with a (mostly) unexpected result
- upth = strings.TrimPrefix(upth, `file://`)
-
- return local(filepath.FromSlash(upth))
- }
-
- // windows-only pre-processing of file://... URIs
+ // windows-only pre-processing of file://... URIs, excluding embed.FS
// support for canonical file URIs on windows.
u, err := url.Parse(filepath.ToSlash(upth))
@@ -139,19 +113,29 @@ func LoadStrategy(pth string, local, remote func(string) ([]byte, error)) func(s
}
}
-func loadHTTPBytes(timeout time.Duration) func(path string) ([]byte, error) {
+func loadHTTPBytes(opts ...Option) func(path string) ([]byte, error) {
+ o := optionsWithDefaults(opts)
+
return func(path string) ([]byte, error) {
- client := &http.Client{Timeout: timeout}
- req, err := http.NewRequest(http.MethodGet, path, nil) //nolint:noctx
+ client := o.client
+ timeoutCtx := context.Background()
+ var cancel func()
+
+ if o.httpTimeout > 0 {
+ timeoutCtx, cancel = context.WithTimeout(timeoutCtx, o.httpTimeout)
+ defer cancel()
+ }
+
+ req, err := http.NewRequestWithContext(timeoutCtx, http.MethodGet, path, nil)
if err != nil {
return nil, err
}
- if LoadHTTPBasicAuthUsername != "" && LoadHTTPBasicAuthPassword != "" {
- req.SetBasicAuth(LoadHTTPBasicAuthUsername, LoadHTTPBasicAuthPassword)
+ if o.basicAuthUsername != "" && o.basicAuthPassword != "" {
+ req.SetBasicAuth(o.basicAuthUsername, o.basicAuthPassword)
}
- for key, val := range LoadHTTPCustomHeaders {
+ for key, val := range o.customHeaders {
req.Header.Set(key, val)
}
diff --git a/vendor/github.com/go-openapi/swag/loading/options.go b/vendor/github.com/go-openapi/swag/loading/options.go
new file mode 100644
index 00000000..6674ac69
--- /dev/null
+++ b/vendor/github.com/go-openapi/swag/loading/options.go
@@ -0,0 +1,125 @@
+// SPDX-FileCopyrightText: Copyright 2015-2025 go-swagger maintainers
+// SPDX-License-Identifier: Apache-2.0
+
+package loading
+
+import (
+ "io/fs"
+ "net/http"
+ "os"
+ "time"
+)
+
+type (
+ // Option provides options for loading a file over HTTP or from a file.
+ Option func(*options)
+
+ httpOptions struct {
+ httpTimeout time.Duration
+ basicAuthUsername string
+ basicAuthPassword string
+ customHeaders map[string]string
+ client *http.Client
+ }
+
+ fileOptions struct {
+ fs fs.ReadFileFS
+ }
+
+ options struct {
+ httpOptions
+ fileOptions
+ }
+)
+
+func (fo fileOptions) ReadFileFunc() func(string) ([]byte, error) {
+ if fo.fs == nil {
+ return os.ReadFile
+ }
+
+ return fo.fs.ReadFile
+}
+
+// WithTimeout sets a timeout for the remote file loader.
+//
+// The default timeout is 30s.
+func WithTimeout(timeout time.Duration) Option {
+ return func(o *options) {
+ o.httpTimeout = timeout
+ }
+}
+
+// WithBasicAuth sets a basic authentication scheme for the remote file loader.
+func WithBasicAuth(username, password string) Option {
+ return func(o *options) {
+ o.basicAuthUsername = username
+ o.basicAuthPassword = password
+ }
+}
+
+// WithCustomHeaders sets custom headers for the remote file loader.
+func WithCustomHeaders(headers map[string]string) Option {
+ return func(o *options) {
+ if o.customHeaders == nil {
+ o.customHeaders = make(map[string]string, len(headers))
+ }
+
+ for header, value := range headers {
+ o.customHeaders[header] = value
+ }
+ }
+}
+
+// WithHTTPClient overrides the default HTTP client used to fetch a remote file.
+//
+// By default, [http.DefaultClient] is used.
+func WithHTTPClient(client *http.Client) Option {
+ return func(o *options) {
+ o.client = client
+ }
+}
+
+// WithFS sets a file system for the local file loader.
+//
+// If the provided file system is a [fs.ReadFileFS], the ReadFile function is used.
+// Otherwise, ReadFile is wrapped using [fs.ReadFile].
+//
+// By default, the file system is the one provided by the os package.
+//
+// For example, this may be set to consume from an embedded file system, or a rooted FS.
+func WithFS(filesystem fs.FS) Option {
+ return func(o *options) {
+ if rfs, ok := filesystem.(fs.ReadFileFS); ok {
+ o.fs = rfs
+
+ return
+ }
+ o.fs = readFileFS{FS: filesystem}
+ }
+}
+
+type readFileFS struct {
+ fs.FS
+}
+
+func (r readFileFS) ReadFile(name string) ([]byte, error) {
+ return fs.ReadFile(r.FS, name)
+}
+
+func optionsWithDefaults(opts []Option) options {
+ const defaultTimeout = 30 * time.Second
+
+ o := options{
+ // package level defaults
+ httpOptions: httpOptions{
+ httpTimeout: defaultTimeout,
+ client: http.DefaultClient,
+ },
+ }
+
+ for _, apply := range opts {
+ apply(&o)
+ }
+
+ return o
+}
diff --git a/vendor/github.com/go-openapi/swag/loading/yaml.go b/vendor/github.com/go-openapi/swag/loading/yaml.go
new file mode 100644
index 00000000..3ebb5366
--- /dev/null
+++ b/vendor/github.com/go-openapi/swag/loading/yaml.go
@@ -0,0 +1,37 @@
+// SPDX-FileCopyrightText: Copyright 2015-2025 go-swagger maintainers
+// SPDX-License-Identifier: Apache-2.0
+
+package loading
+
+import (
+ "encoding/json"
+ "path/filepath"
+
+ "github.com/go-openapi/swag/yamlutils"
+)
+
+// YAMLMatcher matches yaml for a file loader.
+func YAMLMatcher(path string) bool {
+ ext := filepath.Ext(path)
+ return ext == ".yaml" || ext == ".yml"
+}
+
+// YAMLDoc loads a yaml document from either http or a file and converts it to json.
+func YAMLDoc(path string, opts ...Option) (json.RawMessage, error) {
+ yamlDoc, err := YAMLData(path, opts...)
+ if err != nil {
+ return nil, err
+ }
+
+ return yamlutils.YAMLToJSON(yamlDoc)
+}
+
+// YAMLData loads a yaml document from either http or a file.
+func YAMLData(path string, opts ...Option) (any, error) {
+ data, err := LoadFromFileOrHTTP(path, opts...)
+ if err != nil {
+ return nil, err
+ }
+
+ return yamlutils.BytesToYAMLDoc(data)
+}
diff --git a/vendor/github.com/go-openapi/swag/name_lexem.go b/vendor/github.com/go-openapi/swag/name_lexem.go
deleted file mode 100644
index 8bb64ac3..00000000
--- a/vendor/github.com/go-openapi/swag/name_lexem.go
+++ /dev/null
@@ -1,93 +0,0 @@
-// Copyright 2015 go-swagger maintainers
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package swag
-
-import (
- "unicode"
- "unicode/utf8"
-)
-
-type (
- lexemKind uint8
-
- nameLexem struct {
- original string
- matchedInitialism string
- kind lexemKind
- }
-)
-
-const (
- lexemKindCasualName lexemKind = iota
- lexemKindInitialismName
-)
-
-func newInitialismNameLexem(original, matchedInitialism string) nameLexem {
- return nameLexem{
- kind: lexemKindInitialismName,
- original: original,
- matchedInitialism: matchedInitialism,
- }
-}
-
-func newCasualNameLexem(original string) nameLexem {
- return nameLexem{
- kind: lexemKindCasualName,
- original: original,
- }
-}
-
-func (l nameLexem) GetUnsafeGoName() string {
- if l.kind == lexemKindInitialismName {
- return l.matchedInitialism
- }
-
- var (
- first rune
- rest string
- )
-
- for i, orig := range l.original {
- if i == 0 {
- first = orig
- continue
- }
-
- if i > 0 {
- rest = l.original[i:]
- break
- }
- }
-
- if len(l.original) > 1 {
- b := poolOfBuffers.BorrowBuffer(utf8.UTFMax + len(rest))
- defer func() {
- poolOfBuffers.RedeemBuffer(b)
- }()
- b.WriteRune(unicode.ToUpper(first))
- b.WriteString(lower(rest))
- return b.String()
- }
-
- return l.original
-}
-
-func (l nameLexem) GetOriginal() string {
- return l.original
-}
-
-func (l nameLexem) IsInitialism() bool {
- return l.kind == lexemKindInitialismName
-}
diff --git a/vendor/github.com/go-openapi/swag/net.go b/vendor/github.com/go-openapi/swag/net.go
deleted file mode 100644
index 821235f8..00000000
--- a/vendor/github.com/go-openapi/swag/net.go
+++ /dev/null
@@ -1,38 +0,0 @@
-// Copyright 2015 go-swagger maintainers
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package swag
-
-import (
- "net"
- "strconv"
-)
-
-// SplitHostPort splits a network address into a host and a port.
-// The port is -1 when there is no port to be found
-func SplitHostPort(addr string) (host string, port int, err error) {
- h, p, err := net.SplitHostPort(addr)
- if err != nil {
- return "", -1, err
- }
- if p == "" {
- return "", -1, &net.AddrError{Err: "missing port in address", Addr: addr}
- }
-
- pi, err := strconv.Atoi(p)
- if err != nil {
- return "", -1, err
- }
- return h, pi, nil
-}
diff --git a/vendor/github.com/go-openapi/swag/path.go b/vendor/github.com/go-openapi/swag/path.go
deleted file mode 100644
index 941bd017..00000000
--- a/vendor/github.com/go-openapi/swag/path.go
+++ /dev/null
@@ -1,59 +0,0 @@
-// Copyright 2015 go-swagger maintainers
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package swag
-
-import (
- "os"
- "path/filepath"
- "runtime"
- "strings"
-)
-
-const (
- // GOPATHKey represents the env key for gopath
- GOPATHKey = "GOPATH"
-)
-
-// FindInSearchPath finds a package in a provided lists of paths
-func FindInSearchPath(searchPath, pkg string) string {
- pathsList := filepath.SplitList(searchPath)
- for _, path := range pathsList {
- if evaluatedPath, err := filepath.EvalSymlinks(filepath.Join(path, "src", pkg)); err == nil {
- if _, err := os.Stat(evaluatedPath); err == nil {
- return evaluatedPath
- }
- }
- }
- return ""
-}
-
-// FindInGoSearchPath finds a package in the $GOPATH:$GOROOT
-func FindInGoSearchPath(pkg string) string {
- return FindInSearchPath(FullGoSearchPath(), pkg)
-}
-
-// FullGoSearchPath gets the search paths for finding packages
-func FullGoSearchPath() string {
- allPaths := os.Getenv(GOPATHKey)
- if allPaths == "" {
- allPaths = filepath.Join(os.Getenv("HOME"), "go")
- }
- if allPaths != "" {
- allPaths = strings.Join([]string{allPaths, runtime.GOROOT()}, ":")
- } else {
- allPaths = runtime.GOROOT()
- }
- return allPaths
-}
diff --git a/vendor/github.com/go-openapi/swag/split.go b/vendor/github.com/go-openapi/swag/split.go
deleted file mode 100644
index 274727a8..00000000
--- a/vendor/github.com/go-openapi/swag/split.go
+++ /dev/null
@@ -1,508 +0,0 @@
-// Copyright 2015 go-swagger maintainers
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package swag
-
-import (
- "bytes"
- "sync"
- "unicode"
- "unicode/utf8"
-)
-
-type (
- splitter struct {
- initialisms []string
- initialismsRunes [][]rune
- initialismsUpperCased [][]rune // initialisms cached in their trimmed, upper-cased version
- postSplitInitialismCheck bool
- }
-
- splitterOption func(*splitter)
-
- initialismMatch struct {
- body []rune
- start, end int
- complete bool
- }
- initialismMatches []initialismMatch
-)
-
-type (
- // memory pools of temporary objects.
- //
- // These are used to recycle temporarily allocated objects
- // and relieve the GC from undue pressure.
-
- matchesPool struct {
- *sync.Pool
- }
-
- buffersPool struct {
- *sync.Pool
- }
-
- lexemsPool struct {
- *sync.Pool
- }
-
- splittersPool struct {
- *sync.Pool
- }
-)
-
-var (
- // poolOfMatches holds temporary slices for recycling during the initialism match process
- poolOfMatches = matchesPool{
- Pool: &sync.Pool{
- New: func() any {
- s := make(initialismMatches, 0, maxAllocMatches)
-
- return &s
- },
- },
- }
-
- poolOfBuffers = buffersPool{
- Pool: &sync.Pool{
- New: func() any {
- return new(bytes.Buffer)
- },
- },
- }
-
- poolOfLexems = lexemsPool{
- Pool: &sync.Pool{
- New: func() any {
- s := make([]nameLexem, 0, maxAllocMatches)
-
- return &s
- },
- },
- }
-
- poolOfSplitters = splittersPool{
- Pool: &sync.Pool{
- New: func() any {
- s := newSplitter()
-
- return &s
- },
- },
- }
-)
-
-// nameReplaceTable finds a word representation for special characters.
-func nameReplaceTable(r rune) (string, bool) {
- switch r {
- case '@':
- return "At ", true
- case '&':
- return "And ", true
- case '|':
- return "Pipe ", true
- case '$':
- return "Dollar ", true
- case '!':
- return "Bang ", true
- case '-':
- return "", true
- case '_':
- return "", true
- default:
- return "", false
- }
-}
-
-// split calls the splitter.
-//
-// Use newSplitter for more control and options
-func split(str string) []string {
- s := poolOfSplitters.BorrowSplitter()
- lexems := s.split(str)
- result := make([]string, 0, len(*lexems))
-
- for _, lexem := range *lexems {
- result = append(result, lexem.GetOriginal())
- }
- poolOfLexems.RedeemLexems(lexems)
- poolOfSplitters.RedeemSplitter(s)
-
- return result
-
-}
-
-func newSplitter(options ...splitterOption) splitter {
- s := splitter{
- postSplitInitialismCheck: false,
- initialisms: initialisms,
- initialismsRunes: initialismsRunes,
- initialismsUpperCased: initialismsUpperCased,
- }
-
- for _, option := range options {
- option(&s)
- }
-
- return s
-}
-
-// withPostSplitInitialismCheck allows to catch initialisms after main split process
-func withPostSplitInitialismCheck(s *splitter) {
- s.postSplitInitialismCheck = true
-}
-
-func (p matchesPool) BorrowMatches() *initialismMatches {
- s := p.Get().(*initialismMatches)
- *s = (*s)[:0] // reset slice, keep allocated capacity
-
- return s
-}
-
-func (p buffersPool) BorrowBuffer(size int) *bytes.Buffer {
- s := p.Get().(*bytes.Buffer)
- s.Reset()
-
- if s.Cap() < size {
- s.Grow(size)
- }
-
- return s
-}
-
-func (p lexemsPool) BorrowLexems() *[]nameLexem {
- s := p.Get().(*[]nameLexem)
- *s = (*s)[:0] // reset slice, keep allocated capacity
-
- return s
-}
-
-func (p splittersPool) BorrowSplitter(options ...splitterOption) *splitter {
- s := p.Get().(*splitter)
- s.postSplitInitialismCheck = false // reset options
- for _, apply := range options {
- apply(s)
- }
-
- return s
-}
-
-func (p matchesPool) RedeemMatches(s *initialismMatches) {
- p.Put(s)
-}
-
-func (p buffersPool) RedeemBuffer(s *bytes.Buffer) {
- p.Put(s)
-}
-
-func (p lexemsPool) RedeemLexems(s *[]nameLexem) {
- p.Put(s)
-}
-
-func (p splittersPool) RedeemSplitter(s *splitter) {
- p.Put(s)
-}
-
-func (m initialismMatch) isZero() bool {
- return m.start == 0 && m.end == 0
-}
-
-func (s splitter) split(name string) *[]nameLexem {
- nameRunes := []rune(name)
- matches := s.gatherInitialismMatches(nameRunes)
- if matches == nil {
- return poolOfLexems.BorrowLexems()
- }
-
- return s.mapMatchesToNameLexems(nameRunes, matches)
-}
-
-func (s splitter) gatherInitialismMatches(nameRunes []rune) *initialismMatches {
- var matches *initialismMatches
-
- for currentRunePosition, currentRune := range nameRunes {
- // recycle these allocations as we loop over runes
- // with such recycling, only 2 slices should be allocated per call
- // instead of o(n).
- newMatches := poolOfMatches.BorrowMatches()
-
- // check current initialism matches
- if matches != nil { // skip first iteration
- for _, match := range *matches {
- if keepCompleteMatch := match.complete; keepCompleteMatch {
- *newMatches = append(*newMatches, match)
- continue
- }
-
- // drop failed match
- currentMatchRune := match.body[currentRunePosition-match.start]
- if currentMatchRune != currentRune {
- continue
- }
-
- // try to complete ongoing match
- if currentRunePosition-match.start == len(match.body)-1 {
- // we are close; the next step is to check the symbol ahead
- // if it is a small letter, then it is not the end of match
- // but beginning of the next word
-
- if currentRunePosition < len(nameRunes)-1 {
- nextRune := nameRunes[currentRunePosition+1]
- if newWord := unicode.IsLower(nextRune); newWord {
- // oh ok, it was the start of a new word
- continue
- }
- }
-
- match.complete = true
- match.end = currentRunePosition
- }
-
- *newMatches = append(*newMatches, match)
- }
- }
-
- // check for new initialism matches
- for i := range s.initialisms {
- initialismRunes := s.initialismsRunes[i]
- if initialismRunes[0] == currentRune {
- *newMatches = append(*newMatches, initialismMatch{
- start: currentRunePosition,
- body: initialismRunes,
- complete: false,
- })
- }
- }
-
- if matches != nil {
- poolOfMatches.RedeemMatches(matches)
- }
- matches = newMatches
- }
-
- // up to the caller to redeem this last slice
- return matches
-}
-
-func (s splitter) mapMatchesToNameLexems(nameRunes []rune, matches *initialismMatches) *[]nameLexem {
- nameLexems := poolOfLexems.BorrowLexems()
-
- var lastAcceptedMatch initialismMatch
- for _, match := range *matches {
- if !match.complete {
- continue
- }
-
- if firstMatch := lastAcceptedMatch.isZero(); firstMatch {
- s.appendBrokenDownCasualString(nameLexems, nameRunes[:match.start])
- *nameLexems = append(*nameLexems, s.breakInitialism(string(match.body)))
-
- lastAcceptedMatch = match
-
- continue
- }
-
- if overlappedMatch := match.start <= lastAcceptedMatch.end; overlappedMatch {
- continue
- }
-
- middle := nameRunes[lastAcceptedMatch.end+1 : match.start]
- s.appendBrokenDownCasualString(nameLexems, middle)
- *nameLexems = append(*nameLexems, s.breakInitialism(string(match.body)))
-
- lastAcceptedMatch = match
- }
-
- // we have not found any accepted matches
- if lastAcceptedMatch.isZero() {
- *nameLexems = (*nameLexems)[:0]
- s.appendBrokenDownCasualString(nameLexems, nameRunes)
- } else if lastAcceptedMatch.end+1 != len(nameRunes) {
- rest := nameRunes[lastAcceptedMatch.end+1:]
- s.appendBrokenDownCasualString(nameLexems, rest)
- }
-
- poolOfMatches.RedeemMatches(matches)
-
- return nameLexems
-}
-
-func (s splitter) breakInitialism(original string) nameLexem {
- return newInitialismNameLexem(original, original)
-}
-
-func (s splitter) appendBrokenDownCasualString(segments *[]nameLexem, str []rune) {
- currentSegment := poolOfBuffers.BorrowBuffer(len(str)) // unlike strings.Builder, bytes.Buffer initial storage can reused
- defer func() {
- poolOfBuffers.RedeemBuffer(currentSegment)
- }()
-
- addCasualNameLexem := func(original string) {
- *segments = append(*segments, newCasualNameLexem(original))
- }
-
- addInitialismNameLexem := func(original, match string) {
- *segments = append(*segments, newInitialismNameLexem(original, match))
- }
-
- var addNameLexem func(string)
- if s.postSplitInitialismCheck {
- addNameLexem = func(original string) {
- for i := range s.initialisms {
- if isEqualFoldIgnoreSpace(s.initialismsUpperCased[i], original) {
- addInitialismNameLexem(original, s.initialisms[i])
-
- return
- }
- }
-
- addCasualNameLexem(original)
- }
- } else {
- addNameLexem = addCasualNameLexem
- }
-
- for _, rn := range str {
- if replace, found := nameReplaceTable(rn); found {
- if currentSegment.Len() > 0 {
- addNameLexem(currentSegment.String())
- currentSegment.Reset()
- }
-
- if replace != "" {
- addNameLexem(replace)
- }
-
- continue
- }
-
- if !unicode.In(rn, unicode.L, unicode.M, unicode.N, unicode.Pc) {
- if currentSegment.Len() > 0 {
- addNameLexem(currentSegment.String())
- currentSegment.Reset()
- }
-
- continue
- }
-
- if unicode.IsUpper(rn) {
- if currentSegment.Len() > 0 {
- addNameLexem(currentSegment.String())
- }
- currentSegment.Reset()
- }
-
- currentSegment.WriteRune(rn)
- }
-
- if currentSegment.Len() > 0 {
- addNameLexem(currentSegment.String())
- }
-}
-
-// isEqualFoldIgnoreSpace is the same as strings.EqualFold, but
-// it ignores leading and trailing blank spaces in the compared
-// string.
-//
-// base is assumed to be composed of upper-cased runes, and be already
-// trimmed.
-//
-// This code is heavily inspired from strings.EqualFold.
-func isEqualFoldIgnoreSpace(base []rune, str string) bool {
- var i, baseIndex int
- // equivalent to b := []byte(str), but without data copy
- b := hackStringBytes(str)
-
- for i < len(b) {
- if c := b[i]; c < utf8.RuneSelf {
- // fast path for ASCII
- if c != ' ' && c != '\t' {
- break
- }
- i++
-
- continue
- }
-
- // unicode case
- r, size := utf8.DecodeRune(b[i:])
- if !unicode.IsSpace(r) {
- break
- }
- i += size
- }
-
- if i >= len(b) {
- return len(base) == 0
- }
-
- for _, baseRune := range base {
- if i >= len(b) {
- break
- }
-
- if c := b[i]; c < utf8.RuneSelf {
- // single byte rune case (ASCII)
- if baseRune >= utf8.RuneSelf {
- return false
- }
-
- baseChar := byte(baseRune)
- if c != baseChar &&
- !('a' <= c && c <= 'z' && c-'a'+'A' == baseChar) {
- return false
- }
-
- baseIndex++
- i++
-
- continue
- }
-
- // unicode case
- r, size := utf8.DecodeRune(b[i:])
- if unicode.ToUpper(r) != baseRune {
- return false
- }
- baseIndex++
- i += size
- }
-
- if baseIndex != len(base) {
- return false
- }
-
- // all passed: now we should only have blanks
- for i < len(b) {
- if c := b[i]; c < utf8.RuneSelf {
- // fast path for ASCII
- if c != ' ' && c != '\t' {
- return false
- }
- i++
-
- continue
- }
-
- // unicode case
- r, size := utf8.DecodeRune(b[i:])
- if !unicode.IsSpace(r) {
- return false
- }
-
- i += size
- }
-
- return true
-}
diff --git a/vendor/github.com/go-openapi/swag/string_bytes.go b/vendor/github.com/go-openapi/swag/string_bytes.go
deleted file mode 100644
index 90745d5c..00000000
--- a/vendor/github.com/go-openapi/swag/string_bytes.go
+++ /dev/null
@@ -1,8 +0,0 @@
-package swag
-
-import "unsafe"
-
-// hackStringBytes returns the (unsafe) underlying bytes slice of a string.
-func hackStringBytes(str string) []byte {
- return unsafe.Slice(unsafe.StringData(str), len(str))
-}
diff --git a/vendor/github.com/go-openapi/swag/stringutils/LICENSE b/vendor/github.com/go-openapi/swag/stringutils/LICENSE
new file mode 100644
index 00000000..d6456956
--- /dev/null
+++ b/vendor/github.com/go-openapi/swag/stringutils/LICENSE
@@ -0,0 +1,202 @@
+
+ Apache License
+ Version 2.0, January 2004
+ http://www.apache.org/licenses/
+
+ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+ 1. Definitions.
+
+ "License" shall mean the terms and conditions for use, reproduction,
+ and distribution as defined by Sections 1 through 9 of this document.
+
+ "Licensor" shall mean the copyright owner or entity authorized by
+ the copyright owner that is granting the License.
+
+ "Legal Entity" shall mean the union of the acting entity and all
+ other entities that control, are controlled by, or are under common
+ control with that entity. For the purposes of this definition,
+ "control" means (i) the power, direct or indirect, to cause the
+ direction or management of such entity, whether by contract or
+ otherwise, or (ii) ownership of fifty percent (50%) or more of the
+ outstanding shares, or (iii) beneficial ownership of such entity.
+
+ "You" (or "Your") shall mean an individual or Legal Entity
+ exercising permissions granted by this License.
+
+ "Source" form shall mean the preferred form for making modifications,
+ including but not limited to software source code, documentation
+ source, and configuration files.
+
+ "Object" form shall mean any form resulting from mechanical
+ transformation or translation of a Source form, including but
+ not limited to compiled object code, generated documentation,
+ and conversions to other media types.
+
+ "Work" shall mean the work of authorship, whether in Source or
+ Object form, made available under the License, as indicated by a
+ copyright notice that is included in or attached to the work
+ (an example is provided in the Appendix below).
+
+ "Derivative Works" shall mean any work, whether in Source or Object
+ form, that is based on (or derived from) the Work and for which the
+ editorial revisions, annotations, elaborations, or other modifications
+ represent, as a whole, an original work of authorship. For the purposes
+ of this License, Derivative Works shall not include works that remain
+ separable from, or merely link (or bind by name) to the interfaces of,
+ the Work and Derivative Works thereof.
+
+ "Contribution" shall mean any work of authorship, including
+ the original version of the Work and any modifications or additions
+ to that Work or Derivative Works thereof, that is intentionally
+ submitted to Licensor for inclusion in the Work by the copyright owner
+ or by an individual or Legal Entity authorized to submit on behalf of
+ the copyright owner. For the purposes of this definition, "submitted"
+ means any form of electronic, verbal, or written communication sent
+ to the Licensor or its representatives, including but not limited to
+ communication on electronic mailing lists, source code control systems,
+ and issue tracking systems that are managed by, or on behalf of, the
+ Licensor for the purpose of discussing and improving the Work, but
+ excluding communication that is conspicuously marked or otherwise
+ designated in writing by the copyright owner as "Not a Contribution."
+
+ "Contributor" shall mean Licensor and any individual or Legal Entity
+ on behalf of whom a Contribution has been received by Licensor and
+ subsequently incorporated within the Work.
+
+ 2. Grant of Copyright License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ copyright license to reproduce, prepare Derivative Works of,
+ publicly display, publicly perform, sublicense, and distribute the
+ Work and such Derivative Works in Source or Object form.
+
+ 3. Grant of Patent License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ (except as stated in this section) patent license to make, have made,
+ use, offer to sell, sell, import, and otherwise transfer the Work,
+ where such license applies only to those patent claims licensable
+ by such Contributor that are necessarily infringed by their
+ Contribution(s) alone or by combination of their Contribution(s)
+ with the Work to which such Contribution(s) was submitted. If You
+ institute patent litigation against any entity (including a
+ cross-claim or counterclaim in a lawsuit) alleging that the Work
+ or a Contribution incorporated within the Work constitutes direct
+ or contributory patent infringement, then any patent licenses
+ granted to You under this License for that Work shall terminate
+ as of the date such litigation is filed.
+
+ 4. Redistribution. You may reproduce and distribute copies of the
+ Work or Derivative Works thereof in any medium, with or without
+ modifications, and in Source or Object form, provided that You
+ meet the following conditions:
+
+ (a) You must give any other recipients of the Work or
+ Derivative Works a copy of this License; and
+
+ (b) You must cause any modified files to carry prominent notices
+ stating that You changed the files; and
+
+ (c) You must retain, in the Source form of any Derivative Works
+ that You distribute, all copyright, patent, trademark, and
+ attribution notices from the Source form of the Work,
+ excluding those notices that do not pertain to any part of
+ the Derivative Works; and
+
+ (d) If the Work includes a "NOTICE" text file as part of its
+ distribution, then any Derivative Works that You distribute must
+ include a readable copy of the attribution notices contained
+ within such NOTICE file, excluding those notices that do not
+ pertain to any part of the Derivative Works, in at least one
+ of the following places: within a NOTICE text file distributed
+ as part of the Derivative Works; within the Source form or
+ documentation, if provided along with the Derivative Works; or,
+ within a display generated by the Derivative Works, if and
+ wherever such third-party notices normally appear. The contents
+ of the NOTICE file are for informational purposes only and
+ do not modify the License. You may add Your own attribution
+ notices within Derivative Works that You distribute, alongside
+ or as an addendum to the NOTICE text from the Work, provided
+ that such additional attribution notices cannot be construed
+ as modifying the License.
+
+ You may add Your own copyright statement to Your modifications and
+ may provide additional or different license terms and conditions
+ for use, reproduction, or distribution of Your modifications, or
+ for any such Derivative Works as a whole, provided Your use,
+ reproduction, and distribution of the Work otherwise complies with
+ the conditions stated in this License.
+
+ 5. Submission of Contributions. Unless You explicitly state otherwise,
+ any Contribution intentionally submitted for inclusion in the Work
+ by You to the Licensor shall be under the terms and conditions of
+ this License, without any additional terms or conditions.
+ Notwithstanding the above, nothing herein shall supersede or modify
+ the terms of any separate license agreement you may have executed
+ with Licensor regarding such Contributions.
+
+ 6. Trademarks. This License does not grant permission to use the trade
+ names, trademarks, service marks, or product names of the Licensor,
+ except as required for reasonable and customary use in describing the
+ origin of the Work and reproducing the content of the NOTICE file.
+
+ 7. Disclaimer of Warranty. Unless required by applicable law or
+ agreed to in writing, Licensor provides the Work (and each
+ Contributor provides its Contributions) on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ implied, including, without limitation, any warranties or conditions
+ of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+ PARTICULAR PURPOSE. You are solely responsible for determining the
+ appropriateness of using or redistributing the Work and assume any
+ risks associated with Your exercise of permissions under this License.
+
+ 8. Limitation of Liability. In no event and under no legal theory,
+ whether in tort (including negligence), contract, or otherwise,
+ unless required by applicable law (such as deliberate and grossly
+ negligent acts) or agreed to in writing, shall any Contributor be
+ liable to You for damages, including any direct, indirect, special,
+ incidental, or consequential damages of any character arising as a
+ result of this License or out of the use or inability to use the
+ Work (including but not limited to damages for loss of goodwill,
+ work stoppage, computer failure or malfunction, or any and all
+ other commercial damages or losses), even if such Contributor
+ has been advised of the possibility of such damages.
+
+ 9. Accepting Warranty or Additional Liability. While redistributing
+ the Work or Derivative Works thereof, You may choose to offer,
+ and charge a fee for, acceptance of support, warranty, indemnity,
+ or other liability obligations and/or rights consistent with this
+ License. However, in accepting such obligations, You may act only
+ on Your own behalf and on Your sole responsibility, not on behalf
+ of any other Contributor, and only if You agree to indemnify,
+ defend, and hold each Contributor harmless for any liability
+ incurred by, or claims asserted against, such Contributor by reason
+ of your accepting any such warranty or additional liability.
+
+ END OF TERMS AND CONDITIONS
+
+ APPENDIX: How to apply the Apache License to your work.
+
+ To apply the Apache License to your work, attach the following
+ boilerplate notice, with the fields enclosed by brackets "[]"
+ replaced with your own identifying information. (Don't include
+ the brackets!) The text should be enclosed in the appropriate
+ comment syntax for the file format. We also recommend that a
+ file or class name and description of purpose be included on the
+ same "printed page" as the copyright notice for easier
+ identification within third-party archives.
+
+ Copyright [yyyy] [name of copyright owner]
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
diff --git a/vendor/github.com/go-openapi/swag/stringutils/collection_formats.go b/vendor/github.com/go-openapi/swag/stringutils/collection_formats.go
new file mode 100644
index 00000000..28056ad2
--- /dev/null
+++ b/vendor/github.com/go-openapi/swag/stringutils/collection_formats.go
@@ -0,0 +1,74 @@
+// SPDX-FileCopyrightText: Copyright 2015-2025 go-swagger maintainers
+// SPDX-License-Identifier: Apache-2.0
+
+package stringutils
+
+import "strings"
+
+const (
+ // collectionFormatComma = "csv"
+ collectionFormatSpace = "ssv"
+ collectionFormatTab = "tsv"
+ collectionFormatPipe = "pipes"
+ collectionFormatMulti = "multi"
+
+ collectionFormatDefaultSep = ","
+)
+
+// JoinByFormat joins a string array by a known format (e.g. swagger's collectionFormat attribute):
+//
+// ssv: space separated value
+// tsv: tab separated value
+// pipes: pipe (|) separated value
+// csv: comma separated value (default)
+func JoinByFormat(data []string, format string) []string {
+ if len(data) == 0 {
+ return data
+ }
+ var sep string
+ switch format {
+ case collectionFormatSpace:
+ sep = " "
+ case collectionFormatTab:
+ sep = "\t"
+ case collectionFormatPipe:
+ sep = "|"
+ case collectionFormatMulti:
+ return data
+ default:
+ sep = collectionFormatDefaultSep
+ }
+ return []string{strings.Join(data, sep)}
+}
+
+// SplitByFormat splits a string by a known format:
+//
+// ssv: space separated value
+// tsv: tab separated value
+// pipes: pipe (|) separated value
+// csv: comma separated value (default)
+func SplitByFormat(data, format string) []string {
+ if data == "" {
+ return nil
+ }
+ var sep string
+ switch format {
+ case collectionFormatSpace:
+ sep = " "
+ case collectionFormatTab:
+ sep = "\t"
+ case collectionFormatPipe:
+ sep = "|"
+ case collectionFormatMulti:
+ return nil
+ default:
+ sep = collectionFormatDefaultSep
+ }
+ var result []string
+ for _, s := range strings.Split(data, sep) {
+ if ts := strings.TrimSpace(s); ts != "" {
+ result = append(result, ts)
+ }
+ }
+ return result
+}
diff --git a/vendor/github.com/go-openapi/swag/stringutils/doc.go b/vendor/github.com/go-openapi/swag/stringutils/doc.go
new file mode 100644
index 00000000..c6d17a11
--- /dev/null
+++ b/vendor/github.com/go-openapi/swag/stringutils/doc.go
@@ -0,0 +1,5 @@
+// SPDX-FileCopyrightText: Copyright 2015-2025 go-swagger maintainers
+// SPDX-License-Identifier: Apache-2.0
+
+// Package stringutils exposes helpers to search and process strings.
+package stringutils
diff --git a/vendor/github.com/go-openapi/swag/stringutils/strings.go b/vendor/github.com/go-openapi/swag/stringutils/strings.go
new file mode 100644
index 00000000..cd792b7d
--- /dev/null
+++ b/vendor/github.com/go-openapi/swag/stringutils/strings.go
@@ -0,0 +1,23 @@
+// SPDX-FileCopyrightText: Copyright 2015-2025 go-swagger maintainers
+// SPDX-License-Identifier: Apache-2.0
+
+package stringutils
+
+import (
+ "slices"
+ "strings"
+)
+
+// ContainsStrings searches a slice of strings for a case-sensitive match
+//
+// Now equivalent to the standard library [slice.Contains].
+func ContainsStrings(coll []string, item string) bool {
+ return slices.Contains(coll, item)
+}
+
+// ContainsStringsCI searches a slice of strings for a case-insensitive match
+func ContainsStringsCI(coll []string, item string) bool {
+ return slices.ContainsFunc(coll, func(e string) bool {
+ return strings.EqualFold(e, item)
+ })
+}
diff --git a/vendor/github.com/go-openapi/swag/typeutils/LICENSE b/vendor/github.com/go-openapi/swag/typeutils/LICENSE
new file mode 100644
index 00000000..d6456956
--- /dev/null
+++ b/vendor/github.com/go-openapi/swag/typeutils/LICENSE
@@ -0,0 +1,202 @@
+
+ Apache License
+ Version 2.0, January 2004
+ http://www.apache.org/licenses/
+
+ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+ 1. Definitions.
+
+ "License" shall mean the terms and conditions for use, reproduction,
+ and distribution as defined by Sections 1 through 9 of this document.
+
+ "Licensor" shall mean the copyright owner or entity authorized by
+ the copyright owner that is granting the License.
+
+ "Legal Entity" shall mean the union of the acting entity and all
+ other entities that control, are controlled by, or are under common
+ control with that entity. For the purposes of this definition,
+ "control" means (i) the power, direct or indirect, to cause the
+ direction or management of such entity, whether by contract or
+ otherwise, or (ii) ownership of fifty percent (50%) or more of the
+ outstanding shares, or (iii) beneficial ownership of such entity.
+
+ "You" (or "Your") shall mean an individual or Legal Entity
+ exercising permissions granted by this License.
+
+ "Source" form shall mean the preferred form for making modifications,
+ including but not limited to software source code, documentation
+ source, and configuration files.
+
+ "Object" form shall mean any form resulting from mechanical
+ transformation or translation of a Source form, including but
+ not limited to compiled object code, generated documentation,
+ and conversions to other media types.
+
+ "Work" shall mean the work of authorship, whether in Source or
+ Object form, made available under the License, as indicated by a
+ copyright notice that is included in or attached to the work
+ (an example is provided in the Appendix below).
+
+ "Derivative Works" shall mean any work, whether in Source or Object
+ form, that is based on (or derived from) the Work and for which the
+ editorial revisions, annotations, elaborations, or other modifications
+ represent, as a whole, an original work of authorship. For the purposes
+ of this License, Derivative Works shall not include works that remain
+ separable from, or merely link (or bind by name) to the interfaces of,
+ the Work and Derivative Works thereof.
+
+ "Contribution" shall mean any work of authorship, including
+ the original version of the Work and any modifications or additions
+ to that Work or Derivative Works thereof, that is intentionally
+ submitted to Licensor for inclusion in the Work by the copyright owner
+ or by an individual or Legal Entity authorized to submit on behalf of
+ the copyright owner. For the purposes of this definition, "submitted"
+ means any form of electronic, verbal, or written communication sent
+ to the Licensor or its representatives, including but not limited to
+ communication on electronic mailing lists, source code control systems,
+ and issue tracking systems that are managed by, or on behalf of, the
+ Licensor for the purpose of discussing and improving the Work, but
+ excluding communication that is conspicuously marked or otherwise
+ designated in writing by the copyright owner as "Not a Contribution."
+
+ "Contributor" shall mean Licensor and any individual or Legal Entity
+ on behalf of whom a Contribution has been received by Licensor and
+ subsequently incorporated within the Work.
+
+ 2. Grant of Copyright License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ copyright license to reproduce, prepare Derivative Works of,
+ publicly display, publicly perform, sublicense, and distribute the
+ Work and such Derivative Works in Source or Object form.
+
+ 3. Grant of Patent License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ (except as stated in this section) patent license to make, have made,
+ use, offer to sell, sell, import, and otherwise transfer the Work,
+ where such license applies only to those patent claims licensable
+ by such Contributor that are necessarily infringed by their
+ Contribution(s) alone or by combination of their Contribution(s)
+ with the Work to which such Contribution(s) was submitted. If You
+ institute patent litigation against any entity (including a
+ cross-claim or counterclaim in a lawsuit) alleging that the Work
+ or a Contribution incorporated within the Work constitutes direct
+ or contributory patent infringement, then any patent licenses
+ granted to You under this License for that Work shall terminate
+ as of the date such litigation is filed.
+
+ 4. Redistribution. You may reproduce and distribute copies of the
+ Work or Derivative Works thereof in any medium, with or without
+ modifications, and in Source or Object form, provided that You
+ meet the following conditions:
+
+ (a) You must give any other recipients of the Work or
+ Derivative Works a copy of this License; and
+
+ (b) You must cause any modified files to carry prominent notices
+ stating that You changed the files; and
+
+ (c) You must retain, in the Source form of any Derivative Works
+ that You distribute, all copyright, patent, trademark, and
+ attribution notices from the Source form of the Work,
+ excluding those notices that do not pertain to any part of
+ the Derivative Works; and
+
+ (d) If the Work includes a "NOTICE" text file as part of its
+ distribution, then any Derivative Works that You distribute must
+ include a readable copy of the attribution notices contained
+ within such NOTICE file, excluding those notices that do not
+ pertain to any part of the Derivative Works, in at least one
+ of the following places: within a NOTICE text file distributed
+ as part of the Derivative Works; within the Source form or
+ documentation, if provided along with the Derivative Works; or,
+ within a display generated by the Derivative Works, if and
+ wherever such third-party notices normally appear. The contents
+ of the NOTICE file are for informational purposes only and
+ do not modify the License. You may add Your own attribution
+ notices within Derivative Works that You distribute, alongside
+ or as an addendum to the NOTICE text from the Work, provided
+ that such additional attribution notices cannot be construed
+ as modifying the License.
+
+ You may add Your own copyright statement to Your modifications and
+ may provide additional or different license terms and conditions
+ for use, reproduction, or distribution of Your modifications, or
+ for any such Derivative Works as a whole, provided Your use,
+ reproduction, and distribution of the Work otherwise complies with
+ the conditions stated in this License.
+
+ 5. Submission of Contributions. Unless You explicitly state otherwise,
+ any Contribution intentionally submitted for inclusion in the Work
+ by You to the Licensor shall be under the terms and conditions of
+ this License, without any additional terms or conditions.
+ Notwithstanding the above, nothing herein shall supersede or modify
+ the terms of any separate license agreement you may have executed
+ with Licensor regarding such Contributions.
+
+ 6. Trademarks. This License does not grant permission to use the trade
+ names, trademarks, service marks, or product names of the Licensor,
+ except as required for reasonable and customary use in describing the
+ origin of the Work and reproducing the content of the NOTICE file.
+
+ 7. Disclaimer of Warranty. Unless required by applicable law or
+ agreed to in writing, Licensor provides the Work (and each
+ Contributor provides its Contributions) on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ implied, including, without limitation, any warranties or conditions
+ of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+ PARTICULAR PURPOSE. You are solely responsible for determining the
+ appropriateness of using or redistributing the Work and assume any
+ risks associated with Your exercise of permissions under this License.
+
+ 8. Limitation of Liability. In no event and under no legal theory,
+ whether in tort (including negligence), contract, or otherwise,
+ unless required by applicable law (such as deliberate and grossly
+ negligent acts) or agreed to in writing, shall any Contributor be
+ liable to You for damages, including any direct, indirect, special,
+ incidental, or consequential damages of any character arising as a
+ result of this License or out of the use or inability to use the
+ Work (including but not limited to damages for loss of goodwill,
+ work stoppage, computer failure or malfunction, or any and all
+ other commercial damages or losses), even if such Contributor
+ has been advised of the possibility of such damages.
+
+ 9. Accepting Warranty or Additional Liability. While redistributing
+ the Work or Derivative Works thereof, You may choose to offer,
+ and charge a fee for, acceptance of support, warranty, indemnity,
+ or other liability obligations and/or rights consistent with this
+ License. However, in accepting such obligations, You may act only
+ on Your own behalf and on Your sole responsibility, not on behalf
+ of any other Contributor, and only if You agree to indemnify,
+ defend, and hold each Contributor harmless for any liability
+ incurred by, or claims asserted against, such Contributor by reason
+ of your accepting any such warranty or additional liability.
+
+ END OF TERMS AND CONDITIONS
+
+ APPENDIX: How to apply the Apache License to your work.
+
+ To apply the Apache License to your work, attach the following
+ boilerplate notice, with the fields enclosed by brackets "[]"
+ replaced with your own identifying information. (Don't include
+ the brackets!) The text should be enclosed in the appropriate
+ comment syntax for the file format. We also recommend that a
+ file or class name and description of purpose be included on the
+ same "printed page" as the copyright notice for easier
+ identification within third-party archives.
+
+ Copyright [yyyy] [name of copyright owner]
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
diff --git a/vendor/github.com/go-openapi/swag/typeutils/doc.go b/vendor/github.com/go-openapi/swag/typeutils/doc.go
new file mode 100644
index 00000000..66bed20d
--- /dev/null
+++ b/vendor/github.com/go-openapi/swag/typeutils/doc.go
@@ -0,0 +1,5 @@
+// SPDX-FileCopyrightText: Copyright 2015-2025 go-swagger maintainers
+// SPDX-License-Identifier: Apache-2.0
+
+// Package typeutils exposes utilities to inspect generic types.
+package typeutils
diff --git a/vendor/github.com/go-openapi/swag/typeutils/types.go b/vendor/github.com/go-openapi/swag/typeutils/types.go
new file mode 100644
index 00000000..55487a67
--- /dev/null
+++ b/vendor/github.com/go-openapi/swag/typeutils/types.go
@@ -0,0 +1,80 @@
+// SPDX-FileCopyrightText: Copyright 2015-2025 go-swagger maintainers
+// SPDX-License-Identifier: Apache-2.0
+
+package typeutils
+
+import "reflect"
+
+type zeroable interface {
+ IsZero() bool
+}
+
+// IsZero returns true when the value passed into the function is a zero value.
+// This allows for safer checking of interface values.
+func IsZero(data any) bool {
+ v := reflect.ValueOf(data)
+ // check for nil data
+ switch v.Kind() { //nolint:exhaustive
+ case
+ reflect.Interface,
+ reflect.Func,
+ reflect.Chan,
+ reflect.Pointer,
+ reflect.UnsafePointer,
+ reflect.Map,
+ reflect.Slice:
+ if v.IsNil() {
+ return true
+ }
+ }
+
+ // check for things that have an IsZero method instead
+ if vv, ok := data.(zeroable); ok {
+ return vv.IsZero()
+ }
+
+ // continue with slightly more complex reflection
+ switch v.Kind() { //nolint:exhaustive
+ case reflect.String:
+ return v.Len() == 0
+ case reflect.Bool:
+ return !v.Bool()
+ case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+ return v.Int() == 0
+ case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+ return v.Uint() == 0
+ case reflect.Float32, reflect.Float64:
+ return v.Float() == 0
+ case reflect.Struct, reflect.Array:
+ return reflect.DeepEqual(data, reflect.Zero(v.Type()).Interface())
+ case reflect.Invalid:
+ return true
+ default:
+ return false
+ }
+}
+
+// IsNil checks if input is nil.
+//
+// For types chan, func, interface, map, pointer, or slice it returns true if its argument is nil.
+//
+// See [reflect.Value.IsNil].
+func IsNil(input any) bool {
+ if input == nil {
+ return true
+ }
+
+ kind := reflect.TypeOf(input).Kind()
+ switch kind { //nolint:exhaustive
+ case reflect.Pointer,
+ reflect.UnsafePointer,
+ reflect.Map,
+ reflect.Slice,
+ reflect.Chan,
+ reflect.Interface,
+ reflect.Func:
+ return reflect.ValueOf(input).IsNil()
+ default:
+ return false
+ }
+}
diff --git a/vendor/github.com/go-openapi/swag/util.go b/vendor/github.com/go-openapi/swag/util.go
deleted file mode 100644
index 5051401c..00000000
--- a/vendor/github.com/go-openapi/swag/util.go
+++ /dev/null
@@ -1,364 +0,0 @@
-// Copyright 2015 go-swagger maintainers
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package swag
-
-import (
- "reflect"
- "strings"
- "unicode"
- "unicode/utf8"
-)
-
-// GoNamePrefixFunc sets an optional rule to prefix go names
-// which do not start with a letter.
-//
-// The prefix function is assumed to return a string that starts with an upper case letter.
-//
-// e.g. to help convert "123" into "{prefix}123"
-//
-// The default is to prefix with "X"
-var GoNamePrefixFunc func(string) string
-
-func prefixFunc(name, in string) string {
- if GoNamePrefixFunc == nil {
- return "X" + in
- }
-
- return GoNamePrefixFunc(name) + in
-}
-
-const (
- // collectionFormatComma = "csv"
- collectionFormatSpace = "ssv"
- collectionFormatTab = "tsv"
- collectionFormatPipe = "pipes"
- collectionFormatMulti = "multi"
-)
-
-// JoinByFormat joins a string array by a known format (e.g. swagger's collectionFormat attribute):
-//
-// ssv: space separated value
-// tsv: tab separated value
-// pipes: pipe (|) separated value
-// csv: comma separated value (default)
-func JoinByFormat(data []string, format string) []string {
- if len(data) == 0 {
- return data
- }
- var sep string
- switch format {
- case collectionFormatSpace:
- sep = " "
- case collectionFormatTab:
- sep = "\t"
- case collectionFormatPipe:
- sep = "|"
- case collectionFormatMulti:
- return data
- default:
- sep = ","
- }
- return []string{strings.Join(data, sep)}
-}
-
-// SplitByFormat splits a string by a known format:
-//
-// ssv: space separated value
-// tsv: tab separated value
-// pipes: pipe (|) separated value
-// csv: comma separated value (default)
-func SplitByFormat(data, format string) []string {
- if data == "" {
- return nil
- }
- var sep string
- switch format {
- case collectionFormatSpace:
- sep = " "
- case collectionFormatTab:
- sep = "\t"
- case collectionFormatPipe:
- sep = "|"
- case collectionFormatMulti:
- return nil
- default:
- sep = ","
- }
- var result []string
- for _, s := range strings.Split(data, sep) {
- if ts := strings.TrimSpace(s); ts != "" {
- result = append(result, ts)
- }
- }
- return result
-}
-
-// Removes leading whitespaces
-func trim(str string) string {
- return strings.TrimSpace(str)
-}
-
-// Shortcut to strings.ToUpper()
-func upper(str string) string {
- return strings.ToUpper(trim(str))
-}
-
-// Shortcut to strings.ToLower()
-func lower(str string) string {
- return strings.ToLower(trim(str))
-}
-
-// Camelize an uppercased word
-func Camelize(word string) string {
- camelized := poolOfBuffers.BorrowBuffer(len(word))
- defer func() {
- poolOfBuffers.RedeemBuffer(camelized)
- }()
-
- for pos, ru := range []rune(word) {
- if pos > 0 {
- camelized.WriteRune(unicode.ToLower(ru))
- } else {
- camelized.WriteRune(unicode.ToUpper(ru))
- }
- }
- return camelized.String()
-}
-
-// ToFileName lowercases and underscores a go type name
-func ToFileName(name string) string {
- in := split(name)
- out := make([]string, 0, len(in))
-
- for _, w := range in {
- out = append(out, lower(w))
- }
-
- return strings.Join(out, "_")
-}
-
-// ToCommandName lowercases and underscores a go type name
-func ToCommandName(name string) string {
- in := split(name)
- out := make([]string, 0, len(in))
-
- for _, w := range in {
- out = append(out, lower(w))
- }
- return strings.Join(out, "-")
-}
-
-// ToHumanNameLower represents a code name as a human series of words
-func ToHumanNameLower(name string) string {
- s := poolOfSplitters.BorrowSplitter(withPostSplitInitialismCheck)
- in := s.split(name)
- poolOfSplitters.RedeemSplitter(s)
- out := make([]string, 0, len(*in))
-
- for _, w := range *in {
- if !w.IsInitialism() {
- out = append(out, lower(w.GetOriginal()))
- } else {
- out = append(out, trim(w.GetOriginal()))
- }
- }
- poolOfLexems.RedeemLexems(in)
-
- return strings.Join(out, " ")
-}
-
-// ToHumanNameTitle represents a code name as a human series of words with the first letters titleized
-func ToHumanNameTitle(name string) string {
- s := poolOfSplitters.BorrowSplitter(withPostSplitInitialismCheck)
- in := s.split(name)
- poolOfSplitters.RedeemSplitter(s)
-
- out := make([]string, 0, len(*in))
- for _, w := range *in {
- original := trim(w.GetOriginal())
- if !w.IsInitialism() {
- out = append(out, Camelize(original))
- } else {
- out = append(out, original)
- }
- }
- poolOfLexems.RedeemLexems(in)
-
- return strings.Join(out, " ")
-}
-
-// ToJSONName camelcases a name which can be underscored or pascal cased
-func ToJSONName(name string) string {
- in := split(name)
- out := make([]string, 0, len(in))
-
- for i, w := range in {
- if i == 0 {
- out = append(out, lower(w))
- continue
- }
- out = append(out, Camelize(trim(w)))
- }
- return strings.Join(out, "")
-}
-
-// ToVarName camelcases a name which can be underscored or pascal cased
-func ToVarName(name string) string {
- res := ToGoName(name)
- if isInitialism(res) {
- return lower(res)
- }
- if len(res) <= 1 {
- return lower(res)
- }
- return lower(res[:1]) + res[1:]
-}
-
-// ToGoName translates a swagger name which can be underscored or camel cased to a name that golint likes
-func ToGoName(name string) string {
- s := poolOfSplitters.BorrowSplitter(withPostSplitInitialismCheck)
- lexems := s.split(name)
- poolOfSplitters.RedeemSplitter(s)
- defer func() {
- poolOfLexems.RedeemLexems(lexems)
- }()
- lexemes := *lexems
-
- if len(lexemes) == 0 {
- return ""
- }
-
- result := poolOfBuffers.BorrowBuffer(len(name))
- defer func() {
- poolOfBuffers.RedeemBuffer(result)
- }()
-
- // check if not starting with a letter, upper case
- firstPart := lexemes[0].GetUnsafeGoName()
- if lexemes[0].IsInitialism() {
- firstPart = upper(firstPart)
- }
-
- if c := firstPart[0]; c < utf8.RuneSelf {
- // ASCII
- switch {
- case 'A' <= c && c <= 'Z':
- result.WriteString(firstPart)
- case 'a' <= c && c <= 'z':
- result.WriteByte(c - 'a' + 'A')
- result.WriteString(firstPart[1:])
- default:
- result.WriteString(prefixFunc(name, firstPart))
- // NOTE: no longer check if prefixFunc returns a string that starts with uppercase:
- // assume this is always the case
- }
- } else {
- // unicode
- firstRune, _ := utf8.DecodeRuneInString(firstPart)
- switch {
- case !unicode.IsLetter(firstRune):
- result.WriteString(prefixFunc(name, firstPart))
- case !unicode.IsUpper(firstRune):
- result.WriteString(prefixFunc(name, firstPart))
- /*
- result.WriteRune(unicode.ToUpper(firstRune))
- result.WriteString(firstPart[offset:])
- */
- default:
- result.WriteString(firstPart)
- }
- }
-
- for _, lexem := range lexemes[1:] {
- goName := lexem.GetUnsafeGoName()
-
- // to support old behavior
- if lexem.IsInitialism() {
- goName = upper(goName)
- }
- result.WriteString(goName)
- }
-
- return result.String()
-}
-
-// ContainsStrings searches a slice of strings for a case-sensitive match
-func ContainsStrings(coll []string, item string) bool {
- for _, a := range coll {
- if a == item {
- return true
- }
- }
- return false
-}
-
-// ContainsStringsCI searches a slice of strings for a case-insensitive match
-func ContainsStringsCI(coll []string, item string) bool {
- for _, a := range coll {
- if strings.EqualFold(a, item) {
- return true
- }
- }
- return false
-}
-
-type zeroable interface {
- IsZero() bool
-}
-
-// IsZero returns true when the value passed into the function is a zero value.
-// This allows for safer checking of interface values.
-func IsZero(data interface{}) bool {
- v := reflect.ValueOf(data)
- // check for nil data
- switch v.Kind() { //nolint:exhaustive
- case reflect.Interface, reflect.Map, reflect.Ptr, reflect.Slice:
- if v.IsNil() {
- return true
- }
- }
-
- // check for things that have an IsZero method instead
- if vv, ok := data.(zeroable); ok {
- return vv.IsZero()
- }
-
- // continue with slightly more complex reflection
- switch v.Kind() { //nolint:exhaustive
- case reflect.String:
- return v.Len() == 0
- case reflect.Bool:
- return !v.Bool()
- case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
- return v.Int() == 0
- case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
- return v.Uint() == 0
- case reflect.Float32, reflect.Float64:
- return v.Float() == 0
- case reflect.Struct, reflect.Array:
- return reflect.DeepEqual(data, reflect.Zero(v.Type()).Interface())
- case reflect.Invalid:
- return true
- default:
- return false
- }
-}
-
-// CommandLineOptionsGroup represents a group of user-defined command line options
-type CommandLineOptionsGroup struct {
- ShortDescription string
- LongDescription string
- Options interface{}
-}
diff --git a/vendor/github.com/go-openapi/swag/yaml.go b/vendor/github.com/go-openapi/swag/yaml.go
deleted file mode 100644
index 57534653..00000000
--- a/vendor/github.com/go-openapi/swag/yaml.go
+++ /dev/null
@@ -1,481 +0,0 @@
-// Copyright 2015 go-swagger maintainers
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package swag
-
-import (
- "encoding/json"
- "fmt"
- "path/filepath"
- "reflect"
- "sort"
- "strconv"
-
- "github.com/mailru/easyjson/jlexer"
- "github.com/mailru/easyjson/jwriter"
- yaml "gopkg.in/yaml.v3"
-)
-
-// YAMLMatcher matches yaml
-func YAMLMatcher(path string) bool {
- ext := filepath.Ext(path)
- return ext == ".yaml" || ext == ".yml"
-}
-
-// YAMLToJSON converts YAML unmarshaled data into json compatible data
-func YAMLToJSON(data interface{}) (json.RawMessage, error) {
- jm, err := transformData(data)
- if err != nil {
- return nil, err
- }
- b, err := WriteJSON(jm)
- return json.RawMessage(b), err
-}
-
-// BytesToYAMLDoc converts a byte slice into a YAML document
-func BytesToYAMLDoc(data []byte) (interface{}, error) {
- var document yaml.Node // preserve order that is present in the document
- if err := yaml.Unmarshal(data, &document); err != nil {
- return nil, err
- }
- if document.Kind != yaml.DocumentNode || len(document.Content) != 1 || document.Content[0].Kind != yaml.MappingNode {
- return nil, fmt.Errorf("only YAML documents that are objects are supported: %w", ErrYAML)
- }
- return &document, nil
-}
-
-func yamlNode(root *yaml.Node) (interface{}, error) {
- switch root.Kind {
- case yaml.DocumentNode:
- return yamlDocument(root)
- case yaml.SequenceNode:
- return yamlSequence(root)
- case yaml.MappingNode:
- return yamlMapping(root)
- case yaml.ScalarNode:
- return yamlScalar(root)
- case yaml.AliasNode:
- return yamlNode(root.Alias)
- default:
- return nil, fmt.Errorf("unsupported YAML node type: %v: %w", root.Kind, ErrYAML)
- }
-}
-
-func yamlDocument(node *yaml.Node) (interface{}, error) {
- if len(node.Content) != 1 {
- return nil, fmt.Errorf("unexpected YAML Document node content length: %d: %w", len(node.Content), ErrYAML)
- }
- return yamlNode(node.Content[0])
-}
-
-func yamlMapping(node *yaml.Node) (interface{}, error) {
- const sensibleAllocDivider = 2
- m := make(JSONMapSlice, len(node.Content)/sensibleAllocDivider)
-
- var j int
- for i := 0; i < len(node.Content); i += 2 {
- var nmi JSONMapItem
- k, err := yamlStringScalarC(node.Content[i])
- if err != nil {
- return nil, fmt.Errorf("unable to decode YAML map key: %w: %w", err, ErrYAML)
- }
- nmi.Key = k
- v, err := yamlNode(node.Content[i+1])
- if err != nil {
- return nil, fmt.Errorf("unable to process YAML map value for key %q: %w: %w", k, err, ErrYAML)
- }
- nmi.Value = v
- m[j] = nmi
- j++
- }
- return m, nil
-}
-
-func yamlSequence(node *yaml.Node) (interface{}, error) {
- s := make([]interface{}, 0)
-
- for i := 0; i < len(node.Content); i++ {
-
- v, err := yamlNode(node.Content[i])
- if err != nil {
- return nil, fmt.Errorf("unable to decode YAML sequence value: %w: %w", err, ErrYAML)
- }
- s = append(s, v)
- }
- return s, nil
-}
-
-const ( // See https://yaml.org/type/
- yamlStringScalar = "tag:yaml.org,2002:str"
- yamlIntScalar = "tag:yaml.org,2002:int"
- yamlBoolScalar = "tag:yaml.org,2002:bool"
- yamlFloatScalar = "tag:yaml.org,2002:float"
- yamlTimestamp = "tag:yaml.org,2002:timestamp"
- yamlNull = "tag:yaml.org,2002:null"
-)
-
-func yamlScalar(node *yaml.Node) (interface{}, error) {
- switch node.LongTag() {
- case yamlStringScalar:
- return node.Value, nil
- case yamlBoolScalar:
- b, err := strconv.ParseBool(node.Value)
- if err != nil {
- return nil, fmt.Errorf("unable to process scalar node. Got %q. Expecting bool content: %w: %w", node.Value, err, ErrYAML)
- }
- return b, nil
- case yamlIntScalar:
- i, err := strconv.ParseInt(node.Value, 10, 64)
- if err != nil {
- return nil, fmt.Errorf("unable to process scalar node. Got %q. Expecting integer content: %w: %w", node.Value, err, ErrYAML)
- }
- return i, nil
- case yamlFloatScalar:
- f, err := strconv.ParseFloat(node.Value, 64)
- if err != nil {
- return nil, fmt.Errorf("unable to process scalar node. Got %q. Expecting float content: %w: %w", node.Value, err, ErrYAML)
- }
- return f, nil
- case yamlTimestamp:
- return node.Value, nil
- case yamlNull:
- return nil, nil //nolint:nilnil
- default:
- return nil, fmt.Errorf("YAML tag %q is not supported: %w", node.LongTag(), ErrYAML)
- }
-}
-
-func yamlStringScalarC(node *yaml.Node) (string, error) {
- if node.Kind != yaml.ScalarNode {
- return "", fmt.Errorf("expecting a string scalar but got %q: %w", node.Kind, ErrYAML)
- }
- switch node.LongTag() {
- case yamlStringScalar, yamlIntScalar, yamlFloatScalar:
- return node.Value, nil
- default:
- return "", fmt.Errorf("YAML tag %q is not supported as map key: %w", node.LongTag(), ErrYAML)
- }
-}
-
-// JSONMapSlice represent a JSON object, with the order of keys maintained
-type JSONMapSlice []JSONMapItem
-
-// MarshalJSON renders a JSONMapSlice as JSON
-func (s JSONMapSlice) MarshalJSON() ([]byte, error) {
- w := &jwriter.Writer{Flags: jwriter.NilMapAsEmpty | jwriter.NilSliceAsEmpty}
- s.MarshalEasyJSON(w)
- return w.BuildBytes()
-}
-
-// MarshalEasyJSON renders a JSONMapSlice as JSON, using easyJSON
-func (s JSONMapSlice) MarshalEasyJSON(w *jwriter.Writer) {
- w.RawByte('{')
-
- ln := len(s)
- last := ln - 1
- for i := 0; i < ln; i++ {
- s[i].MarshalEasyJSON(w)
- if i != last { // last item
- w.RawByte(',')
- }
- }
-
- w.RawByte('}')
-}
-
-// UnmarshalJSON makes a JSONMapSlice from JSON
-func (s *JSONMapSlice) UnmarshalJSON(data []byte) error {
- l := jlexer.Lexer{Data: data}
- s.UnmarshalEasyJSON(&l)
- return l.Error()
-}
-
-// UnmarshalEasyJSON makes a JSONMapSlice from JSON, using easyJSON
-func (s *JSONMapSlice) UnmarshalEasyJSON(in *jlexer.Lexer) {
- if in.IsNull() {
- in.Skip()
- return
- }
-
- var result JSONMapSlice
- in.Delim('{')
- for !in.IsDelim('}') {
- var mi JSONMapItem
- mi.UnmarshalEasyJSON(in)
- result = append(result, mi)
- }
- *s = result
-}
-
-func (s JSONMapSlice) MarshalYAML() (interface{}, error) {
- var n yaml.Node
- n.Kind = yaml.DocumentNode
- var nodes []*yaml.Node
- for _, item := range s {
- nn, err := json2yaml(item.Value)
- if err != nil {
- return nil, err
- }
- ns := []*yaml.Node{
- {
- Kind: yaml.ScalarNode,
- Tag: yamlStringScalar,
- Value: item.Key,
- },
- nn,
- }
- nodes = append(nodes, ns...)
- }
-
- n.Content = []*yaml.Node{
- {
- Kind: yaml.MappingNode,
- Content: nodes,
- },
- }
-
- return yaml.Marshal(&n)
-}
-
-func isNil(input interface{}) bool {
- if input == nil {
- return true
- }
- kind := reflect.TypeOf(input).Kind()
- switch kind { //nolint:exhaustive
- case reflect.Ptr, reflect.Map, reflect.Slice, reflect.Chan:
- return reflect.ValueOf(input).IsNil()
- default:
- return false
- }
-}
-
-func json2yaml(item interface{}) (*yaml.Node, error) {
- if isNil(item) {
- return &yaml.Node{
- Kind: yaml.ScalarNode,
- Value: "null",
- }, nil
- }
-
- switch val := item.(type) {
- case JSONMapSlice:
- var n yaml.Node
- n.Kind = yaml.MappingNode
- for i := range val {
- childNode, err := json2yaml(&val[i].Value)
- if err != nil {
- return nil, err
- }
- n.Content = append(n.Content, &yaml.Node{
- Kind: yaml.ScalarNode,
- Tag: yamlStringScalar,
- Value: val[i].Key,
- }, childNode)
- }
- return &n, nil
- case map[string]interface{}:
- var n yaml.Node
- n.Kind = yaml.MappingNode
- keys := make([]string, 0, len(val))
- for k := range val {
- keys = append(keys, k)
- }
- sort.Strings(keys)
-
- for _, k := range keys {
- v := val[k]
- childNode, err := json2yaml(v)
- if err != nil {
- return nil, err
- }
- n.Content = append(n.Content, &yaml.Node{
- Kind: yaml.ScalarNode,
- Tag: yamlStringScalar,
- Value: k,
- }, childNode)
- }
- return &n, nil
- case []interface{}:
- var n yaml.Node
- n.Kind = yaml.SequenceNode
- for i := range val {
- childNode, err := json2yaml(val[i])
- if err != nil {
- return nil, err
- }
- n.Content = append(n.Content, childNode)
- }
- return &n, nil
- case string:
- return &yaml.Node{
- Kind: yaml.ScalarNode,
- Tag: yamlStringScalar,
- Value: val,
- }, nil
- case float64:
- return &yaml.Node{
- Kind: yaml.ScalarNode,
- Tag: yamlFloatScalar,
- Value: strconv.FormatFloat(val, 'f', -1, 64),
- }, nil
- case int64:
- return &yaml.Node{
- Kind: yaml.ScalarNode,
- Tag: yamlIntScalar,
- Value: strconv.FormatInt(val, 10),
- }, nil
- case uint64:
- return &yaml.Node{
- Kind: yaml.ScalarNode,
- Tag: yamlIntScalar,
- Value: strconv.FormatUint(val, 10),
- }, nil
- case bool:
- return &yaml.Node{
- Kind: yaml.ScalarNode,
- Tag: yamlBoolScalar,
- Value: strconv.FormatBool(val),
- }, nil
- default:
- return nil, fmt.Errorf("unhandled type: %T: %w", val, ErrYAML)
- }
-}
-
-// JSONMapItem represents the value of a key in a JSON object held by JSONMapSlice
-type JSONMapItem struct {
- Key string
- Value interface{}
-}
-
-// MarshalJSON renders a JSONMapItem as JSON
-func (s JSONMapItem) MarshalJSON() ([]byte, error) {
- w := &jwriter.Writer{Flags: jwriter.NilMapAsEmpty | jwriter.NilSliceAsEmpty}
- s.MarshalEasyJSON(w)
- return w.BuildBytes()
-}
-
-// MarshalEasyJSON renders a JSONMapItem as JSON, using easyJSON
-func (s JSONMapItem) MarshalEasyJSON(w *jwriter.Writer) {
- w.String(s.Key)
- w.RawByte(':')
- w.Raw(WriteJSON(s.Value))
-}
-
-// UnmarshalJSON makes a JSONMapItem from JSON
-func (s *JSONMapItem) UnmarshalJSON(data []byte) error {
- l := jlexer.Lexer{Data: data}
- s.UnmarshalEasyJSON(&l)
- return l.Error()
-}
-
-// UnmarshalEasyJSON makes a JSONMapItem from JSON, using easyJSON
-func (s *JSONMapItem) UnmarshalEasyJSON(in *jlexer.Lexer) {
- key := in.UnsafeString()
- in.WantColon()
- value := in.Interface()
- in.WantComma()
- s.Key = key
- s.Value = value
-}
-
-func transformData(input interface{}) (out interface{}, err error) {
- format := func(t interface{}) (string, error) {
- switch k := t.(type) {
- case string:
- return k, nil
- case uint:
- return strconv.FormatUint(uint64(k), 10), nil
- case uint8:
- return strconv.FormatUint(uint64(k), 10), nil
- case uint16:
- return strconv.FormatUint(uint64(k), 10), nil
- case uint32:
- return strconv.FormatUint(uint64(k), 10), nil
- case uint64:
- return strconv.FormatUint(k, 10), nil
- case int:
- return strconv.Itoa(k), nil
- case int8:
- return strconv.FormatInt(int64(k), 10), nil
- case int16:
- return strconv.FormatInt(int64(k), 10), nil
- case int32:
- return strconv.FormatInt(int64(k), 10), nil
- case int64:
- return strconv.FormatInt(k, 10), nil
- default:
- return "", fmt.Errorf("unexpected map key type, got: %T: %w", k, ErrYAML)
- }
- }
-
- switch in := input.(type) {
- case yaml.Node:
- return yamlNode(&in)
- case *yaml.Node:
- return yamlNode(in)
- case map[interface{}]interface{}:
- o := make(JSONMapSlice, 0, len(in))
- for ke, va := range in {
- var nmi JSONMapItem
- if nmi.Key, err = format(ke); err != nil {
- return nil, err
- }
-
- v, ert := transformData(va)
- if ert != nil {
- return nil, ert
- }
- nmi.Value = v
- o = append(o, nmi)
- }
- return o, nil
- case []interface{}:
- len1 := len(in)
- o := make([]interface{}, len1)
- for i := 0; i < len1; i++ {
- o[i], err = transformData(in[i])
- if err != nil {
- return nil, err
- }
- }
- return o, nil
- }
- return input, nil
-}
-
-// YAMLDoc loads a yaml document from either http or a file and converts it to json
-func YAMLDoc(path string) (json.RawMessage, error) {
- yamlDoc, err := YAMLData(path)
- if err != nil {
- return nil, err
- }
-
- data, err := YAMLToJSON(yamlDoc)
- if err != nil {
- return nil, err
- }
-
- return data, nil
-}
-
-// YAMLData loads a yaml document from either http or a file
-func YAMLData(path string) (interface{}, error) {
- data, err := LoadFromFileOrHTTP(path)
- if err != nil {
- return nil, err
- }
-
- return BytesToYAMLDoc(data)
-}
diff --git a/vendor/github.com/go-openapi/swag/yamlutils/LICENSE b/vendor/github.com/go-openapi/swag/yamlutils/LICENSE
new file mode 100644
index 00000000..d6456956
--- /dev/null
+++ b/vendor/github.com/go-openapi/swag/yamlutils/LICENSE
@@ -0,0 +1,202 @@
+
+ Apache License
+ Version 2.0, January 2004
+ http://www.apache.org/licenses/
+
+ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+ 1. Definitions.
+
+ "License" shall mean the terms and conditions for use, reproduction,
+ and distribution as defined by Sections 1 through 9 of this document.
+
+ "Licensor" shall mean the copyright owner or entity authorized by
+ the copyright owner that is granting the License.
+
+ "Legal Entity" shall mean the union of the acting entity and all
+ other entities that control, are controlled by, or are under common
+ control with that entity. For the purposes of this definition,
+ "control" means (i) the power, direct or indirect, to cause the
+ direction or management of such entity, whether by contract or
+ otherwise, or (ii) ownership of fifty percent (50%) or more of the
+ outstanding shares, or (iii) beneficial ownership of such entity.
+
+ "You" (or "Your") shall mean an individual or Legal Entity
+ exercising permissions granted by this License.
+
+ "Source" form shall mean the preferred form for making modifications,
+ including but not limited to software source code, documentation
+ source, and configuration files.
+
+ "Object" form shall mean any form resulting from mechanical
+ transformation or translation of a Source form, including but
+ not limited to compiled object code, generated documentation,
+ and conversions to other media types.
+
+ "Work" shall mean the work of authorship, whether in Source or
+ Object form, made available under the License, as indicated by a
+ copyright notice that is included in or attached to the work
+ (an example is provided in the Appendix below).
+
+ "Derivative Works" shall mean any work, whether in Source or Object
+ form, that is based on (or derived from) the Work and for which the
+ editorial revisions, annotations, elaborations, or other modifications
+ represent, as a whole, an original work of authorship. For the purposes
+ of this License, Derivative Works shall not include works that remain
+ separable from, or merely link (or bind by name) to the interfaces of,
+ the Work and Derivative Works thereof.
+
+ "Contribution" shall mean any work of authorship, including
+ the original version of the Work and any modifications or additions
+ to that Work or Derivative Works thereof, that is intentionally
+ submitted to Licensor for inclusion in the Work by the copyright owner
+ or by an individual or Legal Entity authorized to submit on behalf of
+ the copyright owner. For the purposes of this definition, "submitted"
+ means any form of electronic, verbal, or written communication sent
+ to the Licensor or its representatives, including but not limited to
+ communication on electronic mailing lists, source code control systems,
+ and issue tracking systems that are managed by, or on behalf of, the
+ Licensor for the purpose of discussing and improving the Work, but
+ excluding communication that is conspicuously marked or otherwise
+ designated in writing by the copyright owner as "Not a Contribution."
+
+ "Contributor" shall mean Licensor and any individual or Legal Entity
+ on behalf of whom a Contribution has been received by Licensor and
+ subsequently incorporated within the Work.
+
+ 2. Grant of Copyright License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ copyright license to reproduce, prepare Derivative Works of,
+ publicly display, publicly perform, sublicense, and distribute the
+ Work and such Derivative Works in Source or Object form.
+
+ 3. Grant of Patent License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ (except as stated in this section) patent license to make, have made,
+ use, offer to sell, sell, import, and otherwise transfer the Work,
+ where such license applies only to those patent claims licensable
+ by such Contributor that are necessarily infringed by their
+ Contribution(s) alone or by combination of their Contribution(s)
+ with the Work to which such Contribution(s) was submitted. If You
+ institute patent litigation against any entity (including a
+ cross-claim or counterclaim in a lawsuit) alleging that the Work
+ or a Contribution incorporated within the Work constitutes direct
+ or contributory patent infringement, then any patent licenses
+ granted to You under this License for that Work shall terminate
+ as of the date such litigation is filed.
+
+ 4. Redistribution. You may reproduce and distribute copies of the
+ Work or Derivative Works thereof in any medium, with or without
+ modifications, and in Source or Object form, provided that You
+ meet the following conditions:
+
+ (a) You must give any other recipients of the Work or
+ Derivative Works a copy of this License; and
+
+ (b) You must cause any modified files to carry prominent notices
+ stating that You changed the files; and
+
+ (c) You must retain, in the Source form of any Derivative Works
+ that You distribute, all copyright, patent, trademark, and
+ attribution notices from the Source form of the Work,
+ excluding those notices that do not pertain to any part of
+ the Derivative Works; and
+
+ (d) If the Work includes a "NOTICE" text file as part of its
+ distribution, then any Derivative Works that You distribute must
+ include a readable copy of the attribution notices contained
+ within such NOTICE file, excluding those notices that do not
+ pertain to any part of the Derivative Works, in at least one
+ of the following places: within a NOTICE text file distributed
+ as part of the Derivative Works; within the Source form or
+ documentation, if provided along with the Derivative Works; or,
+ within a display generated by the Derivative Works, if and
+ wherever such third-party notices normally appear. The contents
+ of the NOTICE file are for informational purposes only and
+ do not modify the License. You may add Your own attribution
+ notices within Derivative Works that You distribute, alongside
+ or as an addendum to the NOTICE text from the Work, provided
+ that such additional attribution notices cannot be construed
+ as modifying the License.
+
+ You may add Your own copyright statement to Your modifications and
+ may provide additional or different license terms and conditions
+ for use, reproduction, or distribution of Your modifications, or
+ for any such Derivative Works as a whole, provided Your use,
+ reproduction, and distribution of the Work otherwise complies with
+ the conditions stated in this License.
+
+ 5. Submission of Contributions. Unless You explicitly state otherwise,
+ any Contribution intentionally submitted for inclusion in the Work
+ by You to the Licensor shall be under the terms and conditions of
+ this License, without any additional terms or conditions.
+ Notwithstanding the above, nothing herein shall supersede or modify
+ the terms of any separate license agreement you may have executed
+ with Licensor regarding such Contributions.
+
+ 6. Trademarks. This License does not grant permission to use the trade
+ names, trademarks, service marks, or product names of the Licensor,
+ except as required for reasonable and customary use in describing the
+ origin of the Work and reproducing the content of the NOTICE file.
+
+ 7. Disclaimer of Warranty. Unless required by applicable law or
+ agreed to in writing, Licensor provides the Work (and each
+ Contributor provides its Contributions) on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ implied, including, without limitation, any warranties or conditions
+ of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+ PARTICULAR PURPOSE. You are solely responsible for determining the
+ appropriateness of using or redistributing the Work and assume any
+ risks associated with Your exercise of permissions under this License.
+
+ 8. Limitation of Liability. In no event and under no legal theory,
+ whether in tort (including negligence), contract, or otherwise,
+ unless required by applicable law (such as deliberate and grossly
+ negligent acts) or agreed to in writing, shall any Contributor be
+ liable to You for damages, including any direct, indirect, special,
+ incidental, or consequential damages of any character arising as a
+ result of this License or out of the use or inability to use the
+ Work (including but not limited to damages for loss of goodwill,
+ work stoppage, computer failure or malfunction, or any and all
+ other commercial damages or losses), even if such Contributor
+ has been advised of the possibility of such damages.
+
+ 9. Accepting Warranty or Additional Liability. While redistributing
+ the Work or Derivative Works thereof, You may choose to offer,
+ and charge a fee for, acceptance of support, warranty, indemnity,
+ or other liability obligations and/or rights consistent with this
+ License. However, in accepting such obligations, You may act only
+ on Your own behalf and on Your sole responsibility, not on behalf
+ of any other Contributor, and only if You agree to indemnify,
+ defend, and hold each Contributor harmless for any liability
+ incurred by, or claims asserted against, such Contributor by reason
+ of your accepting any such warranty or additional liability.
+
+ END OF TERMS AND CONDITIONS
+
+ APPENDIX: How to apply the Apache License to your work.
+
+ To apply the Apache License to your work, attach the following
+ boilerplate notice, with the fields enclosed by brackets "[]"
+ replaced with your own identifying information. (Don't include
+ the brackets!) The text should be enclosed in the appropriate
+ comment syntax for the file format. We also recommend that a
+ file or class name and description of purpose be included on the
+ same "printed page" as the copyright notice for easier
+ identification within third-party archives.
+
+ Copyright [yyyy] [name of copyright owner]
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
diff --git a/vendor/github.com/go-openapi/swag/yamlutils/doc.go b/vendor/github.com/go-openapi/swag/yamlutils/doc.go
new file mode 100644
index 00000000..7bb92a82
--- /dev/null
+++ b/vendor/github.com/go-openapi/swag/yamlutils/doc.go
@@ -0,0 +1,13 @@
+// SPDX-FileCopyrightText: Copyright 2015-2025 go-swagger maintainers
+// SPDX-License-Identifier: Apache-2.0
+
+// Package yamlutils provides utilities to work with YAML documents.
+//
+// - [BytesToYAMLDoc] to construct a [yaml.Node] document
+// - [YAMLToJSON] to convert a [yaml.Node] document to JSON bytes
+// - [YAMLMapSlice] to serialize and deserialize YAML with the order of keys maintained
+package yamlutils
+
+import (
+ _ "go.yaml.in/yaml/v3" // for documentation purpose only
+)
diff --git a/vendor/github.com/go-openapi/swag/yamlutils/errors.go b/vendor/github.com/go-openapi/swag/yamlutils/errors.go
new file mode 100644
index 00000000..e87bc5e8
--- /dev/null
+++ b/vendor/github.com/go-openapi/swag/yamlutils/errors.go
@@ -0,0 +1,15 @@
+// SPDX-FileCopyrightText: Copyright 2015-2025 go-swagger maintainers
+// SPDX-License-Identifier: Apache-2.0
+
+package yamlutils
+
+type yamlError string
+
+const (
+ // ErrYAML is an error raised by YAML utilities
+ ErrYAML yamlError = "yaml error"
+)
+
+func (e yamlError) Error() string {
+ return string(e)
+}
diff --git a/vendor/github.com/go-openapi/swag/yamlutils/ordered_map.go b/vendor/github.com/go-openapi/swag/yamlutils/ordered_map.go
new file mode 100644
index 00000000..3daf68db
--- /dev/null
+++ b/vendor/github.com/go-openapi/swag/yamlutils/ordered_map.go
@@ -0,0 +1,316 @@
+// SPDX-FileCopyrightText: Copyright 2015-2025 go-swagger maintainers
+// SPDX-License-Identifier: Apache-2.0
+
+package yamlutils
+
+import (
+ "fmt"
+ "iter"
+ "slices"
+ "sort"
+ "strconv"
+
+ "github.com/go-openapi/swag/conv"
+ "github.com/go-openapi/swag/jsonutils"
+ "github.com/go-openapi/swag/jsonutils/adapters/ifaces"
+ "github.com/go-openapi/swag/typeutils"
+ yaml "go.yaml.in/yaml/v3"
+)
+
+var (
+ _ yaml.Marshaler = YAMLMapSlice{}
+ _ yaml.Unmarshaler = &YAMLMapSlice{}
+)
+
+// YAMLMapSlice represents a YAML object, with the order of keys maintained.
+//
+// It is similar to [jsonutils.JSONMapSlice] and also knows how to marshal and unmarshal YAML.
+//
+// It behaves like an ordered map, but keys can't be accessed in constant time.
+type YAMLMapSlice []YAMLMapItem
+
+// YAMLMapItem represents the value of a key in a YAML object held by [YAMLMapSlice].
+//
+// It is entirely equivalent to [jsonutils.JSONMapItem], with the same limitation that
+// you should not Marshal or Unmarshal directly this type, outside of a [YAMLMapSlice].
+type YAMLMapItem = jsonutils.JSONMapItem
+
+func (s YAMLMapSlice) OrderedItems() iter.Seq2[string, any] {
+ return func(yield func(string, any) bool) {
+ for _, item := range s {
+ if !yield(item.Key, item.Value) {
+ return
+ }
+ }
+ }
+}
+
+// SetOrderedItems implements [ifaces.SetOrdered]: it merges keys passed by the iterator argument
+// into the [YAMLMapSlice].
+func (s *YAMLMapSlice) SetOrderedItems(items iter.Seq2[string, any]) {
+ if items == nil {
+ // force receiver to be a nil slice
+ *s = nil
+
+ return
+ }
+
+ m := *s
+ if len(m) > 0 {
+ // update mode: short-circuited when unmarshaling fresh data structures
+ idx := make(map[string]int, len(m))
+
+ for i, item := range m {
+ idx[item.Key] = i
+ }
+
+ for k, v := range items {
+ idx, ok := idx[k]
+ if ok {
+ m[idx].Value = v
+
+ continue
+ }
+
+ m = append(m, YAMLMapItem{Key: k, Value: v})
+ }
+
+ *s = m
+
+ return
+ }
+
+ for k, v := range items {
+ m = append(m, YAMLMapItem{Key: k, Value: v})
+ }
+
+ *s = m
+}
+
+// MarshalJSON renders this YAML object as JSON bytes.
+//
+// The difference with standard JSON marshaling is that the order of keys is maintained.
+func (s YAMLMapSlice) MarshalJSON() ([]byte, error) {
+ return jsonutils.JSONMapSlice(s).MarshalJSON()
+}
+
+// UnmarshalJSON builds this YAML object from JSON bytes.
+//
+// The difference with standard JSON marshaling is that the order of keys is maintained.
+func (s *YAMLMapSlice) UnmarshalJSON(data []byte) error {
+ js := jsonutils.JSONMapSlice(*s)
+
+ if err := js.UnmarshalJSON(data); err != nil {
+ return err
+ }
+
+ *s = YAMLMapSlice(js)
+
+ return nil
+}
+
+// MarshalYAML produces a YAML document as bytes
+//
+// The difference with standard YAML marshaling is that the order of keys is maintained.
+//
+// It implements [yaml.Marshaler].
+func (s YAMLMapSlice) MarshalYAML() (any, error) {
+ if typeutils.IsNil(s) {
+ return []byte("null\n"), nil
+ }
+ var n yaml.Node
+ n.Kind = yaml.DocumentNode
+ var nodes []*yaml.Node
+
+ for _, item := range s {
+ nn, err := json2yaml(item.Value)
+ if err != nil {
+ return nil, err
+ }
+
+ ns := []*yaml.Node{
+ {
+ Kind: yaml.ScalarNode,
+ Tag: yamlStringScalar,
+ Value: item.Key,
+ },
+ nn,
+ }
+ nodes = append(nodes, ns...)
+ }
+
+ n.Content = []*yaml.Node{
+ {
+ Kind: yaml.MappingNode,
+ Content: nodes,
+ },
+ }
+
+ return yaml.Marshal(&n)
+}
+
+// UnmarshalYAML builds a YAMLMapSlice object from a YAML document [yaml.Node].
+//
+// It implements [yaml.Unmarshaler].
+func (s *YAMLMapSlice) UnmarshalYAML(node *yaml.Node) error {
+ if typeutils.IsNil(*s) {
+ // allow to unmarshal with a simple var declaration (nil slice)
+ *s = YAMLMapSlice{}
+ }
+ if node == nil {
+ *s = nil
+ return nil
+ }
+
+ const sensibleAllocDivider = 2
+ m := slices.Grow(*s, len(node.Content)/sensibleAllocDivider)
+ m = m[:0]
+
+ for i := 0; i < len(node.Content); i += 2 {
+ var nmi YAMLMapItem
+ k, err := yamlStringScalarC(node.Content[i])
+ if err != nil {
+ return fmt.Errorf("unable to decode YAML map key: %w: %w", err, ErrYAML)
+ }
+ nmi.Key = k
+ v, err := yamlNode(node.Content[i+1])
+ if err != nil {
+ return fmt.Errorf("unable to process YAML map value for key %q: %w: %w", k, err, ErrYAML)
+ }
+ nmi.Value = v
+ m = append(m, nmi)
+ }
+
+ *s = m
+
+ return nil
+}
+
+func json2yaml(item any) (*yaml.Node, error) {
+ if typeutils.IsNil(item) {
+ return &yaml.Node{
+ Kind: yaml.ScalarNode,
+ Value: "null",
+ }, nil
+ }
+
+ switch val := item.(type) {
+ case ifaces.Ordered:
+ return orderedYAML(val)
+
+ case map[string]any:
+ var n yaml.Node
+ n.Kind = yaml.MappingNode
+ keys := make([]string, 0, len(val))
+ for k := range val {
+ keys = append(keys, k)
+ }
+ sort.Strings(keys)
+
+ for _, k := range keys {
+ v := val[k]
+ childNode, err := json2yaml(v)
+ if err != nil {
+ return nil, err
+ }
+ n.Content = append(n.Content, &yaml.Node{
+ Kind: yaml.ScalarNode,
+ Tag: yamlStringScalar,
+ Value: k,
+ }, childNode)
+ }
+ return &n, nil
+
+ case []any:
+ var n yaml.Node
+ n.Kind = yaml.SequenceNode
+ for i := range val {
+ childNode, err := json2yaml(val[i])
+ if err != nil {
+ return nil, err
+ }
+ n.Content = append(n.Content, childNode)
+ }
+ return &n, nil
+ case string:
+ return &yaml.Node{
+ Kind: yaml.ScalarNode,
+ Tag: yamlStringScalar,
+ Value: val,
+ }, nil
+ case float32:
+ return floatNode(val)
+ case float64:
+ return floatNode(val)
+ case int:
+ return integerNode(val)
+ case int8:
+ return integerNode(val)
+ case int16:
+ return integerNode(val)
+ case int32:
+ return integerNode(val)
+ case int64:
+ return integerNode(val)
+ case uint:
+ return uintegerNode(val)
+ case uint8:
+ return uintegerNode(val)
+ case uint16:
+ return uintegerNode(val)
+ case uint32:
+ return uintegerNode(val)
+ case uint64:
+ return uintegerNode(val)
+ case bool:
+ return &yaml.Node{
+ Kind: yaml.ScalarNode,
+ Tag: yamlBoolScalar,
+ Value: strconv.FormatBool(val),
+ }, nil
+ default:
+ return nil, fmt.Errorf("unhandled type: %T: %w", val, ErrYAML)
+ }
+}
+
+func floatNode[T conv.Float](val T) (*yaml.Node, error) {
+ return &yaml.Node{
+ Kind: yaml.ScalarNode,
+ Tag: yamlFloatScalar,
+ Value: conv.FormatFloat(val),
+ }, nil
+}
+
+func integerNode[T conv.Signed](val T) (*yaml.Node, error) {
+ return &yaml.Node{
+ Kind: yaml.ScalarNode,
+ Tag: yamlIntScalar,
+ Value: conv.FormatInteger(val),
+ }, nil
+}
+
+func uintegerNode[T conv.Unsigned](val T) (*yaml.Node, error) {
+ return &yaml.Node{
+ Kind: yaml.ScalarNode,
+ Tag: yamlIntScalar,
+ Value: conv.FormatUinteger(val),
+ }, nil
+}
+
+func orderedYAML[T ifaces.Ordered](val T) (*yaml.Node, error) {
+ var n yaml.Node
+ n.Kind = yaml.MappingNode
+ for key, value := range val.OrderedItems() {
+ childNode, err := json2yaml(value)
+ if err != nil {
+ return nil, err
+ }
+
+ n.Content = append(n.Content, &yaml.Node{
+ Kind: yaml.ScalarNode,
+ Tag: yamlStringScalar,
+ Value: key,
+ }, childNode)
+ }
+ return &n, nil
+}
diff --git a/vendor/github.com/go-openapi/swag/yamlutils/yaml.go b/vendor/github.com/go-openapi/swag/yamlutils/yaml.go
new file mode 100644
index 00000000..e3aff3c2
--- /dev/null
+++ b/vendor/github.com/go-openapi/swag/yamlutils/yaml.go
@@ -0,0 +1,211 @@
+// SPDX-FileCopyrightText: Copyright 2015-2025 go-swagger maintainers
+// SPDX-License-Identifier: Apache-2.0
+
+package yamlutils
+
+import (
+ json "encoding/json"
+ "fmt"
+ "strconv"
+
+ "github.com/go-openapi/swag/jsonutils"
+ yaml "go.yaml.in/yaml/v3"
+)
+
+// YAMLToJSON converts a YAML document into JSON bytes.
+//
+// Note: a YAML document is the output from a [yaml.Marshaler], e.g a pointer to a [yaml.Node].
+//
+// [YAMLToJSON] is typically called after [BytesToYAMLDoc].
+func YAMLToJSON(value any) (json.RawMessage, error) {
+ jm, err := transformData(value)
+ if err != nil {
+ return nil, err
+ }
+
+ b, err := jsonutils.WriteJSON(jm)
+
+ return json.RawMessage(b), err
+}
+
+// BytesToYAMLDoc converts a byte slice into a YAML document.
+//
+// This function only supports root documents that are objects.
+//
+// A YAML document is a pointer to a [yaml.Node].
+func BytesToYAMLDoc(data []byte) (any, error) {
+ var document yaml.Node // preserve order that is present in the document
+ if err := yaml.Unmarshal(data, &document); err != nil {
+ return nil, err
+ }
+ if document.Kind != yaml.DocumentNode || len(document.Content) != 1 || document.Content[0].Kind != yaml.MappingNode {
+ return nil, fmt.Errorf("only YAML documents that are objects are supported: %w", ErrYAML)
+ }
+ return &document, nil
+}
+
+func yamlNode(root *yaml.Node) (any, error) {
+ switch root.Kind {
+ case yaml.DocumentNode:
+ return yamlDocument(root)
+ case yaml.SequenceNode:
+ return yamlSequence(root)
+ case yaml.MappingNode:
+ return yamlMapping(root)
+ case yaml.ScalarNode:
+ return yamlScalar(root)
+ case yaml.AliasNode:
+ return yamlNode(root.Alias)
+ default:
+ return nil, fmt.Errorf("unsupported YAML node type: %v: %w", root.Kind, ErrYAML)
+ }
+}
+
+func yamlDocument(node *yaml.Node) (any, error) {
+ if len(node.Content) != 1 {
+ return nil, fmt.Errorf("unexpected YAML Document node content length: %d: %w", len(node.Content), ErrYAML)
+ }
+ return yamlNode(node.Content[0])
+}
+
+func yamlMapping(node *yaml.Node) (any, error) {
+ const sensibleAllocDivider = 2 // nodes concatenate (key,value) sequences
+ m := make(YAMLMapSlice, len(node.Content)/sensibleAllocDivider)
+
+ if err := m.UnmarshalYAML(node); err != nil {
+ return nil, err
+ }
+
+ return m, nil
+}
+
+func yamlSequence(node *yaml.Node) (any, error) {
+ s := make([]any, 0)
+
+ for i := range len(node.Content) {
+ v, err := yamlNode(node.Content[i])
+ if err != nil {
+ return nil, fmt.Errorf("unable to decode YAML sequence value: %w: %w", err, ErrYAML)
+ }
+ s = append(s, v)
+ }
+ return s, nil
+}
+
+const ( // See https://yaml.org/type/
+ yamlStringScalar = "tag:yaml.org,2002:str"
+ yamlIntScalar = "tag:yaml.org,2002:int"
+ yamlBoolScalar = "tag:yaml.org,2002:bool"
+ yamlFloatScalar = "tag:yaml.org,2002:float"
+ yamlTimestamp = "tag:yaml.org,2002:timestamp"
+ yamlNull = "tag:yaml.org,2002:null"
+)
+
+func yamlScalar(node *yaml.Node) (any, error) {
+ switch node.LongTag() {
+ case yamlStringScalar:
+ return node.Value, nil
+ case yamlBoolScalar:
+ b, err := strconv.ParseBool(node.Value)
+ if err != nil {
+ return nil, fmt.Errorf("unable to process scalar node. Got %q. Expecting bool content: %w: %w", node.Value, err, ErrYAML)
+ }
+ return b, nil
+ case yamlIntScalar:
+ i, err := strconv.ParseInt(node.Value, 10, 64)
+ if err != nil {
+ return nil, fmt.Errorf("unable to process scalar node. Got %q. Expecting integer content: %w: %w", node.Value, err, ErrYAML)
+ }
+ return i, nil
+ case yamlFloatScalar:
+ f, err := strconv.ParseFloat(node.Value, 64)
+ if err != nil {
+ return nil, fmt.Errorf("unable to process scalar node. Got %q. Expecting float content: %w: %w", node.Value, err, ErrYAML)
+ }
+ return f, nil
+ case yamlTimestamp:
+ // YAML timestamp is marshaled as string, not time
+ return node.Value, nil
+ case yamlNull:
+ return nil, nil //nolint:nilnil
+ default:
+ return nil, fmt.Errorf("YAML tag %q is not supported: %w", node.LongTag(), ErrYAML)
+ }
+}
+
+func yamlStringScalarC(node *yaml.Node) (string, error) {
+ if node.Kind != yaml.ScalarNode {
+ return "", fmt.Errorf("expecting a string scalar but got %q: %w", node.Kind, ErrYAML)
+ }
+ switch node.LongTag() {
+ case yamlStringScalar, yamlIntScalar, yamlFloatScalar:
+ return node.Value, nil
+ default:
+ return "", fmt.Errorf("YAML tag %q is not supported as map key: %w", node.LongTag(), ErrYAML)
+ }
+}
+
+func format(t any) (string, error) {
+ switch k := t.(type) {
+ case string:
+ return k, nil
+ case uint:
+ return strconv.FormatUint(uint64(k), 10), nil
+ case uint8:
+ return strconv.FormatUint(uint64(k), 10), nil
+ case uint16:
+ return strconv.FormatUint(uint64(k), 10), nil
+ case uint32:
+ return strconv.FormatUint(uint64(k), 10), nil
+ case uint64:
+ return strconv.FormatUint(k, 10), nil
+ case int:
+ return strconv.Itoa(k), nil
+ case int8:
+ return strconv.FormatInt(int64(k), 10), nil
+ case int16:
+ return strconv.FormatInt(int64(k), 10), nil
+ case int32:
+ return strconv.FormatInt(int64(k), 10), nil
+ case int64:
+ return strconv.FormatInt(k, 10), nil
+ default:
+ return "", fmt.Errorf("unexpected map key type, got: %T: %w", k, ErrYAML)
+ }
+}
+
+func transformData(input any) (out any, err error) {
+ switch in := input.(type) {
+ case yaml.Node:
+ return yamlNode(&in)
+ case *yaml.Node:
+ return yamlNode(in)
+ case map[any]any:
+ o := make(YAMLMapSlice, 0, len(in))
+ for ke, va := range in {
+ var nmi YAMLMapItem
+ if nmi.Key, err = format(ke); err != nil {
+ return nil, err
+ }
+
+ v, ert := transformData(va)
+ if ert != nil {
+ return nil, ert
+ }
+ nmi.Value = v
+ o = append(o, nmi)
+ }
+ return o, nil
+ case []any:
+ len1 := len(in)
+ o := make([]any, len1)
+ for i := range len1 {
+ o[i], err = transformData(in[i])
+ if err != nil {
+ return nil, err
+ }
+ }
+ return o, nil
+ }
+ return input, nil
+}
diff --git a/vendor/github.com/go-playground/validator/v10/README.md b/vendor/github.com/go-playground/validator/v10/README.md
index 28f7e159..cb5d4194 100644
--- a/vendor/github.com/go-playground/validator/v10/README.md
+++ b/vendor/github.com/go-playground/validator/v10/README.md
@@ -106,8 +106,9 @@ validate := validator.New(validator.WithRequiredStructEnabled())
| datauri | Data URL |
| fqdn | Full Qualified Domain Name (FQDN) |
| hostname | Hostname RFC 952 |
-| hostname_port | HostPort |
| hostname_rfc1123 | Hostname RFC 1123 |
+| hostname_port | HostPort |
+| port | Port number |
| ip | Internet Protocol Address IP |
| ip4_addr | Internet Protocol Address IPv4 |
| ip6_addr | Internet Protocol Address IPv6 |
@@ -124,7 +125,8 @@ validate := validator.New(validator.WithRequiredStructEnabled())
| unix_addr | Unix domain socket end point Address |
| uri | URI String |
| url | URL String |
-| http_url | HTTP URL String |
+| http_url | HTTP(s) URL String |
+| https_url | HTTPS-only URL String |
| url_encoded | URL Encoded |
| urn_rfc2141 | Urn RFC 2141 String |
@@ -133,6 +135,7 @@ validate := validator.New(validator.WithRequiredStructEnabled())
| Tag | Description |
| - | - |
| alpha | Alpha Only |
+| alphaspace | Alpha Space |
| alphanum | Alphanumeric |
| alphanumunicode | Alphanumeric Unicode |
| alphaunicode | Alpha Unicode |
diff --git a/vendor/github.com/go-playground/validator/v10/baked_in.go b/vendor/github.com/go-playground/validator/v10/baked_in.go
index c968ad4a..8fd55e77 100644
--- a/vendor/github.com/go-playground/validator/v10/baked_in.go
+++ b/vendor/github.com/go-playground/validator/v10/baked_in.go
@@ -118,6 +118,7 @@ var (
"fieldcontains": fieldContains,
"fieldexcludes": fieldExcludes,
"alpha": isAlpha,
+ "alphaspace": isAlphaSpace,
"alphanum": isAlphanum,
"alphaunicode": isAlphaUnicode,
"alphanumunicode": isAlphanumUnicode,
@@ -134,6 +135,7 @@ var (
"email": isEmail,
"url": isURL,
"http_url": isHttpURL,
+ "https_url": isHttpsURL,
"uri": isURI,
"urn_rfc2141": isUrnRFC2141, // RFC 2141
"file": isFile,
@@ -1513,6 +1515,29 @@ func isHttpURL(fl FieldLevel) bool {
panic(fmt.Sprintf("Bad field type %s", field.Type()))
}
+// isHttpsURL is the validation function for validating if the current field's value is a valid HTTPS-only URL.
+func isHttpsURL(fl FieldLevel) bool {
+ if !isURL(fl) {
+ return false
+ }
+
+ field := fl.Field()
+ switch field.Kind() {
+ case reflect.String:
+
+ s := strings.ToLower(field.String())
+
+ url, err := url.Parse(s)
+ if err != nil || url.Host == "" {
+ return false
+ }
+
+ return url.Scheme == "https"
+ }
+
+ panic(fmt.Sprintf("Bad field type %s", field.Type()))
+}
+
// isUrnRFC2141 is the validation function for validating if the current field's value is a valid URN as per RFC 2141.
func isUrnRFC2141(fl FieldLevel) bool {
field := fl.Field()
@@ -1743,6 +1768,11 @@ func isAlphanumUnicode(fl FieldLevel) bool {
return alphaUnicodeNumericRegex().MatchString(fl.Field().String())
}
+// isAlphaSpace is the validation function for validating if the current field's value is a valid alpha value with spaces.
+func isAlphaSpace(fl FieldLevel) bool {
+ return alphaSpaceRegex().MatchString(fl.Field().String())
+}
+
// isAlphaUnicode is the validation function for validating if the current field's value is a valid alpha unicode value.
func isAlphaUnicode(fl FieldLevel) bool {
return alphaUnicodeRegex().MatchString(fl.Field().String())
@@ -1872,6 +1902,15 @@ func requiredIf(fl FieldLevel) bool {
if len(params)%2 != 0 {
panic(fmt.Sprintf("Bad param number for required_if %s", fl.FieldName()))
}
+
+ seen := make(map[string]struct{})
+ for i := 0; i < len(params); i += 2 {
+ if _, ok := seen[params[i]]; ok {
+ panic(fmt.Sprintf("Duplicate param %s for required_if %s", params[i], fl.FieldName()))
+ }
+ seen[params[i]] = struct{}{}
+ }
+
for i := 0; i < len(params); i += 2 {
if !requireCheckFieldValue(fl, params[i], params[i+1], false) {
return true
diff --git a/vendor/github.com/go-playground/validator/v10/doc.go b/vendor/github.com/go-playground/validator/v10/doc.go
index 23cce991..52918e40 100644
--- a/vendor/github.com/go-playground/validator/v10/doc.go
+++ b/vendor/github.com/go-playground/validator/v10/doc.go
@@ -264,6 +264,7 @@ The field under validation must be present and not empty only if all
the other specified fields are equal to the value following the specified
field. For strings ensures value is not "". For slices, maps, pointers,
interfaces, channels and functions ensures the value is not nil. For structs ensures value is not the zero value.
+Using the same field name multiple times in the parameters will result in a panic at runtime.
Usage: required_if
@@ -776,6 +777,12 @@ This validates that a string value contains ASCII alpha characters only
Usage: alpha
+# Alpha Space
+
+This validates that a string value contains ASCII alpha characters and spaces only
+
+ Usage: alphaspace
+
# Alphanumeric
This validates that a string value contains ASCII alphanumeric characters only
@@ -1330,6 +1337,12 @@ can be used to validate fields typically passed to sockets and connections.
Usage: hostname_port
+# Port
+
+This validates that the value falls within the valid port number range of 1 to 65,535.
+
+ Usage: port
+
# Datetime
This validates that a string value is a valid datetime based on the supplied datetime format.
diff --git a/vendor/github.com/go-playground/validator/v10/regexes.go b/vendor/github.com/go-playground/validator/v10/regexes.go
index 93909b2e..0b3615f5 100644
--- a/vendor/github.com/go-playground/validator/v10/regexes.go
+++ b/vendor/github.com/go-playground/validator/v10/regexes.go
@@ -7,6 +7,7 @@ import (
const (
alphaRegexString = "^[a-zA-Z]+$"
+ alphaSpaceRegexString = "^[a-zA-Z ]+$"
alphaNumericRegexString = "^[a-zA-Z0-9]+$"
alphaUnicodeRegexString = "^[\\p{L}]+$"
alphaUnicodeNumericRegexString = "^[\\p{L}\\p{N}]+$"
@@ -93,6 +94,7 @@ func lazyRegexCompile(str string) func() *regexp.Regexp {
var (
alphaRegex = lazyRegexCompile(alphaRegexString)
+ alphaSpaceRegex = lazyRegexCompile(alphaSpaceRegexString)
alphaNumericRegex = lazyRegexCompile(alphaNumericRegexString)
alphaUnicodeRegex = lazyRegexCompile(alphaUnicodeRegexString)
alphaUnicodeNumericRegex = lazyRegexCompile(alphaUnicodeNumericRegexString)
diff --git a/vendor/github.com/go-playground/validator/v10/validator_instance.go b/vendor/github.com/go-playground/validator/v10/validator_instance.go
index 9362cd73..5ba64e5b 100644
--- a/vendor/github.com/go-playground/validator/v10/validator_instance.go
+++ b/vendor/github.com/go-playground/validator/v10/validator_instance.go
@@ -181,7 +181,7 @@ func (v Validate) ValidateMapCtx(ctx context.Context, data map[string]interface{
errs[field] = errors.New("The field: '" + field + "' is not a map to dive")
}
} else if ruleStr, ok := rule.(string); ok {
- err := v.VarCtx(ctx, data[field], ruleStr)
+ err := v.VarWithKeyCtx(ctx, field, data[field], ruleStr)
if err != nil {
errs[field] = err
}
@@ -681,6 +681,64 @@ func (v *Validate) VarWithValueCtx(ctx context.Context, field interface{}, other
return
}
+// VarWithKey validates a single variable with a key to be included in the returned error using tag style validation
+// eg.
+// var s string
+// validate.VarWithKey("email_address", s, "required,email")
+//
+// WARNING: a struct can be passed for validation eg. time.Time is a struct or
+// if you have a custom type and have registered a custom type handler, so must
+// allow it; however unforeseen validations will occur if trying to validate a
+// struct that is meant to be passed to 'validate.Struct'
+//
+// It returns InvalidValidationError for bad values passed in and nil or ValidationErrors as error otherwise.
+// You will need to assert the error if it's not nil eg. err.(validator.ValidationErrors) to access the array of errors.
+// validate Array, Slice and maps fields which may contain more than one error
+func (v *Validate) VarWithKey(key string, field interface{}, tag string) error {
+ return v.VarWithKeyCtx(context.Background(), key, field, tag)
+}
+
+// VarWithKeyCtx validates a single variable with a key to be included in the returned error using tag style validation
+// and allows passing of contextual validation information via context.Context.
+// eg.
+// var s string
+// validate.VarWithKeyCtx("email_address", s, "required,email")
+//
+// WARNING: a struct can be passed for validation eg. time.Time is a struct or
+// if you have a custom type and have registered a custom type handler, so must
+// allow it; however unforeseen validations will occur if trying to validate a
+// struct that is meant to be passed to 'validate.Struct'
+//
+// It returns InvalidValidationError for bad values passed in and nil or ValidationErrors as error otherwise.
+// You will need to assert the error if it's not nil eg. err.(validator.ValidationErrors) to access the array of errors.
+// validate Array, Slice and maps fields which may contain more than one error
+func (v *Validate) VarWithKeyCtx(ctx context.Context, key string, field interface{}, tag string) (err error) {
+ if len(tag) == 0 || tag == skipValidationTag {
+ return nil
+ }
+
+ ctag := v.fetchCacheTag(tag)
+
+ cField := &cField{
+ name: key,
+ altName: key,
+ namesEqual: true,
+ }
+
+ val := reflect.ValueOf(field)
+ vd := v.pool.Get().(*validate)
+ vd.top = val
+ vd.isPartial = false
+ vd.traverseField(ctx, val, val, vd.ns[0:0], vd.actualNs[0:0], cField, ctag)
+
+ if len(vd.errs) > 0 {
+ err = vd.errs
+ vd.errs = nil
+ }
+ v.pool.Put(vd)
+ return
+}
+
func (v *Validate) registerValidation(tag string, fn FuncCtx, bakedIn bool, nilCheckable bool) error {
if len(tag) == 0 {
return errors.New("function Key cannot be empty")
diff --git a/vendor/github.com/go-viper/mapstructure/v2/.golangci.yaml b/vendor/github.com/go-viper/mapstructure/v2/.golangci.yaml
index ec1680b3..bda96256 100644
--- a/vendor/github.com/go-viper/mapstructure/v2/.golangci.yaml
+++ b/vendor/github.com/go-viper/mapstructure/v2/.golangci.yaml
@@ -37,3 +37,12 @@ formatters:
- standard
- default
- localmodule
+ gofmt:
+ simplify: true
+ rewrite-rules:
+ - pattern: interface{}
+ replacement: any
+
+ exclusions:
+ paths:
+ - internal/
diff --git a/vendor/github.com/go-viper/mapstructure/v2/README.md b/vendor/github.com/go-viper/mapstructure/v2/README.md
index bc4be08e..45db7197 100644
--- a/vendor/github.com/go-viper/mapstructure/v2/README.md
+++ b/vendor/github.com/go-viper/mapstructure/v2/README.md
@@ -1,7 +1,7 @@
# mapstructure
[](https://github.com/go-viper/mapstructure/actions/workflows/ci.yaml)
-[](https://pkg.go.dev/mod/github.com/go-viper/mapstructure)
+[](https://pkg.go.dev/mod/github.com/go-viper/mapstructure/v2)
[](https://deps.dev/go/github.com%252Fgo-viper%252Fmapstructure%252Fv2)
diff --git a/vendor/github.com/go-viper/mapstructure/v2/decode_hooks.go b/vendor/github.com/go-viper/mapstructure/v2/decode_hooks.go
index 57c6de69..a852a0a0 100644
--- a/vendor/github.com/go-viper/mapstructure/v2/decode_hooks.go
+++ b/vendor/github.com/go-viper/mapstructure/v2/decode_hooks.go
@@ -13,7 +13,7 @@ import (
"time"
)
-// typedDecodeHook takes a raw DecodeHookFunc (an interface{}) and turns
+// typedDecodeHook takes a raw DecodeHookFunc (an any) and turns
// it into the proper DecodeHookFunc type, such as DecodeHookFuncType.
func typedDecodeHook(h DecodeHookFunc) DecodeHookFunc {
// Create variables here so we can reference them with the reflect pkg
@@ -23,7 +23,7 @@ func typedDecodeHook(h DecodeHookFunc) DecodeHookFunc {
// Fill in the variables into this interface and the rest is done
// automatically using the reflect package.
- potential := []interface{}{f1, f2, f3}
+ potential := []any{f1, f2, f3}
v := reflect.ValueOf(h)
vt := v.Type()
@@ -37,25 +37,25 @@ func typedDecodeHook(h DecodeHookFunc) DecodeHookFunc {
return nil
}
-// cachedDecodeHook takes a raw DecodeHookFunc (an interface{}) and turns
+// cachedDecodeHook takes a raw DecodeHookFunc (an any) and turns
// it into a closure to be used directly
// if the type fails to convert we return a closure always erroring to keep the previous behaviour
-func cachedDecodeHook(raw DecodeHookFunc) func(from reflect.Value, to reflect.Value) (interface{}, error) {
+func cachedDecodeHook(raw DecodeHookFunc) func(from reflect.Value, to reflect.Value) (any, error) {
switch f := typedDecodeHook(raw).(type) {
case DecodeHookFuncType:
- return func(from reflect.Value, to reflect.Value) (interface{}, error) {
+ return func(from reflect.Value, to reflect.Value) (any, error) {
return f(from.Type(), to.Type(), from.Interface())
}
case DecodeHookFuncKind:
- return func(from reflect.Value, to reflect.Value) (interface{}, error) {
+ return func(from reflect.Value, to reflect.Value) (any, error) {
return f(from.Kind(), to.Kind(), from.Interface())
}
case DecodeHookFuncValue:
- return func(from reflect.Value, to reflect.Value) (interface{}, error) {
+ return func(from reflect.Value, to reflect.Value) (any, error) {
return f(from, to)
}
default:
- return func(from reflect.Value, to reflect.Value) (interface{}, error) {
+ return func(from reflect.Value, to reflect.Value) (any, error) {
return nil, errors.New("invalid decode hook signature")
}
}
@@ -67,7 +67,7 @@ func cachedDecodeHook(raw DecodeHookFunc) func(from reflect.Value, to reflect.Va
func DecodeHookExec(
raw DecodeHookFunc,
from reflect.Value, to reflect.Value,
-) (interface{}, error) {
+) (any, error) {
switch f := typedDecodeHook(raw).(type) {
case DecodeHookFuncType:
return f(from.Type(), to.Type(), from.Interface())
@@ -86,11 +86,11 @@ func DecodeHookExec(
// The composed funcs are called in order, with the result of the
// previous transformation.
func ComposeDecodeHookFunc(fs ...DecodeHookFunc) DecodeHookFunc {
- cached := make([]func(from reflect.Value, to reflect.Value) (interface{}, error), 0, len(fs))
+ cached := make([]func(from reflect.Value, to reflect.Value) (any, error), 0, len(fs))
for _, f := range fs {
cached = append(cached, cachedDecodeHook(f))
}
- return func(f reflect.Value, t reflect.Value) (interface{}, error) {
+ return func(f reflect.Value, t reflect.Value) (any, error) {
var err error
data := f.Interface()
@@ -114,13 +114,13 @@ func ComposeDecodeHookFunc(fs ...DecodeHookFunc) DecodeHookFunc {
// OrComposeDecodeHookFunc executes all input hook functions until one of them returns no error. In that case its value is returned.
// If all hooks return an error, OrComposeDecodeHookFunc returns an error concatenating all error messages.
func OrComposeDecodeHookFunc(ff ...DecodeHookFunc) DecodeHookFunc {
- cached := make([]func(from reflect.Value, to reflect.Value) (interface{}, error), 0, len(ff))
+ cached := make([]func(from reflect.Value, to reflect.Value) (any, error), 0, len(ff))
for _, f := range ff {
cached = append(cached, cachedDecodeHook(f))
}
- return func(a, b reflect.Value) (interface{}, error) {
+ return func(a, b reflect.Value) (any, error) {
var allErrs string
- var out interface{}
+ var out any
var err error
for _, c := range cached {
@@ -143,8 +143,8 @@ func StringToSliceHookFunc(sep string) DecodeHookFunc {
return func(
f reflect.Type,
t reflect.Type,
- data interface{},
- ) (interface{}, error) {
+ data any,
+ ) (any, error) {
if f.Kind() != reflect.String {
return data, nil
}
@@ -161,14 +161,37 @@ func StringToSliceHookFunc(sep string) DecodeHookFunc {
}
}
+// StringToWeakSliceHookFunc brings back the old (pre-v2) behavior of [StringToSliceHookFunc].
+//
+// As of mapstructure v2.0.0 [StringToSliceHookFunc] checks if the return type is a string slice.
+// This function removes that check.
+func StringToWeakSliceHookFunc(sep string) DecodeHookFunc {
+ return func(
+ f reflect.Type,
+ t reflect.Type,
+ data any,
+ ) (any, error) {
+ if f.Kind() != reflect.String || t.Kind() != reflect.Slice {
+ return data, nil
+ }
+
+ raw := data.(string)
+ if raw == "" {
+ return []string{}, nil
+ }
+
+ return strings.Split(raw, sep), nil
+ }
+}
+
// StringToTimeDurationHookFunc returns a DecodeHookFunc that converts
// strings to time.Duration.
func StringToTimeDurationHookFunc() DecodeHookFunc {
return func(
f reflect.Type,
t reflect.Type,
- data interface{},
- ) (interface{}, error) {
+ data any,
+ ) (any, error) {
if f.Kind() != reflect.String {
return data, nil
}
@@ -177,7 +200,29 @@ func StringToTimeDurationHookFunc() DecodeHookFunc {
}
// Convert it by parsing
- return time.ParseDuration(data.(string))
+ d, err := time.ParseDuration(data.(string))
+
+ return d, wrapTimeParseDurationError(err)
+ }
+}
+
+// StringToTimeLocationHookFunc returns a DecodeHookFunc that converts
+// strings to *time.Location.
+func StringToTimeLocationHookFunc() DecodeHookFunc {
+ return func(
+ f reflect.Type,
+ t reflect.Type,
+ data any,
+ ) (any, error) {
+ if f.Kind() != reflect.String {
+ return data, nil
+ }
+ if t != reflect.TypeOf(time.Local) {
+ return data, nil
+ }
+ d, err := time.LoadLocation(data.(string))
+
+ return d, wrapTimeParseLocationError(err)
}
}
@@ -187,8 +232,8 @@ func StringToURLHookFunc() DecodeHookFunc {
return func(
f reflect.Type,
t reflect.Type,
- data interface{},
- ) (interface{}, error) {
+ data any,
+ ) (any, error) {
if f.Kind() != reflect.String {
return data, nil
}
@@ -197,7 +242,9 @@ func StringToURLHookFunc() DecodeHookFunc {
}
// Convert it by parsing
- return url.Parse(data.(string))
+ u, err := url.Parse(data.(string))
+
+ return u, wrapUrlError(err)
}
}
@@ -207,8 +254,8 @@ func StringToIPHookFunc() DecodeHookFunc {
return func(
f reflect.Type,
t reflect.Type,
- data interface{},
- ) (interface{}, error) {
+ data any,
+ ) (any, error) {
if f.Kind() != reflect.String {
return data, nil
}
@@ -219,7 +266,7 @@ func StringToIPHookFunc() DecodeHookFunc {
// Convert it by parsing
ip := net.ParseIP(data.(string))
if ip == nil {
- return net.IP{}, fmt.Errorf("failed parsing ip %v", data)
+ return net.IP{}, fmt.Errorf("failed parsing ip")
}
return ip, nil
@@ -232,8 +279,8 @@ func StringToIPNetHookFunc() DecodeHookFunc {
return func(
f reflect.Type,
t reflect.Type,
- data interface{},
- ) (interface{}, error) {
+ data any,
+ ) (any, error) {
if f.Kind() != reflect.String {
return data, nil
}
@@ -243,7 +290,7 @@ func StringToIPNetHookFunc() DecodeHookFunc {
// Convert it by parsing
_, net, err := net.ParseCIDR(data.(string))
- return net, err
+ return net, wrapNetParseError(err)
}
}
@@ -253,8 +300,8 @@ func StringToTimeHookFunc(layout string) DecodeHookFunc {
return func(
f reflect.Type,
t reflect.Type,
- data interface{},
- ) (interface{}, error) {
+ data any,
+ ) (any, error) {
if f.Kind() != reflect.String {
return data, nil
}
@@ -263,7 +310,9 @@ func StringToTimeHookFunc(layout string) DecodeHookFunc {
}
// Convert it by parsing
- return time.Parse(layout, data.(string))
+ ti, err := time.Parse(layout, data.(string))
+
+ return ti, wrapTimeParseError(err)
}
}
@@ -275,8 +324,8 @@ func StringToTimeHookFunc(layout string) DecodeHookFunc {
func WeaklyTypedHook(
f reflect.Kind,
t reflect.Kind,
- data interface{},
-) (interface{}, error) {
+ data any,
+) (any, error) {
dataVal := reflect.ValueOf(data)
switch t {
case reflect.String:
@@ -305,17 +354,17 @@ func WeaklyTypedHook(
}
func RecursiveStructToMapHookFunc() DecodeHookFunc {
- return func(f reflect.Value, t reflect.Value) (interface{}, error) {
+ return func(f reflect.Value, t reflect.Value) (any, error) {
if f.Kind() != reflect.Struct {
return f.Interface(), nil
}
- var i interface{} = struct{}{}
+ var i any = struct{}{}
if t.Type() != reflect.TypeOf(&i).Elem() {
return f.Interface(), nil
}
- m := make(map[string]interface{})
+ m := make(map[string]any)
t.Set(reflect.ValueOf(m))
return f.Interface(), nil
@@ -329,8 +378,8 @@ func TextUnmarshallerHookFunc() DecodeHookFuncType {
return func(
f reflect.Type,
t reflect.Type,
- data interface{},
- ) (interface{}, error) {
+ data any,
+ ) (any, error) {
if f.Kind() != reflect.String {
return data, nil
}
@@ -356,8 +405,8 @@ func StringToNetIPAddrHookFunc() DecodeHookFunc {
return func(
f reflect.Type,
t reflect.Type,
- data interface{},
- ) (interface{}, error) {
+ data any,
+ ) (any, error) {
if f.Kind() != reflect.String {
return data, nil
}
@@ -366,7 +415,9 @@ func StringToNetIPAddrHookFunc() DecodeHookFunc {
}
// Convert it by parsing
- return netip.ParseAddr(data.(string))
+ addr, err := netip.ParseAddr(data.(string))
+
+ return addr, wrapNetIPParseAddrError(err)
}
}
@@ -376,8 +427,8 @@ func StringToNetIPAddrPortHookFunc() DecodeHookFunc {
return func(
f reflect.Type,
t reflect.Type,
- data interface{},
- ) (interface{}, error) {
+ data any,
+ ) (any, error) {
if f.Kind() != reflect.String {
return data, nil
}
@@ -386,7 +437,9 @@ func StringToNetIPAddrPortHookFunc() DecodeHookFunc {
}
// Convert it by parsing
- return netip.ParseAddrPort(data.(string))
+ addrPort, err := netip.ParseAddrPort(data.(string))
+
+ return addrPort, wrapNetIPParseAddrPortError(err)
}
}
@@ -396,8 +449,8 @@ func StringToNetIPPrefixHookFunc() DecodeHookFunc {
return func(
f reflect.Type,
t reflect.Type,
- data interface{},
- ) (interface{}, error) {
+ data any,
+ ) (any, error) {
if f.Kind() != reflect.String {
return data, nil
}
@@ -406,7 +459,9 @@ func StringToNetIPPrefixHookFunc() DecodeHookFunc {
}
// Convert it by parsing
- return netip.ParsePrefix(data.(string))
+ prefix, err := netip.ParsePrefix(data.(string))
+
+ return prefix, wrapNetIPParsePrefixError(err)
}
}
@@ -439,178 +494,182 @@ func StringToBasicTypeHookFunc() DecodeHookFunc {
// StringToInt8HookFunc returns a DecodeHookFunc that converts
// strings to int8.
func StringToInt8HookFunc() DecodeHookFunc {
- return func(f reflect.Type, t reflect.Type, data interface{}) (interface{}, error) {
+ return func(f reflect.Type, t reflect.Type, data any) (any, error) {
if f.Kind() != reflect.String || t.Kind() != reflect.Int8 {
return data, nil
}
// Convert it by parsing
i64, err := strconv.ParseInt(data.(string), 0, 8)
- return int8(i64), err
+ return int8(i64), wrapStrconvNumError(err)
}
}
// StringToUint8HookFunc returns a DecodeHookFunc that converts
// strings to uint8.
func StringToUint8HookFunc() DecodeHookFunc {
- return func(f reflect.Type, t reflect.Type, data interface{}) (interface{}, error) {
+ return func(f reflect.Type, t reflect.Type, data any) (any, error) {
if f.Kind() != reflect.String || t.Kind() != reflect.Uint8 {
return data, nil
}
// Convert it by parsing
u64, err := strconv.ParseUint(data.(string), 0, 8)
- return uint8(u64), err
+ return uint8(u64), wrapStrconvNumError(err)
}
}
// StringToInt16HookFunc returns a DecodeHookFunc that converts
// strings to int16.
func StringToInt16HookFunc() DecodeHookFunc {
- return func(f reflect.Type, t reflect.Type, data interface{}) (interface{}, error) {
+ return func(f reflect.Type, t reflect.Type, data any) (any, error) {
if f.Kind() != reflect.String || t.Kind() != reflect.Int16 {
return data, nil
}
// Convert it by parsing
i64, err := strconv.ParseInt(data.(string), 0, 16)
- return int16(i64), err
+ return int16(i64), wrapStrconvNumError(err)
}
}
// StringToUint16HookFunc returns a DecodeHookFunc that converts
// strings to uint16.
func StringToUint16HookFunc() DecodeHookFunc {
- return func(f reflect.Type, t reflect.Type, data interface{}) (interface{}, error) {
+ return func(f reflect.Type, t reflect.Type, data any) (any, error) {
if f.Kind() != reflect.String || t.Kind() != reflect.Uint16 {
return data, nil
}
// Convert it by parsing
u64, err := strconv.ParseUint(data.(string), 0, 16)
- return uint16(u64), err
+ return uint16(u64), wrapStrconvNumError(err)
}
}
// StringToInt32HookFunc returns a DecodeHookFunc that converts
// strings to int32.
func StringToInt32HookFunc() DecodeHookFunc {
- return func(f reflect.Type, t reflect.Type, data interface{}) (interface{}, error) {
+ return func(f reflect.Type, t reflect.Type, data any) (any, error) {
if f.Kind() != reflect.String || t.Kind() != reflect.Int32 {
return data, nil
}
// Convert it by parsing
i64, err := strconv.ParseInt(data.(string), 0, 32)
- return int32(i64), err
+ return int32(i64), wrapStrconvNumError(err)
}
}
// StringToUint32HookFunc returns a DecodeHookFunc that converts
// strings to uint32.
func StringToUint32HookFunc() DecodeHookFunc {
- return func(f reflect.Type, t reflect.Type, data interface{}) (interface{}, error) {
+ return func(f reflect.Type, t reflect.Type, data any) (any, error) {
if f.Kind() != reflect.String || t.Kind() != reflect.Uint32 {
return data, nil
}
// Convert it by parsing
u64, err := strconv.ParseUint(data.(string), 0, 32)
- return uint32(u64), err
+ return uint32(u64), wrapStrconvNumError(err)
}
}
// StringToInt64HookFunc returns a DecodeHookFunc that converts
// strings to int64.
func StringToInt64HookFunc() DecodeHookFunc {
- return func(f reflect.Type, t reflect.Type, data interface{}) (interface{}, error) {
+ return func(f reflect.Type, t reflect.Type, data any) (any, error) {
if f.Kind() != reflect.String || t.Kind() != reflect.Int64 {
return data, nil
}
// Convert it by parsing
- return strconv.ParseInt(data.(string), 0, 64)
+ i64, err := strconv.ParseInt(data.(string), 0, 64)
+ return int64(i64), wrapStrconvNumError(err)
}
}
// StringToUint64HookFunc returns a DecodeHookFunc that converts
// strings to uint64.
func StringToUint64HookFunc() DecodeHookFunc {
- return func(f reflect.Type, t reflect.Type, data interface{}) (interface{}, error) {
+ return func(f reflect.Type, t reflect.Type, data any) (any, error) {
if f.Kind() != reflect.String || t.Kind() != reflect.Uint64 {
return data, nil
}
// Convert it by parsing
- return strconv.ParseUint(data.(string), 0, 64)
+ u64, err := strconv.ParseUint(data.(string), 0, 64)
+ return uint64(u64), wrapStrconvNumError(err)
}
}
// StringToIntHookFunc returns a DecodeHookFunc that converts
// strings to int.
func StringToIntHookFunc() DecodeHookFunc {
- return func(f reflect.Type, t reflect.Type, data interface{}) (interface{}, error) {
+ return func(f reflect.Type, t reflect.Type, data any) (any, error) {
if f.Kind() != reflect.String || t.Kind() != reflect.Int {
return data, nil
}
// Convert it by parsing
i64, err := strconv.ParseInt(data.(string), 0, 0)
- return int(i64), err
+ return int(i64), wrapStrconvNumError(err)
}
}
// StringToUintHookFunc returns a DecodeHookFunc that converts
// strings to uint.
func StringToUintHookFunc() DecodeHookFunc {
- return func(f reflect.Type, t reflect.Type, data interface{}) (interface{}, error) {
+ return func(f reflect.Type, t reflect.Type, data any) (any, error) {
if f.Kind() != reflect.String || t.Kind() != reflect.Uint {
return data, nil
}
// Convert it by parsing
u64, err := strconv.ParseUint(data.(string), 0, 0)
- return uint(u64), err
+ return uint(u64), wrapStrconvNumError(err)
}
}
// StringToFloat32HookFunc returns a DecodeHookFunc that converts
// strings to float32.
func StringToFloat32HookFunc() DecodeHookFunc {
- return func(f reflect.Type, t reflect.Type, data interface{}) (interface{}, error) {
+ return func(f reflect.Type, t reflect.Type, data any) (any, error) {
if f.Kind() != reflect.String || t.Kind() != reflect.Float32 {
return data, nil
}
// Convert it by parsing
f64, err := strconv.ParseFloat(data.(string), 32)
- return float32(f64), err
+ return float32(f64), wrapStrconvNumError(err)
}
}
// StringToFloat64HookFunc returns a DecodeHookFunc that converts
// strings to float64.
func StringToFloat64HookFunc() DecodeHookFunc {
- return func(f reflect.Type, t reflect.Type, data interface{}) (interface{}, error) {
+ return func(f reflect.Type, t reflect.Type, data any) (any, error) {
if f.Kind() != reflect.String || t.Kind() != reflect.Float64 {
return data, nil
}
// Convert it by parsing
- return strconv.ParseFloat(data.(string), 64)
+ f64, err := strconv.ParseFloat(data.(string), 64)
+ return f64, wrapStrconvNumError(err)
}
}
// StringToBoolHookFunc returns a DecodeHookFunc that converts
// strings to bool.
func StringToBoolHookFunc() DecodeHookFunc {
- return func(f reflect.Type, t reflect.Type, data interface{}) (interface{}, error) {
+ return func(f reflect.Type, t reflect.Type, data any) (any, error) {
if f.Kind() != reflect.String || t.Kind() != reflect.Bool {
return data, nil
}
// Convert it by parsing
- return strconv.ParseBool(data.(string))
+ b, err := strconv.ParseBool(data.(string))
+ return b, wrapStrconvNumError(err)
}
}
@@ -629,26 +688,27 @@ func StringToRuneHookFunc() DecodeHookFunc {
// StringToComplex64HookFunc returns a DecodeHookFunc that converts
// strings to complex64.
func StringToComplex64HookFunc() DecodeHookFunc {
- return func(f reflect.Type, t reflect.Type, data interface{}) (interface{}, error) {
+ return func(f reflect.Type, t reflect.Type, data any) (any, error) {
if f.Kind() != reflect.String || t.Kind() != reflect.Complex64 {
return data, nil
}
// Convert it by parsing
c128, err := strconv.ParseComplex(data.(string), 64)
- return complex64(c128), err
+ return complex64(c128), wrapStrconvNumError(err)
}
}
// StringToComplex128HookFunc returns a DecodeHookFunc that converts
// strings to complex128.
func StringToComplex128HookFunc() DecodeHookFunc {
- return func(f reflect.Type, t reflect.Type, data interface{}) (interface{}, error) {
+ return func(f reflect.Type, t reflect.Type, data any) (any, error) {
if f.Kind() != reflect.String || t.Kind() != reflect.Complex128 {
return data, nil
}
// Convert it by parsing
- return strconv.ParseComplex(data.(string), 128)
+ c128, err := strconv.ParseComplex(data.(string), 128)
+ return c128, wrapStrconvNumError(err)
}
}
diff --git a/vendor/github.com/go-viper/mapstructure/v2/errors.go b/vendor/github.com/go-viper/mapstructure/v2/errors.go
index 31a3edfb..07d31c22 100644
--- a/vendor/github.com/go-viper/mapstructure/v2/errors.go
+++ b/vendor/github.com/go-viper/mapstructure/v2/errors.go
@@ -1,8 +1,14 @@
package mapstructure
import (
+ "errors"
"fmt"
+ "net"
+ "net/url"
"reflect"
+ "strconv"
+ "strings"
+ "time"
)
// Error interface is implemented by all errors emitted by mapstructure.
@@ -72,3 +78,167 @@ func (e *UnconvertibleTypeError) Error() string {
}
func (*UnconvertibleTypeError) mapstructure() {}
+
+func wrapStrconvNumError(err error) error {
+ if err == nil {
+ return nil
+ }
+
+ if err, ok := err.(*strconv.NumError); ok {
+ return &strconvNumError{Err: err}
+ }
+
+ return err
+}
+
+type strconvNumError struct {
+ Err *strconv.NumError
+}
+
+func (e *strconvNumError) Error() string {
+ return "strconv." + e.Err.Func + ": " + e.Err.Err.Error()
+}
+
+func (e *strconvNumError) Unwrap() error { return e.Err }
+
+func wrapUrlError(err error) error {
+ if err == nil {
+ return nil
+ }
+
+ if err, ok := err.(*url.Error); ok {
+ return &urlError{Err: err}
+ }
+
+ return err
+}
+
+type urlError struct {
+ Err *url.Error
+}
+
+func (e *urlError) Error() string {
+ return fmt.Sprintf("%s", e.Err.Err)
+}
+
+func (e *urlError) Unwrap() error { return e.Err }
+
+func wrapNetParseError(err error) error {
+ if err == nil {
+ return nil
+ }
+
+ if err, ok := err.(*net.ParseError); ok {
+ return &netParseError{Err: err}
+ }
+
+ return err
+}
+
+type netParseError struct {
+ Err *net.ParseError
+}
+
+func (e *netParseError) Error() string {
+ return "invalid " + e.Err.Type
+}
+
+func (e *netParseError) Unwrap() error { return e.Err }
+
+func wrapTimeParseError(err error) error {
+ if err == nil {
+ return nil
+ }
+
+ if err, ok := err.(*time.ParseError); ok {
+ return &timeParseError{Err: err}
+ }
+
+ return err
+}
+
+type timeParseError struct {
+ Err *time.ParseError
+}
+
+func (e *timeParseError) Error() string {
+ if e.Err.Message == "" {
+ return fmt.Sprintf("parsing time as %q: cannot parse as %q", e.Err.Layout, e.Err.LayoutElem)
+ }
+
+ return "parsing time " + e.Err.Message
+}
+
+func (e *timeParseError) Unwrap() error { return e.Err }
+
+func wrapNetIPParseAddrError(err error) error {
+ if err == nil {
+ return nil
+ }
+
+ if errMsg := err.Error(); strings.HasPrefix(errMsg, "ParseAddr") {
+ errPieces := strings.Split(errMsg, ": ")
+
+ return fmt.Errorf("ParseAddr: %s", errPieces[len(errPieces)-1])
+ }
+
+ return err
+}
+
+func wrapNetIPParseAddrPortError(err error) error {
+ if err == nil {
+ return nil
+ }
+
+ errMsg := err.Error()
+ if strings.HasPrefix(errMsg, "invalid port ") {
+ return errors.New("invalid port")
+ } else if strings.HasPrefix(errMsg, "invalid ip:port ") {
+ return errors.New("invalid ip:port")
+ }
+
+ return err
+}
+
+func wrapNetIPParsePrefixError(err error) error {
+ if err == nil {
+ return nil
+ }
+
+ if errMsg := err.Error(); strings.HasPrefix(errMsg, "netip.ParsePrefix") {
+ errPieces := strings.Split(errMsg, ": ")
+
+ return fmt.Errorf("netip.ParsePrefix: %s", errPieces[len(errPieces)-1])
+ }
+
+ return err
+}
+
+func wrapTimeParseDurationError(err error) error {
+ if err == nil {
+ return nil
+ }
+
+ errMsg := err.Error()
+ if strings.HasPrefix(errMsg, "time: unknown unit ") {
+ return errors.New("time: unknown unit")
+ } else if strings.HasPrefix(errMsg, "time: ") {
+ idx := strings.LastIndex(errMsg, " ")
+
+ return errors.New(errMsg[:idx])
+ }
+
+ return err
+}
+
+func wrapTimeParseLocationError(err error) error {
+ if err == nil {
+ return nil
+ }
+ errMsg := err.Error()
+ if strings.Contains(errMsg, "unknown time zone") || strings.HasPrefix(errMsg, "time: unknown format") {
+ return fmt.Errorf("invalid time zone format: %w", err)
+ }
+
+ return err
+}
diff --git a/vendor/github.com/go-viper/mapstructure/v2/mapstructure.go b/vendor/github.com/go-viper/mapstructure/v2/mapstructure.go
index 4b738a3a..7c35bce0 100644
--- a/vendor/github.com/go-viper/mapstructure/v2/mapstructure.go
+++ b/vendor/github.com/go-viper/mapstructure/v2/mapstructure.go
@@ -1,5 +1,5 @@
// Package mapstructure exposes functionality to convert one arbitrary
-// Go type into another, typically to convert a map[string]interface{}
+// Go type into another, typically to convert a map[string]any
// into a native Go structure.
//
// The Go structure can be arbitrarily complex, containing slices,
@@ -54,8 +54,8 @@
//
// This would require an input that looks like below:
//
-// map[string]interface{}{
-// "person": map[string]interface{}{"name": "alice"},
+// map[string]any{
+// "person": map[string]any{"name": "alice"},
// }
//
// If your "person" value is NOT nested, then you can append ",squash" to
@@ -68,7 +68,7 @@
//
// Now the following input would be accepted:
//
-// map[string]interface{}{
+// map[string]any{
// "name": "alice",
// }
//
@@ -79,7 +79,7 @@
//
// Will be decoded into a map:
//
-// map[string]interface{}{
+// map[string]any{
// "name": "alice",
// }
//
@@ -95,18 +95,18 @@
//
// You can also use the ",remain" suffix on your tag to collect all unused
// values in a map. The field with this tag MUST be a map type and should
-// probably be a "map[string]interface{}" or "map[interface{}]interface{}".
+// probably be a "map[string]any" or "map[any]any".
// See example below:
//
// type Friend struct {
// Name string
-// Other map[string]interface{} `mapstructure:",remain"`
+// Other map[string]any `mapstructure:",remain"`
// }
//
// Given the input below, Other would be populated with the other
// values that weren't used (everything but "name"):
//
-// map[string]interface{}{
+// map[string]any{
// "name": "bob",
// "address": "123 Maple St.",
// }
@@ -161,7 +161,7 @@
//
// Using this map as input:
//
-// map[string]interface{}{
+// map[string]any{
// "private": "I will be ignored",
// "Public": "I made it through!",
// }
@@ -204,19 +204,19 @@ import (
// we started with Kinds and then realized Types were the better solution,
// but have a promise to not break backwards compat so we now support
// both.
-type DecodeHookFunc interface{}
+type DecodeHookFunc any
// DecodeHookFuncType is a DecodeHookFunc which has complete information about
// the source and target types.
-type DecodeHookFuncType func(reflect.Type, reflect.Type, interface{}) (interface{}, error)
+type DecodeHookFuncType func(reflect.Type, reflect.Type, any) (any, error)
// DecodeHookFuncKind is a DecodeHookFunc which knows only the Kinds of the
// source and target types.
-type DecodeHookFuncKind func(reflect.Kind, reflect.Kind, interface{}) (interface{}, error)
+type DecodeHookFuncKind func(reflect.Kind, reflect.Kind, any) (any, error)
// DecodeHookFuncValue is a DecodeHookFunc which has complete access to both the source and target
// values.
-type DecodeHookFuncValue func(from reflect.Value, to reflect.Value) (interface{}, error)
+type DecodeHookFuncValue func(from reflect.Value, to reflect.Value) (any, error)
// DecoderConfig is the configuration that is used to create a new decoder
// and allows customization of various aspects of decoding.
@@ -287,7 +287,7 @@ type DecoderConfig struct {
// Result is a pointer to the struct that will contain the decoded
// value.
- Result interface{}
+ Result any
// The tag name that mapstructure reads for field names. This
// defaults to "mapstructure"
@@ -319,7 +319,7 @@ type DecoderConfig struct {
// up the most basic Decoder.
type Decoder struct {
config *DecoderConfig
- cachedDecodeHook func(from reflect.Value, to reflect.Value) (interface{}, error)
+ cachedDecodeHook func(from reflect.Value, to reflect.Value) (any, error)
}
// Metadata contains information about decoding a structure that
@@ -340,7 +340,7 @@ type Metadata struct {
// Decode takes an input structure and uses reflection to translate it to
// the output structure. output must be a pointer to a map or struct.
-func Decode(input interface{}, output interface{}) error {
+func Decode(input any, output any) error {
config := &DecoderConfig{
Metadata: nil,
Result: output,
@@ -356,7 +356,7 @@ func Decode(input interface{}, output interface{}) error {
// WeakDecode is the same as Decode but is shorthand to enable
// WeaklyTypedInput. See DecoderConfig for more info.
-func WeakDecode(input, output interface{}) error {
+func WeakDecode(input, output any) error {
config := &DecoderConfig{
Metadata: nil,
Result: output,
@@ -373,7 +373,7 @@ func WeakDecode(input, output interface{}) error {
// DecodeMetadata is the same as Decode, but is shorthand to
// enable metadata collection. See DecoderConfig for more info.
-func DecodeMetadata(input interface{}, output interface{}, metadata *Metadata) error {
+func DecodeMetadata(input any, output any, metadata *Metadata) error {
config := &DecoderConfig{
Metadata: metadata,
Result: output,
@@ -390,7 +390,7 @@ func DecodeMetadata(input interface{}, output interface{}, metadata *Metadata) e
// WeakDecodeMetadata is the same as Decode, but is shorthand to
// enable both WeaklyTypedInput and metadata collection. See
// DecoderConfig for more info.
-func WeakDecodeMetadata(input interface{}, output interface{}, metadata *Metadata) error {
+func WeakDecodeMetadata(input any, output any, metadata *Metadata) error {
config := &DecoderConfig{
Metadata: metadata,
Result: output,
@@ -457,7 +457,7 @@ func NewDecoder(config *DecoderConfig) (*Decoder, error) {
// Decode decodes the given raw interface to the target pointer specified
// by the configuration.
-func (d *Decoder) Decode(input interface{}) error {
+func (d *Decoder) Decode(input any) error {
err := d.decode("", input, reflect.ValueOf(d.config.Result).Elem())
// Retain some of the original behavior when multiple errors ocurr
@@ -470,7 +470,7 @@ func (d *Decoder) Decode(input interface{}) error {
}
// isNil returns true if the input is nil or a typed nil pointer.
-func isNil(input interface{}) bool {
+func isNil(input any) bool {
if input == nil {
return true
}
@@ -479,7 +479,7 @@ func isNil(input interface{}) bool {
}
// Decodes an unknown data type into a specific reflection value.
-func (d *Decoder) decode(name string, input interface{}, outVal reflect.Value) error {
+func (d *Decoder) decode(name string, input any, outVal reflect.Value) error {
var (
inputVal = reflect.ValueOf(input)
outputKind = getKind(outVal)
@@ -516,10 +516,10 @@ func (d *Decoder) decode(name string, input interface{}, outVal reflect.Value) e
// Hooks need a valid inputVal, so reset it to zero value of outVal type.
switch outputKind {
case reflect.Struct, reflect.Map:
- var mapVal map[string]interface{}
+ var mapVal map[string]any
inputVal = reflect.ValueOf(mapVal) // create nil map pointer
case reflect.Slice, reflect.Array:
- var sliceVal []interface{}
+ var sliceVal []any
inputVal = reflect.ValueOf(sliceVal) // create nil slice pointer
default:
inputVal = reflect.Zero(outVal.Type())
@@ -583,7 +583,7 @@ func (d *Decoder) decode(name string, input interface{}, outVal reflect.Value) e
// This decodes a basic type (bool, int, string, etc.) and sets the
// value to "data" of that type.
-func (d *Decoder) decodeBasic(name string, data interface{}, val reflect.Value) error {
+func (d *Decoder) decodeBasic(name string, data any, val reflect.Value) error {
if val.IsValid() && val.Elem().IsValid() {
elem := val.Elem()
@@ -640,7 +640,7 @@ func (d *Decoder) decodeBasic(name string, data interface{}, val reflect.Value)
return nil
}
-func (d *Decoder) decodeString(name string, data interface{}, val reflect.Value) error {
+func (d *Decoder) decodeString(name string, data any, val reflect.Value) error {
dataVal := reflect.Indirect(reflect.ValueOf(data))
dataKind := getKind(dataVal)
@@ -693,7 +693,7 @@ func (d *Decoder) decodeString(name string, data interface{}, val reflect.Value)
return nil
}
-func (d *Decoder) decodeInt(name string, data interface{}, val reflect.Value) error {
+func (d *Decoder) decodeInt(name string, data any, val reflect.Value) error {
dataVal := reflect.Indirect(reflect.ValueOf(data))
dataKind := getKind(dataVal)
dataType := dataVal.Type()
@@ -724,7 +724,7 @@ func (d *Decoder) decodeInt(name string, data interface{}, val reflect.Value) er
return newDecodeError(name, &ParseError{
Expected: val,
Value: data,
- Err: err,
+ Err: wrapStrconvNumError(err),
})
}
case dataType.PkgPath() == "encoding/json" && dataType.Name() == "Number":
@@ -748,7 +748,7 @@ func (d *Decoder) decodeInt(name string, data interface{}, val reflect.Value) er
return nil
}
-func (d *Decoder) decodeUint(name string, data interface{}, val reflect.Value) error {
+func (d *Decoder) decodeUint(name string, data any, val reflect.Value) error {
dataVal := reflect.Indirect(reflect.ValueOf(data))
dataKind := getKind(dataVal)
dataType := dataVal.Type()
@@ -795,7 +795,7 @@ func (d *Decoder) decodeUint(name string, data interface{}, val reflect.Value) e
return newDecodeError(name, &ParseError{
Expected: val,
Value: data,
- Err: err,
+ Err: wrapStrconvNumError(err),
})
}
case dataType.PkgPath() == "encoding/json" && dataType.Name() == "Number":
@@ -805,7 +805,7 @@ func (d *Decoder) decodeUint(name string, data interface{}, val reflect.Value) e
return newDecodeError(name, &ParseError{
Expected: val,
Value: data,
- Err: err,
+ Err: wrapStrconvNumError(err),
})
}
val.SetUint(i)
@@ -819,7 +819,7 @@ func (d *Decoder) decodeUint(name string, data interface{}, val reflect.Value) e
return nil
}
-func (d *Decoder) decodeBool(name string, data interface{}, val reflect.Value) error {
+func (d *Decoder) decodeBool(name string, data any, val reflect.Value) error {
dataVal := reflect.Indirect(reflect.ValueOf(data))
dataKind := getKind(dataVal)
@@ -842,7 +842,7 @@ func (d *Decoder) decodeBool(name string, data interface{}, val reflect.Value) e
return newDecodeError(name, &ParseError{
Expected: val,
Value: data,
- Err: err,
+ Err: wrapStrconvNumError(err),
})
}
default:
@@ -855,7 +855,7 @@ func (d *Decoder) decodeBool(name string, data interface{}, val reflect.Value) e
return nil
}
-func (d *Decoder) decodeFloat(name string, data interface{}, val reflect.Value) error {
+func (d *Decoder) decodeFloat(name string, data any, val reflect.Value) error {
dataVal := reflect.Indirect(reflect.ValueOf(data))
dataKind := getKind(dataVal)
dataType := dataVal.Type()
@@ -886,7 +886,7 @@ func (d *Decoder) decodeFloat(name string, data interface{}, val reflect.Value)
return newDecodeError(name, &ParseError{
Expected: val,
Value: data,
- Err: err,
+ Err: wrapStrconvNumError(err),
})
}
case dataType.PkgPath() == "encoding/json" && dataType.Name() == "Number":
@@ -910,7 +910,7 @@ func (d *Decoder) decodeFloat(name string, data interface{}, val reflect.Value)
return nil
}
-func (d *Decoder) decodeComplex(name string, data interface{}, val reflect.Value) error {
+func (d *Decoder) decodeComplex(name string, data any, val reflect.Value) error {
dataVal := reflect.Indirect(reflect.ValueOf(data))
dataKind := getKind(dataVal)
@@ -927,7 +927,7 @@ func (d *Decoder) decodeComplex(name string, data interface{}, val reflect.Value
return nil
}
-func (d *Decoder) decodeMap(name string, data interface{}, val reflect.Value) error {
+func (d *Decoder) decodeMap(name string, data any, val reflect.Value) error {
valType := val.Type()
valKeyType := valType.Key()
valElemType := valType.Elem()
@@ -1176,7 +1176,7 @@ func (d *Decoder) decodeMapFromStruct(name string, dataVal reflect.Value, val re
return nil
}
-func (d *Decoder) decodePtr(name string, data interface{}, val reflect.Value) (bool, error) {
+func (d *Decoder) decodePtr(name string, data any, val reflect.Value) (bool, error) {
// If the input data is nil, then we want to just set the output
// pointer to be nil as well.
isNil := data == nil
@@ -1223,7 +1223,7 @@ func (d *Decoder) decodePtr(name string, data interface{}, val reflect.Value) (b
return false, nil
}
-func (d *Decoder) decodeFunc(name string, data interface{}, val reflect.Value) error {
+func (d *Decoder) decodeFunc(name string, data any, val reflect.Value) error {
// Create an element of the concrete (non pointer) type and decode
// into that. Then set the value of the pointer to this type.
dataVal := reflect.Indirect(reflect.ValueOf(data))
@@ -1237,7 +1237,7 @@ func (d *Decoder) decodeFunc(name string, data interface{}, val reflect.Value) e
return nil
}
-func (d *Decoder) decodeSlice(name string, data interface{}, val reflect.Value) error {
+func (d *Decoder) decodeSlice(name string, data any, val reflect.Value) error {
dataVal := reflect.Indirect(reflect.ValueOf(data))
dataValKind := dataVal.Kind()
valType := val.Type()
@@ -1259,7 +1259,7 @@ func (d *Decoder) decodeSlice(name string, data interface{}, val reflect.Value)
return nil
}
// Create slice of maps of other sizes
- return d.decodeSlice(name, []interface{}{data}, val)
+ return d.decodeSlice(name, []any{data}, val)
case dataValKind == reflect.String && valElemType.Kind() == reflect.Uint8:
return d.decodeSlice(name, []byte(dataVal.String()), val)
@@ -1268,7 +1268,7 @@ func (d *Decoder) decodeSlice(name string, data interface{}, val reflect.Value)
// and "lift" it into it. i.e. a string becomes a string slice.
default:
// Just re-try this function with data as a slice.
- return d.decodeSlice(name, []interface{}{data}, val)
+ return d.decodeSlice(name, []any{data}, val)
}
}
@@ -1311,7 +1311,7 @@ func (d *Decoder) decodeSlice(name string, data interface{}, val reflect.Value)
return errors.Join(errs...)
}
-func (d *Decoder) decodeArray(name string, data interface{}, val reflect.Value) error {
+func (d *Decoder) decodeArray(name string, data any, val reflect.Value) error {
dataVal := reflect.Indirect(reflect.ValueOf(data))
dataValKind := dataVal.Kind()
valType := val.Type()
@@ -1336,7 +1336,7 @@ func (d *Decoder) decodeArray(name string, data interface{}, val reflect.Value)
// and "lift" it into it. i.e. a string becomes a string array.
default:
// Just re-try this function with data as a slice.
- return d.decodeArray(name, []interface{}{data}, val)
+ return d.decodeArray(name, []any{data}, val)
}
}
@@ -1372,7 +1372,7 @@ func (d *Decoder) decodeArray(name string, data interface{}, val reflect.Value)
return errors.Join(errs...)
}
-func (d *Decoder) decodeStruct(name string, data interface{}, val reflect.Value) error {
+func (d *Decoder) decodeStruct(name string, data any, val reflect.Value) error {
dataVal := reflect.Indirect(reflect.ValueOf(data))
// If the type of the value to write to and the data match directly,
@@ -1393,7 +1393,7 @@ func (d *Decoder) decodeStruct(name string, data interface{}, val reflect.Value)
// as an intermediary.
// Make a new map to hold our result
- mapType := reflect.TypeOf((map[string]interface{})(nil))
+ mapType := reflect.TypeOf((map[string]any)(nil))
mval := reflect.MakeMap(mapType)
// Creating a pointer to a map so that other methods can completely
@@ -1424,13 +1424,13 @@ func (d *Decoder) decodeStructFromMap(name string, dataVal, val reflect.Value) e
}
dataValKeys := make(map[reflect.Value]struct{})
- dataValKeysUnused := make(map[interface{}]struct{})
+ dataValKeysUnused := make(map[any]struct{})
for _, dataValKey := range dataVal.MapKeys() {
dataValKeys[dataValKey] = struct{}{}
dataValKeysUnused[dataValKey.Interface()] = struct{}{}
}
- targetValKeysUnused := make(map[interface{}]struct{})
+ targetValKeysUnused := make(map[any]struct{})
var errs []error
@@ -1583,7 +1583,7 @@ func (d *Decoder) decodeStructFromMap(name string, dataVal, val reflect.Value) e
// we put the unused keys directly into the remain field.
if remainField != nil && len(dataValKeysUnused) > 0 {
// Build a map of only the unused values
- remain := map[interface{}]interface{}{}
+ remain := map[any]any{}
for key := range dataValKeysUnused {
remain[key] = dataVal.MapIndex(reflect.ValueOf(key)).Interface()
}
diff --git a/vendor/github.com/goccy/go-json/.gitignore b/vendor/github.com/goccy/go-json/.gitignore
deleted file mode 100644
index 37828382..00000000
--- a/vendor/github.com/goccy/go-json/.gitignore
+++ /dev/null
@@ -1,2 +0,0 @@
-cover.html
-cover.out
diff --git a/vendor/github.com/goccy/go-json/.golangci.yml b/vendor/github.com/goccy/go-json/.golangci.yml
deleted file mode 100644
index 977accaa..00000000
--- a/vendor/github.com/goccy/go-json/.golangci.yml
+++ /dev/null
@@ -1,86 +0,0 @@
-run:
- skip-files:
- - encode_optype.go
- - ".*_test\\.go$"
-
-linters-settings:
- govet:
- enable-all: true
- disable:
- - shadow
-
-linters:
- enable-all: true
- disable:
- - dogsled
- - dupl
- - exhaustive
- - exhaustivestruct
- - errorlint
- - forbidigo
- - funlen
- - gci
- - gochecknoglobals
- - gochecknoinits
- - gocognit
- - gocritic
- - gocyclo
- - godot
- - godox
- - goerr113
- - gofumpt
- - gomnd
- - gosec
- - ifshort
- - lll
- - makezero
- - nakedret
- - nestif
- - nlreturn
- - paralleltest
- - testpackage
- - thelper
- - wrapcheck
- - interfacer
- - lll
- - nakedret
- - nestif
- - nlreturn
- - testpackage
- - wsl
- - varnamelen
- - nilnil
- - ireturn
- - govet
- - forcetypeassert
- - cyclop
- - containedctx
- - revive
- - nosnakecase
- - exhaustruct
- - depguard
-
-issues:
- exclude-rules:
- # not needed
- - path: /*.go
- text: "ST1003: should not use underscores in package names"
- linters:
- - stylecheck
- - path: /*.go
- text: "don't use an underscore in package name"
- linters:
- - golint
- - path: rtype.go
- linters:
- - golint
- - stylecheck
- - path: error.go
- linters:
- - staticcheck
-
- # Maximum issues count per one linter. Set to 0 to disable. Default is 50.
- max-issues-per-linter: 0
-
- # Maximum count of issues with the same text. Set to 0 to disable. Default is 3.
- max-same-issues: 0
diff --git a/vendor/github.com/goccy/go-json/CHANGELOG.md b/vendor/github.com/goccy/go-json/CHANGELOG.md
deleted file mode 100644
index d09bb89c..00000000
--- a/vendor/github.com/goccy/go-json/CHANGELOG.md
+++ /dev/null
@@ -1,425 +0,0 @@
-# v0.10.2 - 2023/03/20
-
-### New features
-
-* Support DebugDOT option for debugging encoder ( #440 )
-
-### Fix bugs
-
-* Fix combination of embedding structure and omitempty option ( #442 )
-
-# v0.10.1 - 2023/03/13
-
-### Fix bugs
-
-* Fix checkptr error for array decoder ( #415 )
-* Fix added buffer size check when decoding key ( #430 )
-* Fix handling of anonymous fields other than struct ( #431 )
-* Fix to not optimize when lower conversion can't handle byte-by-byte ( #432 )
-* Fix a problem that MarshalIndent does not work when UnorderedMap is specified ( #435 )
-* Fix mapDecoder.DecodeStream() for empty objects containing whitespace ( #425 )
-* Fix an issue that could not set the correct NextField for fields in the embedded structure ( #438 )
-
-# v0.10.0 - 2022/11/29
-
-### New features
-
-* Support JSON Path ( #250 )
-
-### Fix bugs
-
-* Fix marshaler for map's key ( #409 )
-
-# v0.9.11 - 2022/08/18
-
-### Fix bugs
-
-* Fix unexpected behavior when buffer ends with backslash ( #383 )
-* Fix stream decoding of escaped character ( #387 )
-
-# v0.9.10 - 2022/07/15
-
-### Fix bugs
-
-* Fix boundary exception of type caching ( #382 )
-
-# v0.9.9 - 2022/07/15
-
-### Fix bugs
-
-* Fix encoding of directed interface with typed nil ( #377 )
-* Fix embedded primitive type encoding using alias ( #378 )
-* Fix slice/array type encoding with types implementing MarshalJSON ( #379 )
-* Fix unicode decoding when the expected buffer state is not met after reading ( #380 )
-
-# v0.9.8 - 2022/06/30
-
-### Fix bugs
-
-* Fix decoding of surrogate-pair ( #365 )
-* Fix handling of embedded primitive type ( #366 )
-* Add validation of escape sequence for decoder ( #367 )
-* Fix stream tokenizing respecting UseNumber ( #369 )
-* Fix encoding when struct pointer type that implements Marshal JSON is embedded ( #375 )
-
-### Improve performance
-
-* Improve performance of linkRecursiveCode ( #368 )
-
-# v0.9.7 - 2022/04/22
-
-### Fix bugs
-
-#### Encoder
-
-* Add filtering process for encoding on slow path ( #355 )
-* Fix encoding of interface{} with pointer type ( #363 )
-
-#### Decoder
-
-* Fix map key decoder that implements UnmarshalJSON ( #353 )
-* Fix decoding of []uint8 type ( #361 )
-
-### New features
-
-* Add DebugWith option for encoder ( #356 )
-
-# v0.9.6 - 2022/03/22
-
-### Fix bugs
-
-* Correct the handling of the minimum value of int type for decoder ( #344 )
-* Fix bugs of stream decoder's bufferSize ( #349 )
-* Add a guard to use typeptr more safely ( #351 )
-
-### Improve decoder performance
-
-* Improve escapeString's performance ( #345 )
-
-### Others
-
-* Update go version for CI ( #347 )
-
-# v0.9.5 - 2022/03/04
-
-### Fix bugs
-
-* Fix panic when decoding time.Time with context ( #328 )
-* Fix reading the next character in buffer to nul consideration ( #338 )
-* Fix incorrect handling on skipValue ( #341 )
-
-### Improve decoder performance
-
-* Improve performance when a payload contains escape sequence ( #334 )
-
-# v0.9.4 - 2022/01/21
-
-* Fix IsNilForMarshaler for string type with omitempty ( #323 )
-* Fix the case where the embedded field is at the end ( #326 )
-
-# v0.9.3 - 2022/01/14
-
-* Fix logic of removing struct field for decoder ( #322 )
-
-# v0.9.2 - 2022/01/14
-
-* Add invalid decoder to delay type error judgment at decode ( #321 )
-
-# v0.9.1 - 2022/01/11
-
-* Fix encoding of MarshalText/MarshalJSON operation with head offset ( #319 )
-
-# v0.9.0 - 2022/01/05
-
-### New feature
-
-* Supports dynamic filtering of struct fields ( #314 )
-
-### Improve encoding performance
-
-* Improve map encoding performance ( #310 )
-* Optimize encoding path for escaped string ( #311 )
-* Add encoding option for performance ( #312 )
-
-### Fix bugs
-
-* Fix panic at encoding map value on 1.18 ( #310 )
-* Fix MarshalIndent for interface type ( #317 )
-
-# v0.8.1 - 2021/12/05
-
-* Fix operation conversion from PtrHead to Head in Recursive type ( #305 )
-
-# v0.8.0 - 2021/12/02
-
-* Fix embedded field conflict behavior ( #300 )
-* Refactor compiler for encoder ( #301 #302 )
-
-# v0.7.10 - 2021/10/16
-
-* Fix conversion from pointer to uint64 ( #294 )
-
-# v0.7.9 - 2021/09/28
-
-* Fix encoding of nil value about interface type that has method ( #291 )
-
-# v0.7.8 - 2021/09/01
-
-* Fix mapassign_faststr for indirect struct type ( #283 )
-* Fix encoding of not empty interface type ( #284 )
-* Fix encoding of empty struct interface type ( #286 )
-
-# v0.7.7 - 2021/08/25
-
-* Fix invalid utf8 on stream decoder ( #279 )
-* Fix buffer length bug on string stream decoder ( #280 )
-
-Thank you @orisano !!
-
-# v0.7.6 - 2021/08/13
-
-* Fix nil slice assignment ( #276 )
-* Improve error message ( #277 )
-
-# v0.7.5 - 2021/08/12
-
-* Fix encoding of embedded struct with tags ( #265 )
-* Fix encoding of embedded struct that isn't first field ( #272 )
-* Fix decoding of binary type with escaped char ( #273 )
-
-# v0.7.4 - 2021/07/06
-
-* Fix encoding of indirect layout structure ( #264 )
-
-# v0.7.3 - 2021/06/29
-
-* Fix encoding of pointer type in empty interface ( #262 )
-
-# v0.7.2 - 2021/06/26
-
-### Fix decoder
-
-* Add decoder for func type to fix decoding of nil function value ( #257 )
-* Fix stream decoding of []byte type ( #258 )
-
-### Performance
-
-* Improve decoding performance of map[string]interface{} type ( use `mapassign_faststr` ) ( #256 )
-* Improve encoding performance of empty interface type ( remove recursive calling of `vm.Run` ) ( #259 )
-
-### Benchmark
-
-* Add bytedance/sonic as benchmark target ( #254 )
-
-# v0.7.1 - 2021/06/18
-
-### Fix decoder
-
-* Fix error when unmarshal empty array ( #253 )
-
-# v0.7.0 - 2021/06/12
-
-### Support context for MarshalJSON and UnmarshalJSON ( #248 )
-
-* json.MarshalContext(context.Context, interface{}, ...json.EncodeOption) ([]byte, error)
-* json.NewEncoder(io.Writer).EncodeContext(context.Context, interface{}, ...json.EncodeOption) error
-* json.UnmarshalContext(context.Context, []byte, interface{}, ...json.DecodeOption) error
-* json.NewDecoder(io.Reader).DecodeContext(context.Context, interface{}) error
-
-```go
-type MarshalerContext interface {
- MarshalJSON(context.Context) ([]byte, error)
-}
-
-type UnmarshalerContext interface {
- UnmarshalJSON(context.Context, []byte) error
-}
-```
-
-### Add DecodeFieldPriorityFirstWin option ( #242 )
-
-In the default behavior, go-json, like encoding/json, will reflect the result of the last evaluation when a field with the same name exists. I've added new options to allow you to change this behavior. `json.DecodeFieldPriorityFirstWin` option reflects the result of the first evaluation if a field with the same name exists. This behavior has a performance advantage as it allows the subsequent strings to be skipped if all fields have been evaluated.
-
-### Fix encoder
-
-* Fix indent number contains recursive type ( #249 )
-* Fix encoding of using empty interface as map key ( #244 )
-
-### Fix decoder
-
-* Fix decoding fields containing escaped characters ( #237 )
-
-### Refactor
-
-* Move some tests to subdirectory ( #243 )
-* Refactor package layout for decoder ( #238 )
-
-# v0.6.1 - 2021/06/02
-
-### Fix encoder
-
-* Fix value of totalLength for encoding ( #236 )
-
-# v0.6.0 - 2021/06/01
-
-### Support Colorize option for encoding (#233)
-
-```go
-b, err := json.MarshalWithOption(v, json.Colorize(json.DefaultColorScheme))
-if err != nil {
- ...
-}
-fmt.Println(string(b)) // print colored json
-```
-
-### Refactor
-
-* Fix opcode layout - Adjust memory layout of the opcode to 128 bytes in a 64-bit environment ( #230 )
-* Refactor encode option ( #231 )
-* Refactor escape string ( #232 )
-
-# v0.5.1 - 2021/5/20
-
-### Optimization
-
-* Add type addrShift to enable bigger encoder/decoder cache ( #213 )
-
-### Fix decoder
-
-* Keep original reference of slice element ( #229 )
-
-### Refactor
-
-* Refactor Debug mode for encoding ( #226 )
-* Generate VM sources for encoding ( #227 )
-* Refactor validator for null/true/false for decoding ( #221 )
-
-# v0.5.0 - 2021/5/9
-
-### Supports using omitempty and string tags at the same time ( #216 )
-
-### Fix decoder
-
-* Fix stream decoder for unicode char ( #215 )
-* Fix decoding of slice element ( #219 )
-* Fix calculating of buffer length for stream decoder ( #220 )
-
-### Refactor
-
-* replace skipWhiteSpace goto by loop ( #212 )
-
-# v0.4.14 - 2021/5/4
-
-### Benchmark
-
-* Add valyala/fastjson to benchmark ( #193 )
-* Add benchmark task for CI ( #211 )
-
-### Fix decoder
-
-* Fix decoding of slice with unmarshal json type ( #198 )
-* Fix decoding of null value for interface type that does not implement Unmarshaler ( #205 )
-* Fix decoding of null value to []byte by json.Unmarshal ( #206 )
-* Fix decoding of backslash char at the end of string ( #207 )
-* Fix stream decoder for null/true/false value ( #208 )
-* Fix stream decoder for slow reader ( #211 )
-
-### Performance
-
-* If cap of slice is enough, reuse slice data for compatibility with encoding/json ( #200 )
-
-# v0.4.13 - 2021/4/20
-
-### Fix json.Compact and json.Indent
-
-* Support validation the input buffer for json.Compact and json.Indent ( #189 )
-* Optimize json.Compact and json.Indent ( improve memory footprint ) ( #190 )
-
-# v0.4.12 - 2021/4/15
-
-### Fix encoder
-
-* Fix unnecessary indent for empty slice type ( #181 )
-* Fix encoding of omitempty feature for the slice or interface type ( #183 )
-* Fix encoding custom types zero values with omitempty when marshaller exists ( #187 )
-
-### Fix decoder
-
-* Fix decoder for invalid top level value ( #184 )
-* Fix decoder for invalid number value ( #185 )
-
-# v0.4.11 - 2021/4/3
-
-* Improve decoder performance for interface type
-
-# v0.4.10 - 2021/4/2
-
-### Fix encoder
-
-* Fixed a bug when encoding slice and map containing recursive structures
-* Fixed a logic to determine if indirect reference
-
-# v0.4.9 - 2021/3/29
-
-### Add debug mode
-
-If you use `json.MarshalWithOption(v, json.Debug())` and `panic` occurred in `go-json`, produces debug information to console.
-
-### Support a new feature to compatible with encoding/json
-
-- invalid UTF-8 is coerced to valid UTF-8 ( without performance down )
-
-### Fix encoder
-
-- Fixed handling of MarshalJSON of function type
-
-### Fix decoding of slice of pointer type
-
-If there is a pointer value, go-json will use it. (This behavior is necessary to achieve the ability to prioritize pre-filled values). However, since slices are reused internally, there was a bug that referred to the previous pointer value. Therefore, it is not necessary to refer to the pointer value in advance for the slice element, so we explicitly initialize slice element by `nil`.
-
-# v0.4.8 - 2021/3/21
-
-### Reduce memory usage at compile time
-
-* go-json have used about 2GB of memory at compile time, but now it can compile with about less than 550MB.
-
-### Fix any encoder's bug
-
-* Add many test cases for encoder
-* Fix composite type ( slice/array/map )
-* Fix pointer types
-* Fix encoding of MarshalJSON or MarshalText or json.Number type
-
-### Refactor encoder
-
-* Change package layout for reducing memory usage at compile
-* Remove anonymous and only operation
-* Remove root property from encodeCompileContext and opcode
-
-### Fix CI
-
-* Add Go 1.16
-* Remove Go 1.13
-* Fix `make cover` task
-
-### Number/Delim/Token/RawMessage use the types defined in encoding/json by type alias
-
-# v0.4.7 - 2021/02/22
-
-### Fix decoder
-
-* Fix decoding of deep recursive structure
-* Fix decoding of embedded unexported pointer field
-* Fix invalid test case
-* Fix decoding of invalid value
-* Fix decoding of prefilled value
-* Fix not being able to return UnmarshalTypeError when it should be returned
-* Fix decoding of null value
-* Fix decoding of type of null string
-* Use pre allocated pointer if exists it at decoding
-
-### Reduce memory usage at compile
-
-* Integrate int/int8/int16/int32/int64 and uint/uint8/uint16/uint32/uint64 operation to reduce memory usage at compile
-
-### Remove unnecessary optype
diff --git a/vendor/github.com/goccy/go-json/Makefile b/vendor/github.com/goccy/go-json/Makefile
deleted file mode 100644
index c030577d..00000000
--- a/vendor/github.com/goccy/go-json/Makefile
+++ /dev/null
@@ -1,39 +0,0 @@
-PKG := github.com/goccy/go-json
-
-BIN_DIR := $(CURDIR)/bin
-PKGS := $(shell go list ./... | grep -v internal/cmd|grep -v test)
-COVER_PKGS := $(foreach pkg,$(PKGS),$(subst $(PKG),.,$(pkg)))
-
-COMMA := ,
-EMPTY :=
-SPACE := $(EMPTY) $(EMPTY)
-COVERPKG_OPT := $(subst $(SPACE),$(COMMA),$(COVER_PKGS))
-
-$(BIN_DIR):
- @mkdir -p $(BIN_DIR)
-
-.PHONY: cover
-cover:
- go test -coverpkg=$(COVERPKG_OPT) -coverprofile=cover.out ./...
-
-.PHONY: cover-html
-cover-html: cover
- go tool cover -html=cover.out
-
-.PHONY: lint
-lint: golangci-lint
- $(BIN_DIR)/golangci-lint run
-
-golangci-lint: | $(BIN_DIR)
- @{ \
- set -e; \
- GOLANGCI_LINT_TMP_DIR=$$(mktemp -d); \
- cd $$GOLANGCI_LINT_TMP_DIR; \
- go mod init tmp; \
- GOBIN=$(BIN_DIR) go install github.com/golangci/golangci-lint/cmd/golangci-lint@v1.54.2; \
- rm -rf $$GOLANGCI_LINT_TMP_DIR; \
- }
-
-.PHONY: generate
-generate:
- go generate ./internal/...
diff --git a/vendor/github.com/goccy/go-json/README.md b/vendor/github.com/goccy/go-json/README.md
deleted file mode 100644
index 7bacc54f..00000000
--- a/vendor/github.com/goccy/go-json/README.md
+++ /dev/null
@@ -1,529 +0,0 @@
-# go-json
-
-
-[](https://pkg.go.dev/github.com/goccy/go-json?tab=doc)
-[](https://codecov.io/gh/goccy/go-json)
-
-Fast JSON encoder/decoder compatible with encoding/json for Go
-
-
-
-# Roadmap
-
-```
-* version ( expected release date )
-
-* v0.9.0
- |
- | while maintaining compatibility with encoding/json, we will add convenient APIs
- |
- v
-* v1.0.0
-```
-
-We are accepting requests for features that will be implemented between v0.9.0 and v.1.0.0.
-If you have the API you need, please submit your issue [here](https://github.com/goccy/go-json/issues).
-
-# Features
-
-- Drop-in replacement of `encoding/json`
-- Fast ( See [Benchmark section](https://github.com/goccy/go-json#benchmarks) )
-- Flexible customization with options
-- Coloring the encoded string
-- Can propagate context.Context to `MarshalJSON` or `UnmarshalJSON`
-- Can dynamically filter the fields of the structure type-safely
-
-# Installation
-
-```
-go get github.com/goccy/go-json
-```
-
-# How to use
-
-Replace import statement from `encoding/json` to `github.com/goccy/go-json`
-
-```
--import "encoding/json"
-+import "github.com/goccy/go-json"
-```
-
-# JSON library comparison
-
-| name | encoder | decoder | compatible with `encoding/json` |
-| :----: | :------: | :-----: | :-----------------------------: |
-| encoding/json | yes | yes | N/A |
-| [json-iterator/go](https://github.com/json-iterator/go) | yes | yes | partial |
-| [easyjson](https://github.com/mailru/easyjson) | yes | yes | no |
-| [gojay](https://github.com/francoispqt/gojay) | yes | yes | no |
-| [segmentio/encoding/json](https://github.com/segmentio/encoding/tree/master/json) | yes | yes | partial |
-| [jettison](https://github.com/wI2L/jettison) | yes | no | no |
-| [simdjson-go](https://github.com/minio/simdjson-go) | no | yes | no |
-| goccy/go-json | yes | yes | yes |
-
-- `json-iterator/go` isn't compatible with `encoding/json` in many ways (e.g. https://github.com/json-iterator/go/issues/229 ), but it hasn't been supported for a long time.
-- `segmentio/encoding/json` is well supported for encoders, but some are not supported for decoder APIs such as `Token` ( streaming decode )
-
-## Other libraries
-
-- [jingo](https://github.com/bet365/jingo)
-
-I tried the benchmark but it didn't work.
-Also, it seems to panic when it receives an unexpected value because there is no error handling...
-
-- [ffjson](https://github.com/pquerna/ffjson)
-
-Benchmarking gave very slow results.
-It seems that it is assumed that the user will use the buffer pool properly.
-Also, development seems to have already stopped
-
-# Benchmarks
-
-```
-$ cd benchmarks
-$ go test -bench .
-```
-
-## Encode
-
-
-
-
-## Decode
-
-
-
-
-
-
-# Fuzzing
-
-[go-json-fuzz](https://github.com/goccy/go-json-fuzz) is the repository for fuzzing tests.
-If you run the test in this repository and find a bug, please commit to corpus to go-json-fuzz and report the issue to [go-json](https://github.com/goccy/go-json/issues).
-
-# How it works
-
-`go-json` is very fast in both encoding and decoding compared to other libraries.
-It's easier to implement by using automatic code generation for performance or by using a dedicated interface, but `go-json` dares to stick to compatibility with `encoding/json` and is the simple interface. Despite this, we are developing with the aim of being the fastest library.
-
-Here, we explain the various speed-up techniques implemented by `go-json`.
-
-## Basic technique
-
-The techniques listed here are the ones used by most of the libraries listed above.
-
-### Buffer reuse
-
-Since the only value required for the result of `json.Marshal(interface{}) ([]byte, error)` is `[]byte`, the only value that must be allocated during encoding is the return value `[]byte` .
-
-Also, as the number of allocations increases, the performance will be affected, so the number of allocations should be kept as low as possible when creating `[]byte`.
-
-Therefore, there is a technique to reduce the number of times a new buffer must be allocated by reusing the buffer used for the previous encoding by using `sync.Pool`.
-
-Finally, you allocate a buffer that is as long as the resulting buffer and copy the contents into it, you only need to allocate the buffer once in theory.
-
-```go
-type buffer struct {
- data []byte
-}
-
-var bufPool = sync.Pool{
- New: func() interface{} {
- return &buffer{data: make([]byte, 0, 1024)}
- },
-}
-
-buf := bufPool.Get().(*buffer)
-data := encode(buf.data) // reuse buf.data
-
-newBuf := make([]byte, len(data))
-copy(newBuf, buf)
-
-buf.data = data
-bufPool.Put(buf)
-```
-
-### Elimination of reflection
-
-As you know, the reflection operation is very slow.
-
-Therefore, using the fact that the address position where the type information is stored is fixed for each binary ( we call this `typeptr` ),
-we can use the address in the type information to call a pre-built optimized process.
-
-For example, you can get the address to the type information from `interface{}` as follows and you can use that information to call a process that does not have reflection.
-
-To process without reflection, pass a pointer (`unsafe.Pointer`) to the value is stored.
-
-```go
-
-type emptyInterface struct {
- typ unsafe.Pointer
- ptr unsafe.Pointer
-}
-
-var typeToEncoder = map[uintptr]func(unsafe.Pointer)([]byte, error){}
-
-func Marshal(v interface{}) ([]byte, error) {
- iface := (*emptyInterface)(unsafe.Pointer(&v)
- typeptr := uintptr(iface.typ)
- if enc, exists := typeToEncoder[typeptr]; exists {
- return enc(iface.ptr)
- }
- ...
-}
-```
-
-※ In reality, `typeToEncoder` can be referenced by multiple goroutines, so exclusive control is required.
-
-## Unique speed-up technique
-
-## Encoder
-
-### Do not escape arguments of `Marshal`
-
-`json.Marshal` and `json.Unmarshal` receive `interface{}` value and they perform type determination dynamically to process.
-In normal case, you need to use the `reflect` library to determine the type dynamically, but since `reflect.Type` is defined as `interface`, when you call the method of `reflect.Type`, The reflect's argument is escaped.
-
-Therefore, the arguments for `Marshal` and `Unmarshal` are always escaped to the heap.
-However, `go-json` can use the feature of `reflect.Type` while avoiding escaping.
-
-`reflect.Type` is defined as `interface`, but in reality `reflect.Type` is implemented only by the structure `rtype` defined in the `reflect` package.
-For this reason, to date `reflect.Type` is the same as `*reflect.rtype`.
-
-Therefore, by directly handling `*reflect.rtype`, which is an implementation of `reflect.Type`, it is possible to avoid escaping because it changes from `interface` to using `struct`.
-
-The technique for working with `*reflect.rtype` directly from `go-json` is implemented at [rtype.go](https://github.com/goccy/go-json/blob/master/internal/runtime/rtype.go)
-
-Also, the same technique is cut out as a library ( https://github.com/goccy/go-reflect )
-
-Initially this feature was the default behavior of `go-json`.
-But after careful testing, I found that I passed a large value to `json.Marshal()` and if the argument could not be assigned to the stack, it could not be properly escaped to the heap (a bug in the Go compiler).
-
-Therefore, this feature will be provided as an **optional** until this issue is resolved.
-
-To use it, add `NoEscape` like `MarshalNoEscape()`
-
-### Encoding using opcode sequence
-
-I explained that you can use `typeptr` to call a pre-built process from type information.
-
-In other libraries, this dedicated process is processed by making it an function calling like anonymous function, but function calls are inherently slow processes and should be avoided as much as possible.
-
-Therefore, `go-json` adopted the Instruction-based execution processing system, which is also used to implement virtual machines for programming language.
-
-If it is the first type to encode, create the opcode ( instruction ) sequence required for encoding.
-From the second time onward, use `typeptr` to get the cached pre-built opcode sequence and encode it based on it. An example of the opcode sequence is shown below.
-
-```go
-json.Marshal(struct{
- X int `json:"x"`
- Y string `json:"y"`
-}{X: 1, Y: "hello"})
-```
-
-When encoding a structure like the one above, create a sequence of opcodes like this:
-
-```
-- opStructFieldHead ( `{` )
-- opStructFieldInt ( `"x": 1,` )
-- opStructFieldString ( `"y": "hello"` )
-- opStructEnd ( `}` )
-- opEnd
-```
-
-※ When processing each operation, write the letters on the right.
-
-In addition, each opcode is managed by the following structure (
-Pseudo code ).
-
-```go
-type opType int
-const (
- opStructFieldHead opType = iota
- opStructFieldInt
- opStructFieldStirng
- opStructEnd
- opEnd
-)
-type opcode struct {
- op opType
- key []byte
- next *opcode
-}
-```
-
-The process of encoding using the opcode sequence is roughly implemented as follows.
-
-```go
-func encode(code *opcode, b []byte, p unsafe.Pointer) ([]byte, error) {
- for {
- switch code.op {
- case opStructFieldHead:
- b = append(b, '{')
- code = code.next
- case opStructFieldInt:
- b = append(b, code.key...)
- b = appendInt((*int)(unsafe.Pointer(uintptr(p)+code.offset)))
- code = code.next
- case opStructFieldString:
- b = append(b, code.key...)
- b = appendString((*string)(unsafe.Pointer(uintptr(p)+code.offset)))
- code = code.next
- case opStructEnd:
- b = append(b, '}')
- code = code.next
- case opEnd:
- goto END
- }
- }
-END:
- return b, nil
-}
-```
-
-In this way, the huge `switch-case` is used to encode by manipulating the linked list opcodes to avoid unnecessary function calls.
-
-### Opcode sequence optimization
-
-One of the advantages of encoding using the opcode sequence is the ease of optimization.
-The opcode sequence mentioned above is actually converted into the following optimized operations and used.
-
-```
-- opStructFieldHeadInt ( `{"x": 1,` )
-- opStructEndString ( `"y": "hello"}` )
-- opEnd
-```
-
-It has been reduced from 5 opcodes to 3 opcodes !
-Reducing the number of opcodees means reducing the number of branches with `switch-case`.
-In other words, the closer the number of operations is to 1, the faster the processing can be performed.
-
-In `go-json`, optimization to reduce the number of opcodes itself like the above and it speeds up by preparing opcodes with optimized paths.
-
-### Change recursive call from CALL to JMP
-
-Recursive processing is required during encoding if the type is defined recursively as follows:
-
-```go
-type T struct {
- X int
- U *U
-}
-
-type U struct {
- T *T
-}
-
-b, err := json.Marshal(&T{
- X: 1,
- U: &U{
- T: &T{
- X: 2,
- },
- },
-})
-fmt.Println(string(b)) // {"X":1,"U":{"T":{"X":2,"U":null}}}
-```
-
-In `go-json`, recursive processing is processed by the operation type of ` opStructFieldRecursive`.
-
-In this operation, after acquiring the opcode sequence used for recursive processing, the function is **not** called recursively as it is, but the necessary values are saved by itself and implemented by moving to the next operation.
-
-The technique of implementing recursive processing with the `JMP` operation while avoiding the `CALL` operation is a famous technique for implementing a high-speed virtual machine.
-
-For more details, please refer to [the article](https://engineering.mercari.com/blog/entry/1599563768-081104c850) ( but Japanese only ).
-
-### Dispatch by typeptr from map to slice
-
-When retrieving the data cached from the type information by `typeptr`, we usually use map.
-Map requires exclusive control, so use `sync.Map` for a naive implementation.
-
-However, this is slow, so it's a good idea to use the `atomic` package for exclusive control as implemented by `segmentio/encoding/json` ( https://github.com/segmentio/encoding/blob/master/json/codec.go#L41-L55 ).
-
-This implementation slows down the set instead of speeding up the get, but it works well because of the nature of the library, it encodes much more for the same type.
-
-However, as a result of profiling, I noticed that `runtime.mapaccess2` accounts for a significant percentage of the execution time. So I thought if I could change the lookup from map to slice.
-
-There is an API named `typelinks` defined in the `runtime` package that the `reflect` package uses internally.
-This allows you to get all the type information defined in the binary at runtime.
-
-The fact that all type information can be acquired means that by constructing slices in advance with the acquired total number of type information, it is possible to look up with the value of `typeptr` without worrying about out-of-range access.
-
-However, if there is too much type information, it will use a lot of memory, so by default we will only use this optimization if the slice size fits within **2Mib** .
-
-If this approach is not available, it will fall back to the `atomic` based process described above.
-
-If you want to know more, please refer to the implementation [here](https://github.com/goccy/go-json/blob/master/internal/runtime/type.go#L36-L100)
-
-## Decoder
-
-### Dispatch by typeptr from map to slice
-
-Like the encoder, the decoder also uses typeptr to call the dedicated process.
-
-### Faster termination character inspection using NUL character
-
-In order to decode, you have to traverse the input buffer character by position.
-At that time, if you check whether the buffer has reached the end, it will be very slow.
-
-`buf` : `[]byte` type variable. holds the string passed to the decoder
-`cursor` : `int64` type variable. holds the current read position
-
-```go
-buflen := len(buf)
-for ; cursor < buflen; cursor++ { // compare cursor and buflen at all times, it is so slow.
- switch buf[cursor] {
- case ' ', '\n', '\r', '\t':
- }
-}
-```
-
-Therefore, by adding the `NUL` (`\000`) character to the end of the read buffer as shown below, it is possible to check the termination character at the same time as other characters.
-
-```go
-for {
- switch buf[cursor] {
- case ' ', '\n', '\r', '\t':
- case '\000':
- return nil
- }
- cursor++
-}
-```
-
-### Use Boundary Check Elimination
-
-Due to the `NUL` character optimization, the Go compiler does a boundary check every time, even though `buf[cursor]` does not cause out-of-range access.
-
-Therefore, `go-json` eliminates boundary check by fetching characters for hotspot by pointer operation. For example, the following code.
-
-```go
-func char(ptr unsafe.Pointer, offset int64) byte {
- return *(*byte)(unsafe.Pointer(uintptr(ptr) + uintptr(offset)))
-}
-
-p := (*sliceHeader)(&unsafe.Pointer(buf)).data
-for {
- switch char(p, cursor) {
- case ' ', '\n', '\r', '\t':
- case '\000':
- return nil
- }
- cursor++
-}
-```
-
-### Checking the existence of fields of struct using Bitmaps
-
-I found by the profiling result, in the struct decode, lookup process for field was taking a long time.
-
-For example, consider decoding a string like `{"a":1,"b":2,"c":3}` into the following structure:
-
-```go
-type T struct {
- A int `json:"a"`
- B int `json:"b"`
- C int `json:"c"`
-}
-```
-
-At this time, it was found that it takes a lot of time to acquire the decoding process corresponding to the field from the field name as shown below during the decoding process.
-
-```go
-fieldName := decodeKey(buf, cursor) // "a" or "b" or "c"
-decoder, exists := fieldToDecoderMap[fieldName] // so slow
-if exists {
- decoder(buf, cursor)
-} else {
- skipValue(buf, cursor)
-}
-```
-
-To improve this process, `json-iterator/go` is optimized so that it can be branched by switch-case when the number of fields in the structure is 10 or less (switch-case is faster than map). However, there is a risk of hash collision because the value hashed by the FNV algorithm is used for conditional branching. Also, `gojay` processes this part at high speed by letting the library user yourself write `switch-case`.
-
-
-`go-json` considers and implements a new approach that is different from these. I call this **bitmap field optimization**.
-
-The range of values per character can be represented by `[256]byte`. Also, if the number of fields in the structure is 8 or less, `int8` type can represent the state of each field.
-In other words, it has the following structure.
-
-- Base ( 8bit ): `00000000`
-- Key "a": `00000001` ( assign key "a" to the first bit )
-- Key "b": `00000010` ( assign key "b" to the second bit )
-- Key "c": `00000100` ( assign key "c" to the third bit )
-
-Bitmap structure is the following
-
-```
- | key index(0) |
-------------------------
- 0 | 00000000 |
- 1 | 00000000 |
-~~ | |
-97 (a) | 00000001 |
-98 (b) | 00000010 |
-99 (c) | 00000100 |
-~~ | |
-255 | 00000000 |
-```
-
-You can think of this as a Bitmap with a height of `256` and a width of the maximum string length in the field name.
-In other words, it can be represented by the following type .
-
-```go
-[maxFieldKeyLength][256]int8
-```
-
-When decoding a field character, check whether the corresponding character exists by referring to the pre-built bitmap like the following.
-
-```go
-var curBit int8 = math.MaxInt8 // 11111111
-
-c := char(buf, cursor)
-bit := bitmap[keyIdx][c]
-curBit &= bit
-if curBit == 0 {
- // not found field
-}
-```
-
-If `curBit` is not `0` until the end of the field string, then the string is
-You may have hit one of the fields.
-But the possibility is that if the decoded string is shorter than the field string, you will get a false hit.
-
-- input: `{"a":1}`
-```go
-type T struct {
- X int `json:"abc"`
-}
-```
-※ Since `a` is shorter than `abc`, it can decode to the end of the field character without `curBit` being 0.
-
-Rest assured. In this case, it doesn't matter because you can tell if you hit by comparing the string length of `a` with the string length of `abc`.
-
-Finally, calculate the position of the bit where `1` is set and get the corresponding value, and you're done.
-
-Using this technique, field lookups are possible with only bitwise operations and access to slices.
-
-`go-json` uses a similar technique for fields with 9 or more and 16 or less fields. At this time, Bitmap is constructed as `[maxKeyLen][256]int16` type.
-
-Currently, this optimization is not performed when the maximum length of the field name is long (specifically, 64 bytes or more) in addition to the limitation of the number of fields from the viewpoint of saving memory usage.
-
-### Others
-
-I have done a lot of other optimizations. I will find time to write about them. If you have any questions about what's written here or other optimizations, please visit the `#go-json` channel on `gophers.slack.com` .
-
-## Reference
-
-Regarding the story of go-json, there are the following articles in Japanese only.
-
-- https://speakerdeck.com/goccy/zui-su-falsejsonraiburariwoqiu-mete
-- https://engineering.mercari.com/blog/entry/1599563768-081104c850/
-
-# Looking for Sponsors
-
-I'm looking for sponsors this library. This library is being developed as a personal project in my spare time. If you want a quick response or problem resolution when using this library in your project, please register as a [sponsor](https://github.com/sponsors/goccy). I will cooperate as much as possible. Of course, this library is developed as an MIT license, so you can use it freely for free.
-
-# License
-
-MIT
diff --git a/vendor/github.com/goccy/go-json/color.go b/vendor/github.com/goccy/go-json/color.go
deleted file mode 100644
index e80b22b4..00000000
--- a/vendor/github.com/goccy/go-json/color.go
+++ /dev/null
@@ -1,68 +0,0 @@
-package json
-
-import (
- "fmt"
-
- "github.com/goccy/go-json/internal/encoder"
-)
-
-type (
- ColorFormat = encoder.ColorFormat
- ColorScheme = encoder.ColorScheme
-)
-
-const escape = "\x1b"
-
-type colorAttr int
-
-//nolint:deadcode,varcheck
-const (
- fgBlackColor colorAttr = iota + 30
- fgRedColor
- fgGreenColor
- fgYellowColor
- fgBlueColor
- fgMagentaColor
- fgCyanColor
- fgWhiteColor
-)
-
-//nolint:deadcode,varcheck
-const (
- fgHiBlackColor colorAttr = iota + 90
- fgHiRedColor
- fgHiGreenColor
- fgHiYellowColor
- fgHiBlueColor
- fgHiMagentaColor
- fgHiCyanColor
- fgHiWhiteColor
-)
-
-func createColorFormat(attr colorAttr) ColorFormat {
- return ColorFormat{
- Header: wrapColor(attr),
- Footer: resetColor(),
- }
-}
-
-func wrapColor(attr colorAttr) string {
- return fmt.Sprintf("%s[%dm", escape, attr)
-}
-
-func resetColor() string {
- return wrapColor(colorAttr(0))
-}
-
-var (
- DefaultColorScheme = &ColorScheme{
- Int: createColorFormat(fgHiMagentaColor),
- Uint: createColorFormat(fgHiMagentaColor),
- Float: createColorFormat(fgHiMagentaColor),
- Bool: createColorFormat(fgHiYellowColor),
- String: createColorFormat(fgHiGreenColor),
- Binary: createColorFormat(fgHiRedColor),
- ObjectKey: createColorFormat(fgHiCyanColor),
- Null: createColorFormat(fgBlueColor),
- }
-)
diff --git a/vendor/github.com/goccy/go-json/decode.go b/vendor/github.com/goccy/go-json/decode.go
deleted file mode 100644
index 74c6ac3b..00000000
--- a/vendor/github.com/goccy/go-json/decode.go
+++ /dev/null
@@ -1,263 +0,0 @@
-package json
-
-import (
- "context"
- "fmt"
- "io"
- "reflect"
- "unsafe"
-
- "github.com/goccy/go-json/internal/decoder"
- "github.com/goccy/go-json/internal/errors"
- "github.com/goccy/go-json/internal/runtime"
-)
-
-type Decoder struct {
- s *decoder.Stream
-}
-
-const (
- nul = '\000'
-)
-
-type emptyInterface struct {
- typ *runtime.Type
- ptr unsafe.Pointer
-}
-
-func unmarshal(data []byte, v interface{}, optFuncs ...DecodeOptionFunc) error {
- src := make([]byte, len(data)+1) // append nul byte to the end
- copy(src, data)
-
- header := (*emptyInterface)(unsafe.Pointer(&v))
-
- if err := validateType(header.typ, uintptr(header.ptr)); err != nil {
- return err
- }
- dec, err := decoder.CompileToGetDecoder(header.typ)
- if err != nil {
- return err
- }
- ctx := decoder.TakeRuntimeContext()
- ctx.Buf = src
- ctx.Option.Flags = 0
- for _, optFunc := range optFuncs {
- optFunc(ctx.Option)
- }
- cursor, err := dec.Decode(ctx, 0, 0, header.ptr)
- if err != nil {
- decoder.ReleaseRuntimeContext(ctx)
- return err
- }
- decoder.ReleaseRuntimeContext(ctx)
- return validateEndBuf(src, cursor)
-}
-
-func unmarshalContext(ctx context.Context, data []byte, v interface{}, optFuncs ...DecodeOptionFunc) error {
- src := make([]byte, len(data)+1) // append nul byte to the end
- copy(src, data)
-
- header := (*emptyInterface)(unsafe.Pointer(&v))
-
- if err := validateType(header.typ, uintptr(header.ptr)); err != nil {
- return err
- }
- dec, err := decoder.CompileToGetDecoder(header.typ)
- if err != nil {
- return err
- }
- rctx := decoder.TakeRuntimeContext()
- rctx.Buf = src
- rctx.Option.Flags = 0
- rctx.Option.Flags |= decoder.ContextOption
- rctx.Option.Context = ctx
- for _, optFunc := range optFuncs {
- optFunc(rctx.Option)
- }
- cursor, err := dec.Decode(rctx, 0, 0, header.ptr)
- if err != nil {
- decoder.ReleaseRuntimeContext(rctx)
- return err
- }
- decoder.ReleaseRuntimeContext(rctx)
- return validateEndBuf(src, cursor)
-}
-
-var (
- pathDecoder = decoder.NewPathDecoder()
-)
-
-func extractFromPath(path *Path, data []byte, optFuncs ...DecodeOptionFunc) ([][]byte, error) {
- if path.path.RootSelectorOnly {
- return [][]byte{data}, nil
- }
- src := make([]byte, len(data)+1) // append nul byte to the end
- copy(src, data)
-
- ctx := decoder.TakeRuntimeContext()
- ctx.Buf = src
- ctx.Option.Flags = 0
- ctx.Option.Flags |= decoder.PathOption
- ctx.Option.Path = path.path
- for _, optFunc := range optFuncs {
- optFunc(ctx.Option)
- }
- paths, cursor, err := pathDecoder.DecodePath(ctx, 0, 0)
- if err != nil {
- decoder.ReleaseRuntimeContext(ctx)
- return nil, err
- }
- decoder.ReleaseRuntimeContext(ctx)
- if err := validateEndBuf(src, cursor); err != nil {
- return nil, err
- }
- return paths, nil
-}
-
-func unmarshalNoEscape(data []byte, v interface{}, optFuncs ...DecodeOptionFunc) error {
- src := make([]byte, len(data)+1) // append nul byte to the end
- copy(src, data)
-
- header := (*emptyInterface)(unsafe.Pointer(&v))
-
- if err := validateType(header.typ, uintptr(header.ptr)); err != nil {
- return err
- }
- dec, err := decoder.CompileToGetDecoder(header.typ)
- if err != nil {
- return err
- }
-
- ctx := decoder.TakeRuntimeContext()
- ctx.Buf = src
- ctx.Option.Flags = 0
- for _, optFunc := range optFuncs {
- optFunc(ctx.Option)
- }
- cursor, err := dec.Decode(ctx, 0, 0, noescape(header.ptr))
- if err != nil {
- decoder.ReleaseRuntimeContext(ctx)
- return err
- }
- decoder.ReleaseRuntimeContext(ctx)
- return validateEndBuf(src, cursor)
-}
-
-func validateEndBuf(src []byte, cursor int64) error {
- for {
- switch src[cursor] {
- case ' ', '\t', '\n', '\r':
- cursor++
- continue
- case nul:
- return nil
- }
- return errors.ErrSyntax(
- fmt.Sprintf("invalid character '%c' after top-level value", src[cursor]),
- cursor+1,
- )
- }
-}
-
-//nolint:staticcheck
-//go:nosplit
-func noescape(p unsafe.Pointer) unsafe.Pointer {
- x := uintptr(p)
- return unsafe.Pointer(x ^ 0)
-}
-
-func validateType(typ *runtime.Type, p uintptr) error {
- if typ == nil || typ.Kind() != reflect.Ptr || p == 0 {
- return &InvalidUnmarshalError{Type: runtime.RType2Type(typ)}
- }
- return nil
-}
-
-// NewDecoder returns a new decoder that reads from r.
-//
-// The decoder introduces its own buffering and may
-// read data from r beyond the JSON values requested.
-func NewDecoder(r io.Reader) *Decoder {
- s := decoder.NewStream(r)
- return &Decoder{
- s: s,
- }
-}
-
-// Buffered returns a reader of the data remaining in the Decoder's
-// buffer. The reader is valid until the next call to Decode.
-func (d *Decoder) Buffered() io.Reader {
- return d.s.Buffered()
-}
-
-// Decode reads the next JSON-encoded value from its
-// input and stores it in the value pointed to by v.
-//
-// See the documentation for Unmarshal for details about
-// the conversion of JSON into a Go value.
-func (d *Decoder) Decode(v interface{}) error {
- return d.DecodeWithOption(v)
-}
-
-// DecodeContext reads the next JSON-encoded value from its
-// input and stores it in the value pointed to by v with context.Context.
-func (d *Decoder) DecodeContext(ctx context.Context, v interface{}) error {
- d.s.Option.Flags |= decoder.ContextOption
- d.s.Option.Context = ctx
- return d.DecodeWithOption(v)
-}
-
-func (d *Decoder) DecodeWithOption(v interface{}, optFuncs ...DecodeOptionFunc) error {
- header := (*emptyInterface)(unsafe.Pointer(&v))
- typ := header.typ
- ptr := uintptr(header.ptr)
- typeptr := uintptr(unsafe.Pointer(typ))
- // noescape trick for header.typ ( reflect.*rtype )
- copiedType := *(**runtime.Type)(unsafe.Pointer(&typeptr))
-
- if err := validateType(copiedType, ptr); err != nil {
- return err
- }
-
- dec, err := decoder.CompileToGetDecoder(typ)
- if err != nil {
- return err
- }
- if err := d.s.PrepareForDecode(); err != nil {
- return err
- }
- s := d.s
- for _, optFunc := range optFuncs {
- optFunc(s.Option)
- }
- if err := dec.DecodeStream(s, 0, header.ptr); err != nil {
- return err
- }
- s.Reset()
- return nil
-}
-
-func (d *Decoder) More() bool {
- return d.s.More()
-}
-
-func (d *Decoder) Token() (Token, error) {
- return d.s.Token()
-}
-
-// DisallowUnknownFields causes the Decoder to return an error when the destination
-// is a struct and the input contains object keys which do not match any
-// non-ignored, exported fields in the destination.
-func (d *Decoder) DisallowUnknownFields() {
- d.s.DisallowUnknownFields = true
-}
-
-func (d *Decoder) InputOffset() int64 {
- return d.s.TotalOffset()
-}
-
-// UseNumber causes the Decoder to unmarshal a number into an interface{} as a
-// Number instead of as a float64.
-func (d *Decoder) UseNumber() {
- d.s.UseNumber = true
-}
diff --git a/vendor/github.com/goccy/go-json/docker-compose.yml b/vendor/github.com/goccy/go-json/docker-compose.yml
deleted file mode 100644
index db40c79a..00000000
--- a/vendor/github.com/goccy/go-json/docker-compose.yml
+++ /dev/null
@@ -1,13 +0,0 @@
-version: '2'
-services:
- go-json:
- image: golang:1.18
- volumes:
- - '.:/go/src/go-json'
- deploy:
- resources:
- limits:
- memory: 620M
- working_dir: /go/src/go-json
- command: |
- sh -c "go test -c . && ls go-json.test"
diff --git a/vendor/github.com/goccy/go-json/encode.go b/vendor/github.com/goccy/go-json/encode.go
deleted file mode 100644
index c5173825..00000000
--- a/vendor/github.com/goccy/go-json/encode.go
+++ /dev/null
@@ -1,326 +0,0 @@
-package json
-
-import (
- "context"
- "io"
- "os"
- "unsafe"
-
- "github.com/goccy/go-json/internal/encoder"
- "github.com/goccy/go-json/internal/encoder/vm"
- "github.com/goccy/go-json/internal/encoder/vm_color"
- "github.com/goccy/go-json/internal/encoder/vm_color_indent"
- "github.com/goccy/go-json/internal/encoder/vm_indent"
-)
-
-// An Encoder writes JSON values to an output stream.
-type Encoder struct {
- w io.Writer
- enabledIndent bool
- enabledHTMLEscape bool
- prefix string
- indentStr string
-}
-
-// NewEncoder returns a new encoder that writes to w.
-func NewEncoder(w io.Writer) *Encoder {
- return &Encoder{w: w, enabledHTMLEscape: true}
-}
-
-// Encode writes the JSON encoding of v to the stream, followed by a newline character.
-//
-// See the documentation for Marshal for details about the conversion of Go values to JSON.
-func (e *Encoder) Encode(v interface{}) error {
- return e.EncodeWithOption(v)
-}
-
-// EncodeWithOption call Encode with EncodeOption.
-func (e *Encoder) EncodeWithOption(v interface{}, optFuncs ...EncodeOptionFunc) error {
- ctx := encoder.TakeRuntimeContext()
- ctx.Option.Flag = 0
-
- err := e.encodeWithOption(ctx, v, optFuncs...)
-
- encoder.ReleaseRuntimeContext(ctx)
- return err
-}
-
-// EncodeContext call Encode with context.Context and EncodeOption.
-func (e *Encoder) EncodeContext(ctx context.Context, v interface{}, optFuncs ...EncodeOptionFunc) error {
- rctx := encoder.TakeRuntimeContext()
- rctx.Option.Flag = 0
- rctx.Option.Flag |= encoder.ContextOption
- rctx.Option.Context = ctx
-
- err := e.encodeWithOption(rctx, v, optFuncs...) //nolint: contextcheck
-
- encoder.ReleaseRuntimeContext(rctx)
- return err
-}
-
-func (e *Encoder) encodeWithOption(ctx *encoder.RuntimeContext, v interface{}, optFuncs ...EncodeOptionFunc) error {
- if e.enabledHTMLEscape {
- ctx.Option.Flag |= encoder.HTMLEscapeOption
- }
- ctx.Option.Flag |= encoder.NormalizeUTF8Option
- ctx.Option.DebugOut = os.Stdout
- for _, optFunc := range optFuncs {
- optFunc(ctx.Option)
- }
- var (
- buf []byte
- err error
- )
- if e.enabledIndent {
- buf, err = encodeIndent(ctx, v, e.prefix, e.indentStr)
- } else {
- buf, err = encode(ctx, v)
- }
- if err != nil {
- return err
- }
- if e.enabledIndent {
- buf = buf[:len(buf)-2]
- } else {
- buf = buf[:len(buf)-1]
- }
- buf = append(buf, '\n')
- if _, err := e.w.Write(buf); err != nil {
- return err
- }
- return nil
-}
-
-// SetEscapeHTML specifies whether problematic HTML characters should be escaped inside JSON quoted strings.
-// The default behavior is to escape &, <, and > to \u0026, \u003c, and \u003e to avoid certain safety problems that can arise when embedding JSON in HTML.
-//
-// In non-HTML settings where the escaping interferes with the readability of the output, SetEscapeHTML(false) disables this behavior.
-func (e *Encoder) SetEscapeHTML(on bool) {
- e.enabledHTMLEscape = on
-}
-
-// SetIndent instructs the encoder to format each subsequent encoded value as if indented by the package-level function Indent(dst, src, prefix, indent).
-// Calling SetIndent("", "") disables indentation.
-func (e *Encoder) SetIndent(prefix, indent string) {
- if prefix == "" && indent == "" {
- e.enabledIndent = false
- return
- }
- e.prefix = prefix
- e.indentStr = indent
- e.enabledIndent = true
-}
-
-func marshalContext(ctx context.Context, v interface{}, optFuncs ...EncodeOptionFunc) ([]byte, error) {
- rctx := encoder.TakeRuntimeContext()
- rctx.Option.Flag = 0
- rctx.Option.Flag = encoder.HTMLEscapeOption | encoder.NormalizeUTF8Option | encoder.ContextOption
- rctx.Option.Context = ctx
- for _, optFunc := range optFuncs {
- optFunc(rctx.Option)
- }
-
- buf, err := encode(rctx, v) //nolint: contextcheck
- if err != nil {
- encoder.ReleaseRuntimeContext(rctx)
- return nil, err
- }
-
- // this line exists to escape call of `runtime.makeslicecopy` .
- // if use `make([]byte, len(buf)-1)` and `copy(copied, buf)`,
- // dst buffer size and src buffer size are differrent.
- // in this case, compiler uses `runtime.makeslicecopy`, but it is slow.
- buf = buf[:len(buf)-1]
- copied := make([]byte, len(buf))
- copy(copied, buf)
-
- encoder.ReleaseRuntimeContext(rctx)
- return copied, nil
-}
-
-func marshal(v interface{}, optFuncs ...EncodeOptionFunc) ([]byte, error) {
- ctx := encoder.TakeRuntimeContext()
-
- ctx.Option.Flag = 0
- ctx.Option.Flag |= (encoder.HTMLEscapeOption | encoder.NormalizeUTF8Option)
- for _, optFunc := range optFuncs {
- optFunc(ctx.Option)
- }
-
- buf, err := encode(ctx, v)
- if err != nil {
- encoder.ReleaseRuntimeContext(ctx)
- return nil, err
- }
-
- // this line exists to escape call of `runtime.makeslicecopy` .
- // if use `make([]byte, len(buf)-1)` and `copy(copied, buf)`,
- // dst buffer size and src buffer size are differrent.
- // in this case, compiler uses `runtime.makeslicecopy`, but it is slow.
- buf = buf[:len(buf)-1]
- copied := make([]byte, len(buf))
- copy(copied, buf)
-
- encoder.ReleaseRuntimeContext(ctx)
- return copied, nil
-}
-
-func marshalNoEscape(v interface{}) ([]byte, error) {
- ctx := encoder.TakeRuntimeContext()
-
- ctx.Option.Flag = 0
- ctx.Option.Flag |= (encoder.HTMLEscapeOption | encoder.NormalizeUTF8Option)
-
- buf, err := encodeNoEscape(ctx, v)
- if err != nil {
- encoder.ReleaseRuntimeContext(ctx)
- return nil, err
- }
-
- // this line exists to escape call of `runtime.makeslicecopy` .
- // if use `make([]byte, len(buf)-1)` and `copy(copied, buf)`,
- // dst buffer size and src buffer size are differrent.
- // in this case, compiler uses `runtime.makeslicecopy`, but it is slow.
- buf = buf[:len(buf)-1]
- copied := make([]byte, len(buf))
- copy(copied, buf)
-
- encoder.ReleaseRuntimeContext(ctx)
- return copied, nil
-}
-
-func marshalIndent(v interface{}, prefix, indent string, optFuncs ...EncodeOptionFunc) ([]byte, error) {
- ctx := encoder.TakeRuntimeContext()
-
- ctx.Option.Flag = 0
- ctx.Option.Flag |= (encoder.HTMLEscapeOption | encoder.NormalizeUTF8Option | encoder.IndentOption)
- for _, optFunc := range optFuncs {
- optFunc(ctx.Option)
- }
-
- buf, err := encodeIndent(ctx, v, prefix, indent)
- if err != nil {
- encoder.ReleaseRuntimeContext(ctx)
- return nil, err
- }
-
- buf = buf[:len(buf)-2]
- copied := make([]byte, len(buf))
- copy(copied, buf)
-
- encoder.ReleaseRuntimeContext(ctx)
- return copied, nil
-}
-
-func encode(ctx *encoder.RuntimeContext, v interface{}) ([]byte, error) {
- b := ctx.Buf[:0]
- if v == nil {
- b = encoder.AppendNull(ctx, b)
- b = encoder.AppendComma(ctx, b)
- return b, nil
- }
- header := (*emptyInterface)(unsafe.Pointer(&v))
- typ := header.typ
-
- typeptr := uintptr(unsafe.Pointer(typ))
- codeSet, err := encoder.CompileToGetCodeSet(ctx, typeptr)
- if err != nil {
- return nil, err
- }
-
- p := uintptr(header.ptr)
- ctx.Init(p, codeSet.CodeLength)
- ctx.KeepRefs = append(ctx.KeepRefs, header.ptr)
-
- buf, err := encodeRunCode(ctx, b, codeSet)
- if err != nil {
- return nil, err
- }
- ctx.Buf = buf
- return buf, nil
-}
-
-func encodeNoEscape(ctx *encoder.RuntimeContext, v interface{}) ([]byte, error) {
- b := ctx.Buf[:0]
- if v == nil {
- b = encoder.AppendNull(ctx, b)
- b = encoder.AppendComma(ctx, b)
- return b, nil
- }
- header := (*emptyInterface)(unsafe.Pointer(&v))
- typ := header.typ
-
- typeptr := uintptr(unsafe.Pointer(typ))
- codeSet, err := encoder.CompileToGetCodeSet(ctx, typeptr)
- if err != nil {
- return nil, err
- }
-
- p := uintptr(header.ptr)
- ctx.Init(p, codeSet.CodeLength)
- buf, err := encodeRunCode(ctx, b, codeSet)
- if err != nil {
- return nil, err
- }
-
- ctx.Buf = buf
- return buf, nil
-}
-
-func encodeIndent(ctx *encoder.RuntimeContext, v interface{}, prefix, indent string) ([]byte, error) {
- b := ctx.Buf[:0]
- if v == nil {
- b = encoder.AppendNull(ctx, b)
- b = encoder.AppendCommaIndent(ctx, b)
- return b, nil
- }
- header := (*emptyInterface)(unsafe.Pointer(&v))
- typ := header.typ
-
- typeptr := uintptr(unsafe.Pointer(typ))
- codeSet, err := encoder.CompileToGetCodeSet(ctx, typeptr)
- if err != nil {
- return nil, err
- }
-
- p := uintptr(header.ptr)
- ctx.Init(p, codeSet.CodeLength)
- buf, err := encodeRunIndentCode(ctx, b, codeSet, prefix, indent)
-
- ctx.KeepRefs = append(ctx.KeepRefs, header.ptr)
-
- if err != nil {
- return nil, err
- }
-
- ctx.Buf = buf
- return buf, nil
-}
-
-func encodeRunCode(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet) ([]byte, error) {
- if (ctx.Option.Flag & encoder.DebugOption) != 0 {
- if (ctx.Option.Flag & encoder.ColorizeOption) != 0 {
- return vm_color.DebugRun(ctx, b, codeSet)
- }
- return vm.DebugRun(ctx, b, codeSet)
- }
- if (ctx.Option.Flag & encoder.ColorizeOption) != 0 {
- return vm_color.Run(ctx, b, codeSet)
- }
- return vm.Run(ctx, b, codeSet)
-}
-
-func encodeRunIndentCode(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, prefix, indent string) ([]byte, error) {
- ctx.Prefix = []byte(prefix)
- ctx.IndentStr = []byte(indent)
- if (ctx.Option.Flag & encoder.DebugOption) != 0 {
- if (ctx.Option.Flag & encoder.ColorizeOption) != 0 {
- return vm_color_indent.DebugRun(ctx, b, codeSet)
- }
- return vm_indent.DebugRun(ctx, b, codeSet)
- }
- if (ctx.Option.Flag & encoder.ColorizeOption) != 0 {
- return vm_color_indent.Run(ctx, b, codeSet)
- }
- return vm_indent.Run(ctx, b, codeSet)
-}
diff --git a/vendor/github.com/goccy/go-json/error.go b/vendor/github.com/goccy/go-json/error.go
deleted file mode 100644
index 5b2dcee5..00000000
--- a/vendor/github.com/goccy/go-json/error.go
+++ /dev/null
@@ -1,41 +0,0 @@
-package json
-
-import (
- "github.com/goccy/go-json/internal/errors"
-)
-
-// Before Go 1.2, an InvalidUTF8Error was returned by Marshal when
-// attempting to encode a string value with invalid UTF-8 sequences.
-// As of Go 1.2, Marshal instead coerces the string to valid UTF-8 by
-// replacing invalid bytes with the Unicode replacement rune U+FFFD.
-//
-// Deprecated: No longer used; kept for compatibility.
-type InvalidUTF8Error = errors.InvalidUTF8Error
-
-// An InvalidUnmarshalError describes an invalid argument passed to Unmarshal.
-// (The argument to Unmarshal must be a non-nil pointer.)
-type InvalidUnmarshalError = errors.InvalidUnmarshalError
-
-// A MarshalerError represents an error from calling a MarshalJSON or MarshalText method.
-type MarshalerError = errors.MarshalerError
-
-// A SyntaxError is a description of a JSON syntax error.
-type SyntaxError = errors.SyntaxError
-
-// An UnmarshalFieldError describes a JSON object key that
-// led to an unexported (and therefore unwritable) struct field.
-//
-// Deprecated: No longer used; kept for compatibility.
-type UnmarshalFieldError = errors.UnmarshalFieldError
-
-// An UnmarshalTypeError describes a JSON value that was
-// not appropriate for a value of a specific Go type.
-type UnmarshalTypeError = errors.UnmarshalTypeError
-
-// An UnsupportedTypeError is returned by Marshal when attempting
-// to encode an unsupported value type.
-type UnsupportedTypeError = errors.UnsupportedTypeError
-
-type UnsupportedValueError = errors.UnsupportedValueError
-
-type PathError = errors.PathError
diff --git a/vendor/github.com/goccy/go-json/internal/decoder/anonymous_field.go b/vendor/github.com/goccy/go-json/internal/decoder/anonymous_field.go
deleted file mode 100644
index b6876cf0..00000000
--- a/vendor/github.com/goccy/go-json/internal/decoder/anonymous_field.go
+++ /dev/null
@@ -1,41 +0,0 @@
-package decoder
-
-import (
- "unsafe"
-
- "github.com/goccy/go-json/internal/runtime"
-)
-
-type anonymousFieldDecoder struct {
- structType *runtime.Type
- offset uintptr
- dec Decoder
-}
-
-func newAnonymousFieldDecoder(structType *runtime.Type, offset uintptr, dec Decoder) *anonymousFieldDecoder {
- return &anonymousFieldDecoder{
- structType: structType,
- offset: offset,
- dec: dec,
- }
-}
-
-func (d *anonymousFieldDecoder) DecodeStream(s *Stream, depth int64, p unsafe.Pointer) error {
- if *(*unsafe.Pointer)(p) == nil {
- *(*unsafe.Pointer)(p) = unsafe_New(d.structType)
- }
- p = *(*unsafe.Pointer)(p)
- return d.dec.DecodeStream(s, depth, unsafe.Pointer(uintptr(p)+d.offset))
-}
-
-func (d *anonymousFieldDecoder) Decode(ctx *RuntimeContext, cursor, depth int64, p unsafe.Pointer) (int64, error) {
- if *(*unsafe.Pointer)(p) == nil {
- *(*unsafe.Pointer)(p) = unsafe_New(d.structType)
- }
- p = *(*unsafe.Pointer)(p)
- return d.dec.Decode(ctx, cursor, depth, unsafe.Pointer(uintptr(p)+d.offset))
-}
-
-func (d *anonymousFieldDecoder) DecodePath(ctx *RuntimeContext, cursor, depth int64) ([][]byte, int64, error) {
- return d.dec.DecodePath(ctx, cursor, depth)
-}
diff --git a/vendor/github.com/goccy/go-json/internal/decoder/array.go b/vendor/github.com/goccy/go-json/internal/decoder/array.go
deleted file mode 100644
index 4b23ed43..00000000
--- a/vendor/github.com/goccy/go-json/internal/decoder/array.go
+++ /dev/null
@@ -1,176 +0,0 @@
-package decoder
-
-import (
- "fmt"
- "unsafe"
-
- "github.com/goccy/go-json/internal/errors"
- "github.com/goccy/go-json/internal/runtime"
-)
-
-type arrayDecoder struct {
- elemType *runtime.Type
- size uintptr
- valueDecoder Decoder
- alen int
- structName string
- fieldName string
- zeroValue unsafe.Pointer
-}
-
-func newArrayDecoder(dec Decoder, elemType *runtime.Type, alen int, structName, fieldName string) *arrayDecoder {
- // workaround to avoid checkptr errors. cannot use `*(*unsafe.Pointer)(unsafe_New(elemType))` directly.
- zeroValuePtr := unsafe_New(elemType)
- zeroValue := **(**unsafe.Pointer)(unsafe.Pointer(&zeroValuePtr))
- return &arrayDecoder{
- valueDecoder: dec,
- elemType: elemType,
- size: elemType.Size(),
- alen: alen,
- structName: structName,
- fieldName: fieldName,
- zeroValue: zeroValue,
- }
-}
-
-func (d *arrayDecoder) DecodeStream(s *Stream, depth int64, p unsafe.Pointer) error {
- depth++
- if depth > maxDecodeNestingDepth {
- return errors.ErrExceededMaxDepth(s.char(), s.cursor)
- }
-
- for {
- switch s.char() {
- case ' ', '\n', '\t', '\r':
- case 'n':
- if err := nullBytes(s); err != nil {
- return err
- }
- return nil
- case '[':
- idx := 0
- s.cursor++
- if s.skipWhiteSpace() == ']' {
- for idx < d.alen {
- *(*unsafe.Pointer)(unsafe.Pointer(uintptr(p) + uintptr(idx)*d.size)) = d.zeroValue
- idx++
- }
- s.cursor++
- return nil
- }
- for {
- if idx < d.alen {
- if err := d.valueDecoder.DecodeStream(s, depth, unsafe.Pointer(uintptr(p)+uintptr(idx)*d.size)); err != nil {
- return err
- }
- } else {
- if err := s.skipValue(depth); err != nil {
- return err
- }
- }
- idx++
- switch s.skipWhiteSpace() {
- case ']':
- for idx < d.alen {
- *(*unsafe.Pointer)(unsafe.Pointer(uintptr(p) + uintptr(idx)*d.size)) = d.zeroValue
- idx++
- }
- s.cursor++
- return nil
- case ',':
- s.cursor++
- continue
- case nul:
- if s.read() {
- s.cursor++
- continue
- }
- goto ERROR
- default:
- goto ERROR
- }
- }
- case nul:
- if s.read() {
- continue
- }
- goto ERROR
- default:
- goto ERROR
- }
- s.cursor++
- }
-ERROR:
- return errors.ErrUnexpectedEndOfJSON("array", s.totalOffset())
-}
-
-func (d *arrayDecoder) Decode(ctx *RuntimeContext, cursor, depth int64, p unsafe.Pointer) (int64, error) {
- buf := ctx.Buf
- depth++
- if depth > maxDecodeNestingDepth {
- return 0, errors.ErrExceededMaxDepth(buf[cursor], cursor)
- }
-
- for {
- switch buf[cursor] {
- case ' ', '\n', '\t', '\r':
- cursor++
- continue
- case 'n':
- if err := validateNull(buf, cursor); err != nil {
- return 0, err
- }
- cursor += 4
- return cursor, nil
- case '[':
- idx := 0
- cursor++
- cursor = skipWhiteSpace(buf, cursor)
- if buf[cursor] == ']' {
- for idx < d.alen {
- *(*unsafe.Pointer)(unsafe.Pointer(uintptr(p) + uintptr(idx)*d.size)) = d.zeroValue
- idx++
- }
- cursor++
- return cursor, nil
- }
- for {
- if idx < d.alen {
- c, err := d.valueDecoder.Decode(ctx, cursor, depth, unsafe.Pointer(uintptr(p)+uintptr(idx)*d.size))
- if err != nil {
- return 0, err
- }
- cursor = c
- } else {
- c, err := skipValue(buf, cursor, depth)
- if err != nil {
- return 0, err
- }
- cursor = c
- }
- idx++
- cursor = skipWhiteSpace(buf, cursor)
- switch buf[cursor] {
- case ']':
- for idx < d.alen {
- *(*unsafe.Pointer)(unsafe.Pointer(uintptr(p) + uintptr(idx)*d.size)) = d.zeroValue
- idx++
- }
- cursor++
- return cursor, nil
- case ',':
- cursor++
- continue
- default:
- return 0, errors.ErrInvalidCharacter(buf[cursor], "array", cursor)
- }
- }
- default:
- return 0, errors.ErrUnexpectedEndOfJSON("array", cursor)
- }
- }
-}
-
-func (d *arrayDecoder) DecodePath(ctx *RuntimeContext, cursor, depth int64) ([][]byte, int64, error) {
- return nil, 0, fmt.Errorf("json: array decoder does not support decode path")
-}
diff --git a/vendor/github.com/goccy/go-json/internal/decoder/assign.go b/vendor/github.com/goccy/go-json/internal/decoder/assign.go
deleted file mode 100644
index c53e6ad9..00000000
--- a/vendor/github.com/goccy/go-json/internal/decoder/assign.go
+++ /dev/null
@@ -1,438 +0,0 @@
-package decoder
-
-import (
- "fmt"
- "reflect"
- "strconv"
-)
-
-var (
- nilValue = reflect.ValueOf(nil)
-)
-
-func AssignValue(src, dst reflect.Value) error {
- if dst.Type().Kind() != reflect.Ptr {
- return fmt.Errorf("invalid dst type. required pointer type: %T", dst.Type())
- }
- casted, err := castValue(dst.Elem().Type(), src)
- if err != nil {
- return err
- }
- dst.Elem().Set(casted)
- return nil
-}
-
-func castValue(t reflect.Type, v reflect.Value) (reflect.Value, error) {
- switch t.Kind() {
- case reflect.Int:
- vv, err := castInt(v)
- if err != nil {
- return nilValue, err
- }
- return reflect.ValueOf(int(vv.Int())), nil
- case reflect.Int8:
- vv, err := castInt(v)
- if err != nil {
- return nilValue, err
- }
- return reflect.ValueOf(int8(vv.Int())), nil
- case reflect.Int16:
- vv, err := castInt(v)
- if err != nil {
- return nilValue, err
- }
- return reflect.ValueOf(int16(vv.Int())), nil
- case reflect.Int32:
- vv, err := castInt(v)
- if err != nil {
- return nilValue, err
- }
- return reflect.ValueOf(int32(vv.Int())), nil
- case reflect.Int64:
- return castInt(v)
- case reflect.Uint:
- vv, err := castUint(v)
- if err != nil {
- return nilValue, err
- }
- return reflect.ValueOf(uint(vv.Uint())), nil
- case reflect.Uint8:
- vv, err := castUint(v)
- if err != nil {
- return nilValue, err
- }
- return reflect.ValueOf(uint8(vv.Uint())), nil
- case reflect.Uint16:
- vv, err := castUint(v)
- if err != nil {
- return nilValue, err
- }
- return reflect.ValueOf(uint16(vv.Uint())), nil
- case reflect.Uint32:
- vv, err := castUint(v)
- if err != nil {
- return nilValue, err
- }
- return reflect.ValueOf(uint32(vv.Uint())), nil
- case reflect.Uint64:
- return castUint(v)
- case reflect.Uintptr:
- vv, err := castUint(v)
- if err != nil {
- return nilValue, err
- }
- return reflect.ValueOf(uintptr(vv.Uint())), nil
- case reflect.String:
- return castString(v)
- case reflect.Bool:
- return castBool(v)
- case reflect.Float32:
- vv, err := castFloat(v)
- if err != nil {
- return nilValue, err
- }
- return reflect.ValueOf(float32(vv.Float())), nil
- case reflect.Float64:
- return castFloat(v)
- case reflect.Array:
- return castArray(t, v)
- case reflect.Slice:
- return castSlice(t, v)
- case reflect.Map:
- return castMap(t, v)
- case reflect.Struct:
- return castStruct(t, v)
- }
- return v, nil
-}
-
-func castInt(v reflect.Value) (reflect.Value, error) {
- switch v.Type().Kind() {
- case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
- return v, nil
- case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
- return reflect.ValueOf(int64(v.Uint())), nil
- case reflect.String:
- i64, err := strconv.ParseInt(v.String(), 10, 64)
- if err != nil {
- return nilValue, err
- }
- return reflect.ValueOf(i64), nil
- case reflect.Bool:
- if v.Bool() {
- return reflect.ValueOf(int64(1)), nil
- }
- return reflect.ValueOf(int64(0)), nil
- case reflect.Float32, reflect.Float64:
- return reflect.ValueOf(int64(v.Float())), nil
- case reflect.Array:
- if v.Len() > 0 {
- return castInt(v.Index(0))
- }
- return nilValue, fmt.Errorf("failed to cast to int64 from empty array")
- case reflect.Slice:
- if v.Len() > 0 {
- return castInt(v.Index(0))
- }
- return nilValue, fmt.Errorf("failed to cast to int64 from empty slice")
- case reflect.Interface:
- return castInt(reflect.ValueOf(v.Interface()))
- case reflect.Map:
- return nilValue, fmt.Errorf("failed to cast to int64 from map")
- case reflect.Struct:
- return nilValue, fmt.Errorf("failed to cast to int64 from struct")
- case reflect.Ptr:
- return castInt(v.Elem())
- }
- return nilValue, fmt.Errorf("failed to cast to int64 from %s", v.Type().Kind())
-}
-
-func castUint(v reflect.Value) (reflect.Value, error) {
- switch v.Type().Kind() {
- case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
- return reflect.ValueOf(uint64(v.Int())), nil
- case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
- return v, nil
- case reflect.String:
- u64, err := strconv.ParseUint(v.String(), 10, 64)
- if err != nil {
- return nilValue, err
- }
- return reflect.ValueOf(u64), nil
- case reflect.Bool:
- if v.Bool() {
- return reflect.ValueOf(uint64(1)), nil
- }
- return reflect.ValueOf(uint64(0)), nil
- case reflect.Float32, reflect.Float64:
- return reflect.ValueOf(uint64(v.Float())), nil
- case reflect.Array:
- if v.Len() > 0 {
- return castUint(v.Index(0))
- }
- return nilValue, fmt.Errorf("failed to cast to uint64 from empty array")
- case reflect.Slice:
- if v.Len() > 0 {
- return castUint(v.Index(0))
- }
- return nilValue, fmt.Errorf("failed to cast to uint64 from empty slice")
- case reflect.Interface:
- return castUint(reflect.ValueOf(v.Interface()))
- case reflect.Map:
- return nilValue, fmt.Errorf("failed to cast to uint64 from map")
- case reflect.Struct:
- return nilValue, fmt.Errorf("failed to cast to uint64 from struct")
- case reflect.Ptr:
- return castUint(v.Elem())
- }
- return nilValue, fmt.Errorf("failed to cast to uint64 from %s", v.Type().Kind())
-}
-
-func castString(v reflect.Value) (reflect.Value, error) {
- switch v.Type().Kind() {
- case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
- return reflect.ValueOf(fmt.Sprint(v.Int())), nil
- case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
- return reflect.ValueOf(fmt.Sprint(v.Uint())), nil
- case reflect.String:
- return v, nil
- case reflect.Bool:
- if v.Bool() {
- return reflect.ValueOf("true"), nil
- }
- return reflect.ValueOf("false"), nil
- case reflect.Float32, reflect.Float64:
- return reflect.ValueOf(fmt.Sprint(v.Float())), nil
- case reflect.Array:
- if v.Len() > 0 {
- return castString(v.Index(0))
- }
- return nilValue, fmt.Errorf("failed to cast to string from empty array")
- case reflect.Slice:
- if v.Len() > 0 {
- return castString(v.Index(0))
- }
- return nilValue, fmt.Errorf("failed to cast to string from empty slice")
- case reflect.Interface:
- return castString(reflect.ValueOf(v.Interface()))
- case reflect.Map:
- return nilValue, fmt.Errorf("failed to cast to string from map")
- case reflect.Struct:
- return nilValue, fmt.Errorf("failed to cast to string from struct")
- case reflect.Ptr:
- return castString(v.Elem())
- }
- return nilValue, fmt.Errorf("failed to cast to string from %s", v.Type().Kind())
-}
-
-func castBool(v reflect.Value) (reflect.Value, error) {
- switch v.Type().Kind() {
- case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
- switch v.Int() {
- case 0:
- return reflect.ValueOf(false), nil
- case 1:
- return reflect.ValueOf(true), nil
- }
- return nilValue, fmt.Errorf("failed to cast to bool from %d", v.Int())
- case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
- switch v.Uint() {
- case 0:
- return reflect.ValueOf(false), nil
- case 1:
- return reflect.ValueOf(true), nil
- }
- return nilValue, fmt.Errorf("failed to cast to bool from %d", v.Uint())
- case reflect.String:
- b, err := strconv.ParseBool(v.String())
- if err != nil {
- return nilValue, err
- }
- return reflect.ValueOf(b), nil
- case reflect.Bool:
- return v, nil
- case reflect.Float32, reflect.Float64:
- switch v.Float() {
- case 0:
- return reflect.ValueOf(false), nil
- case 1:
- return reflect.ValueOf(true), nil
- }
- return nilValue, fmt.Errorf("failed to cast to bool from %f", v.Float())
- case reflect.Array:
- if v.Len() > 0 {
- return castBool(v.Index(0))
- }
- return nilValue, fmt.Errorf("failed to cast to string from empty array")
- case reflect.Slice:
- if v.Len() > 0 {
- return castBool(v.Index(0))
- }
- return nilValue, fmt.Errorf("failed to cast to string from empty slice")
- case reflect.Interface:
- return castBool(reflect.ValueOf(v.Interface()))
- case reflect.Map:
- return nilValue, fmt.Errorf("failed to cast to string from map")
- case reflect.Struct:
- return nilValue, fmt.Errorf("failed to cast to string from struct")
- case reflect.Ptr:
- return castBool(v.Elem())
- }
- return nilValue, fmt.Errorf("failed to cast to bool from %s", v.Type().Kind())
-}
-
-func castFloat(v reflect.Value) (reflect.Value, error) {
- switch v.Type().Kind() {
- case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
- return reflect.ValueOf(float64(v.Int())), nil
- case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
- return reflect.ValueOf(float64(v.Uint())), nil
- case reflect.String:
- f64, err := strconv.ParseFloat(v.String(), 64)
- if err != nil {
- return nilValue, err
- }
- return reflect.ValueOf(f64), nil
- case reflect.Bool:
- if v.Bool() {
- return reflect.ValueOf(float64(1)), nil
- }
- return reflect.ValueOf(float64(0)), nil
- case reflect.Float32, reflect.Float64:
- return v, nil
- case reflect.Array:
- if v.Len() > 0 {
- return castFloat(v.Index(0))
- }
- return nilValue, fmt.Errorf("failed to cast to float64 from empty array")
- case reflect.Slice:
- if v.Len() > 0 {
- return castFloat(v.Index(0))
- }
- return nilValue, fmt.Errorf("failed to cast to float64 from empty slice")
- case reflect.Interface:
- return castFloat(reflect.ValueOf(v.Interface()))
- case reflect.Map:
- return nilValue, fmt.Errorf("failed to cast to float64 from map")
- case reflect.Struct:
- return nilValue, fmt.Errorf("failed to cast to float64 from struct")
- case reflect.Ptr:
- return castFloat(v.Elem())
- }
- return nilValue, fmt.Errorf("failed to cast to float64 from %s", v.Type().Kind())
-}
-
-func castArray(t reflect.Type, v reflect.Value) (reflect.Value, error) {
- kind := v.Type().Kind()
- if kind == reflect.Interface {
- return castArray(t, reflect.ValueOf(v.Interface()))
- }
- if kind != reflect.Slice && kind != reflect.Array {
- return nilValue, fmt.Errorf("failed to cast to array from %s", kind)
- }
- if t.Elem() == v.Type().Elem() {
- return v, nil
- }
- if t.Len() != v.Len() {
- return nilValue, fmt.Errorf("failed to cast [%d]array from slice of %d length", t.Len(), v.Len())
- }
- ret := reflect.New(t).Elem()
- for i := 0; i < v.Len(); i++ {
- vv, err := castValue(t.Elem(), v.Index(i))
- if err != nil {
- return nilValue, err
- }
- ret.Index(i).Set(vv)
- }
- return ret, nil
-}
-
-func castSlice(t reflect.Type, v reflect.Value) (reflect.Value, error) {
- kind := v.Type().Kind()
- if kind == reflect.Interface {
- return castSlice(t, reflect.ValueOf(v.Interface()))
- }
- if kind != reflect.Slice && kind != reflect.Array {
- return nilValue, fmt.Errorf("failed to cast to slice from %s", kind)
- }
- if t.Elem() == v.Type().Elem() {
- return v, nil
- }
- ret := reflect.MakeSlice(t, v.Len(), v.Len())
- for i := 0; i < v.Len(); i++ {
- vv, err := castValue(t.Elem(), v.Index(i))
- if err != nil {
- return nilValue, err
- }
- ret.Index(i).Set(vv)
- }
- return ret, nil
-}
-
-func castMap(t reflect.Type, v reflect.Value) (reflect.Value, error) {
- ret := reflect.MakeMap(t)
- switch v.Type().Kind() {
- case reflect.Map:
- iter := v.MapRange()
- for iter.Next() {
- key, err := castValue(t.Key(), iter.Key())
- if err != nil {
- return nilValue, err
- }
- value, err := castValue(t.Elem(), iter.Value())
- if err != nil {
- return nilValue, err
- }
- ret.SetMapIndex(key, value)
- }
- return ret, nil
- case reflect.Interface:
- return castMap(t, reflect.ValueOf(v.Interface()))
- case reflect.Slice:
- if v.Len() > 0 {
- return castMap(t, v.Index(0))
- }
- return nilValue, fmt.Errorf("failed to cast to map from empty slice")
- }
- return nilValue, fmt.Errorf("failed to cast to map from %s", v.Type().Kind())
-}
-
-func castStruct(t reflect.Type, v reflect.Value) (reflect.Value, error) {
- ret := reflect.New(t).Elem()
- switch v.Type().Kind() {
- case reflect.Map:
- iter := v.MapRange()
- for iter.Next() {
- key := iter.Key()
- k, err := castString(key)
- if err != nil {
- return nilValue, err
- }
- fieldName := k.String()
- field, ok := t.FieldByName(fieldName)
- if ok {
- value, err := castValue(field.Type, iter.Value())
- if err != nil {
- return nilValue, err
- }
- ret.FieldByName(fieldName).Set(value)
- }
- }
- return ret, nil
- case reflect.Struct:
- for i := 0; i < v.Type().NumField(); i++ {
- name := v.Type().Field(i).Name
- ret.FieldByName(name).Set(v.FieldByName(name))
- }
- return ret, nil
- case reflect.Interface:
- return castStruct(t, reflect.ValueOf(v.Interface()))
- case reflect.Slice:
- if v.Len() > 0 {
- return castStruct(t, v.Index(0))
- }
- return nilValue, fmt.Errorf("failed to cast to struct from empty slice")
- default:
- return nilValue, fmt.Errorf("failed to cast to struct from %s", v.Type().Kind())
- }
-}
diff --git a/vendor/github.com/goccy/go-json/internal/decoder/bool.go b/vendor/github.com/goccy/go-json/internal/decoder/bool.go
deleted file mode 100644
index ba6cf5bc..00000000
--- a/vendor/github.com/goccy/go-json/internal/decoder/bool.go
+++ /dev/null
@@ -1,83 +0,0 @@
-package decoder
-
-import (
- "fmt"
- "unsafe"
-
- "github.com/goccy/go-json/internal/errors"
-)
-
-type boolDecoder struct {
- structName string
- fieldName string
-}
-
-func newBoolDecoder(structName, fieldName string) *boolDecoder {
- return &boolDecoder{structName: structName, fieldName: fieldName}
-}
-
-func (d *boolDecoder) DecodeStream(s *Stream, depth int64, p unsafe.Pointer) error {
- c := s.skipWhiteSpace()
- for {
- switch c {
- case 't':
- if err := trueBytes(s); err != nil {
- return err
- }
- **(**bool)(unsafe.Pointer(&p)) = true
- return nil
- case 'f':
- if err := falseBytes(s); err != nil {
- return err
- }
- **(**bool)(unsafe.Pointer(&p)) = false
- return nil
- case 'n':
- if err := nullBytes(s); err != nil {
- return err
- }
- return nil
- case nul:
- if s.read() {
- c = s.char()
- continue
- }
- goto ERROR
- }
- break
- }
-ERROR:
- return errors.ErrUnexpectedEndOfJSON("bool", s.totalOffset())
-}
-
-func (d *boolDecoder) Decode(ctx *RuntimeContext, cursor, depth int64, p unsafe.Pointer) (int64, error) {
- buf := ctx.Buf
- cursor = skipWhiteSpace(buf, cursor)
- switch buf[cursor] {
- case 't':
- if err := validateTrue(buf, cursor); err != nil {
- return 0, err
- }
- cursor += 4
- **(**bool)(unsafe.Pointer(&p)) = true
- return cursor, nil
- case 'f':
- if err := validateFalse(buf, cursor); err != nil {
- return 0, err
- }
- cursor += 5
- **(**bool)(unsafe.Pointer(&p)) = false
- return cursor, nil
- case 'n':
- if err := validateNull(buf, cursor); err != nil {
- return 0, err
- }
- cursor += 4
- return cursor, nil
- }
- return 0, errors.ErrUnexpectedEndOfJSON("bool", cursor)
-}
-
-func (d *boolDecoder) DecodePath(ctx *RuntimeContext, cursor, depth int64) ([][]byte, int64, error) {
- return nil, 0, fmt.Errorf("json: bool decoder does not support decode path")
-}
diff --git a/vendor/github.com/goccy/go-json/internal/decoder/bytes.go b/vendor/github.com/goccy/go-json/internal/decoder/bytes.go
deleted file mode 100644
index 939bf432..00000000
--- a/vendor/github.com/goccy/go-json/internal/decoder/bytes.go
+++ /dev/null
@@ -1,118 +0,0 @@
-package decoder
-
-import (
- "encoding/base64"
- "fmt"
- "unsafe"
-
- "github.com/goccy/go-json/internal/errors"
- "github.com/goccy/go-json/internal/runtime"
-)
-
-type bytesDecoder struct {
- typ *runtime.Type
- sliceDecoder Decoder
- stringDecoder *stringDecoder
- structName string
- fieldName string
-}
-
-func byteUnmarshalerSliceDecoder(typ *runtime.Type, structName string, fieldName string) Decoder {
- var unmarshalDecoder Decoder
- switch {
- case runtime.PtrTo(typ).Implements(unmarshalJSONType):
- unmarshalDecoder = newUnmarshalJSONDecoder(runtime.PtrTo(typ), structName, fieldName)
- case runtime.PtrTo(typ).Implements(unmarshalTextType):
- unmarshalDecoder = newUnmarshalTextDecoder(runtime.PtrTo(typ), structName, fieldName)
- default:
- unmarshalDecoder, _ = compileUint8(typ, structName, fieldName)
- }
- return newSliceDecoder(unmarshalDecoder, typ, 1, structName, fieldName)
-}
-
-func newBytesDecoder(typ *runtime.Type, structName string, fieldName string) *bytesDecoder {
- return &bytesDecoder{
- typ: typ,
- sliceDecoder: byteUnmarshalerSliceDecoder(typ, structName, fieldName),
- stringDecoder: newStringDecoder(structName, fieldName),
- structName: structName,
- fieldName: fieldName,
- }
-}
-
-func (d *bytesDecoder) DecodeStream(s *Stream, depth int64, p unsafe.Pointer) error {
- bytes, err := d.decodeStreamBinary(s, depth, p)
- if err != nil {
- return err
- }
- if bytes == nil {
- s.reset()
- return nil
- }
- decodedLen := base64.StdEncoding.DecodedLen(len(bytes))
- buf := make([]byte, decodedLen)
- n, err := base64.StdEncoding.Decode(buf, bytes)
- if err != nil {
- return err
- }
- *(*[]byte)(p) = buf[:n]
- s.reset()
- return nil
-}
-
-func (d *bytesDecoder) Decode(ctx *RuntimeContext, cursor, depth int64, p unsafe.Pointer) (int64, error) {
- bytes, c, err := d.decodeBinary(ctx, cursor, depth, p)
- if err != nil {
- return 0, err
- }
- if bytes == nil {
- return c, nil
- }
- cursor = c
- decodedLen := base64.StdEncoding.DecodedLen(len(bytes))
- b := make([]byte, decodedLen)
- n, err := base64.StdEncoding.Decode(b, bytes)
- if err != nil {
- return 0, err
- }
- *(*[]byte)(p) = b[:n]
- return cursor, nil
-}
-
-func (d *bytesDecoder) DecodePath(ctx *RuntimeContext, cursor, depth int64) ([][]byte, int64, error) {
- return nil, 0, fmt.Errorf("json: []byte decoder does not support decode path")
-}
-
-func (d *bytesDecoder) decodeStreamBinary(s *Stream, depth int64, p unsafe.Pointer) ([]byte, error) {
- c := s.skipWhiteSpace()
- if c == '[' {
- if d.sliceDecoder == nil {
- return nil, &errors.UnmarshalTypeError{
- Type: runtime.RType2Type(d.typ),
- Offset: s.totalOffset(),
- }
- }
- err := d.sliceDecoder.DecodeStream(s, depth, p)
- return nil, err
- }
- return d.stringDecoder.decodeStreamByte(s)
-}
-
-func (d *bytesDecoder) decodeBinary(ctx *RuntimeContext, cursor, depth int64, p unsafe.Pointer) ([]byte, int64, error) {
- buf := ctx.Buf
- cursor = skipWhiteSpace(buf, cursor)
- if buf[cursor] == '[' {
- if d.sliceDecoder == nil {
- return nil, 0, &errors.UnmarshalTypeError{
- Type: runtime.RType2Type(d.typ),
- Offset: cursor,
- }
- }
- c, err := d.sliceDecoder.Decode(ctx, cursor, depth, p)
- if err != nil {
- return nil, 0, err
- }
- return nil, c, nil
- }
- return d.stringDecoder.decodeByte(buf, cursor)
-}
diff --git a/vendor/github.com/goccy/go-json/internal/decoder/compile.go b/vendor/github.com/goccy/go-json/internal/decoder/compile.go
deleted file mode 100644
index 8ad50936..00000000
--- a/vendor/github.com/goccy/go-json/internal/decoder/compile.go
+++ /dev/null
@@ -1,493 +0,0 @@
-package decoder
-
-import (
- "encoding/json"
- "fmt"
- "reflect"
- "strings"
- "sync"
- "sync/atomic"
- "unicode"
- "unsafe"
-
- "github.com/goccy/go-json/internal/runtime"
-)
-
-var (
- jsonNumberType = reflect.TypeOf(json.Number(""))
- typeAddr *runtime.TypeAddr
- cachedDecoderMap unsafe.Pointer // map[uintptr]decoder
- cachedDecoder []Decoder
- initOnce sync.Once
-)
-
-func initDecoder() {
- initOnce.Do(func() {
- typeAddr = runtime.AnalyzeTypeAddr()
- if typeAddr == nil {
- typeAddr = &runtime.TypeAddr{}
- }
- cachedDecoder = make([]Decoder, typeAddr.AddrRange>>typeAddr.AddrShift+1)
- })
-}
-
-func loadDecoderMap() map[uintptr]Decoder {
- initDecoder()
- p := atomic.LoadPointer(&cachedDecoderMap)
- return *(*map[uintptr]Decoder)(unsafe.Pointer(&p))
-}
-
-func storeDecoder(typ uintptr, dec Decoder, m map[uintptr]Decoder) {
- initDecoder()
- newDecoderMap := make(map[uintptr]Decoder, len(m)+1)
- newDecoderMap[typ] = dec
-
- for k, v := range m {
- newDecoderMap[k] = v
- }
-
- atomic.StorePointer(&cachedDecoderMap, *(*unsafe.Pointer)(unsafe.Pointer(&newDecoderMap)))
-}
-
-func compileToGetDecoderSlowPath(typeptr uintptr, typ *runtime.Type) (Decoder, error) {
- decoderMap := loadDecoderMap()
- if dec, exists := decoderMap[typeptr]; exists {
- return dec, nil
- }
-
- dec, err := compileHead(typ, map[uintptr]Decoder{})
- if err != nil {
- return nil, err
- }
- storeDecoder(typeptr, dec, decoderMap)
- return dec, nil
-}
-
-func compileHead(typ *runtime.Type, structTypeToDecoder map[uintptr]Decoder) (Decoder, error) {
- switch {
- case implementsUnmarshalJSONType(runtime.PtrTo(typ)):
- return newUnmarshalJSONDecoder(runtime.PtrTo(typ), "", ""), nil
- case runtime.PtrTo(typ).Implements(unmarshalTextType):
- return newUnmarshalTextDecoder(runtime.PtrTo(typ), "", ""), nil
- }
- return compile(typ.Elem(), "", "", structTypeToDecoder)
-}
-
-func compile(typ *runtime.Type, structName, fieldName string, structTypeToDecoder map[uintptr]Decoder) (Decoder, error) {
- switch {
- case implementsUnmarshalJSONType(runtime.PtrTo(typ)):
- return newUnmarshalJSONDecoder(runtime.PtrTo(typ), structName, fieldName), nil
- case runtime.PtrTo(typ).Implements(unmarshalTextType):
- return newUnmarshalTextDecoder(runtime.PtrTo(typ), structName, fieldName), nil
- }
-
- switch typ.Kind() {
- case reflect.Ptr:
- return compilePtr(typ, structName, fieldName, structTypeToDecoder)
- case reflect.Struct:
- return compileStruct(typ, structName, fieldName, structTypeToDecoder)
- case reflect.Slice:
- elem := typ.Elem()
- if elem.Kind() == reflect.Uint8 {
- return compileBytes(elem, structName, fieldName)
- }
- return compileSlice(typ, structName, fieldName, structTypeToDecoder)
- case reflect.Array:
- return compileArray(typ, structName, fieldName, structTypeToDecoder)
- case reflect.Map:
- return compileMap(typ, structName, fieldName, structTypeToDecoder)
- case reflect.Interface:
- return compileInterface(typ, structName, fieldName)
- case reflect.Uintptr:
- return compileUint(typ, structName, fieldName)
- case reflect.Int:
- return compileInt(typ, structName, fieldName)
- case reflect.Int8:
- return compileInt8(typ, structName, fieldName)
- case reflect.Int16:
- return compileInt16(typ, structName, fieldName)
- case reflect.Int32:
- return compileInt32(typ, structName, fieldName)
- case reflect.Int64:
- return compileInt64(typ, structName, fieldName)
- case reflect.Uint:
- return compileUint(typ, structName, fieldName)
- case reflect.Uint8:
- return compileUint8(typ, structName, fieldName)
- case reflect.Uint16:
- return compileUint16(typ, structName, fieldName)
- case reflect.Uint32:
- return compileUint32(typ, structName, fieldName)
- case reflect.Uint64:
- return compileUint64(typ, structName, fieldName)
- case reflect.String:
- return compileString(typ, structName, fieldName)
- case reflect.Bool:
- return compileBool(structName, fieldName)
- case reflect.Float32:
- return compileFloat32(structName, fieldName)
- case reflect.Float64:
- return compileFloat64(structName, fieldName)
- case reflect.Func:
- return compileFunc(typ, structName, fieldName)
- }
- return newInvalidDecoder(typ, structName, fieldName), nil
-}
-
-func isStringTagSupportedType(typ *runtime.Type) bool {
- switch {
- case implementsUnmarshalJSONType(runtime.PtrTo(typ)):
- return false
- case runtime.PtrTo(typ).Implements(unmarshalTextType):
- return false
- }
- switch typ.Kind() {
- case reflect.Map:
- return false
- case reflect.Slice:
- return false
- case reflect.Array:
- return false
- case reflect.Struct:
- return false
- case reflect.Interface:
- return false
- }
- return true
-}
-
-func compileMapKey(typ *runtime.Type, structName, fieldName string, structTypeToDecoder map[uintptr]Decoder) (Decoder, error) {
- if runtime.PtrTo(typ).Implements(unmarshalTextType) {
- return newUnmarshalTextDecoder(runtime.PtrTo(typ), structName, fieldName), nil
- }
- if typ.Kind() == reflect.String {
- return newStringDecoder(structName, fieldName), nil
- }
- dec, err := compile(typ, structName, fieldName, structTypeToDecoder)
- if err != nil {
- return nil, err
- }
- for {
- switch t := dec.(type) {
- case *stringDecoder, *interfaceDecoder:
- return dec, nil
- case *boolDecoder, *intDecoder, *uintDecoder, *numberDecoder:
- return newWrappedStringDecoder(typ, dec, structName, fieldName), nil
- case *ptrDecoder:
- dec = t.dec
- default:
- return newInvalidDecoder(typ, structName, fieldName), nil
- }
- }
-}
-
-func compilePtr(typ *runtime.Type, structName, fieldName string, structTypeToDecoder map[uintptr]Decoder) (Decoder, error) {
- dec, err := compile(typ.Elem(), structName, fieldName, structTypeToDecoder)
- if err != nil {
- return nil, err
- }
- return newPtrDecoder(dec, typ.Elem(), structName, fieldName), nil
-}
-
-func compileInt(typ *runtime.Type, structName, fieldName string) (Decoder, error) {
- return newIntDecoder(typ, structName, fieldName, func(p unsafe.Pointer, v int64) {
- *(*int)(p) = int(v)
- }), nil
-}
-
-func compileInt8(typ *runtime.Type, structName, fieldName string) (Decoder, error) {
- return newIntDecoder(typ, structName, fieldName, func(p unsafe.Pointer, v int64) {
- *(*int8)(p) = int8(v)
- }), nil
-}
-
-func compileInt16(typ *runtime.Type, structName, fieldName string) (Decoder, error) {
- return newIntDecoder(typ, structName, fieldName, func(p unsafe.Pointer, v int64) {
- *(*int16)(p) = int16(v)
- }), nil
-}
-
-func compileInt32(typ *runtime.Type, structName, fieldName string) (Decoder, error) {
- return newIntDecoder(typ, structName, fieldName, func(p unsafe.Pointer, v int64) {
- *(*int32)(p) = int32(v)
- }), nil
-}
-
-func compileInt64(typ *runtime.Type, structName, fieldName string) (Decoder, error) {
- return newIntDecoder(typ, structName, fieldName, func(p unsafe.Pointer, v int64) {
- *(*int64)(p) = v
- }), nil
-}
-
-func compileUint(typ *runtime.Type, structName, fieldName string) (Decoder, error) {
- return newUintDecoder(typ, structName, fieldName, func(p unsafe.Pointer, v uint64) {
- *(*uint)(p) = uint(v)
- }), nil
-}
-
-func compileUint8(typ *runtime.Type, structName, fieldName string) (Decoder, error) {
- return newUintDecoder(typ, structName, fieldName, func(p unsafe.Pointer, v uint64) {
- *(*uint8)(p) = uint8(v)
- }), nil
-}
-
-func compileUint16(typ *runtime.Type, structName, fieldName string) (Decoder, error) {
- return newUintDecoder(typ, structName, fieldName, func(p unsafe.Pointer, v uint64) {
- *(*uint16)(p) = uint16(v)
- }), nil
-}
-
-func compileUint32(typ *runtime.Type, structName, fieldName string) (Decoder, error) {
- return newUintDecoder(typ, structName, fieldName, func(p unsafe.Pointer, v uint64) {
- *(*uint32)(p) = uint32(v)
- }), nil
-}
-
-func compileUint64(typ *runtime.Type, structName, fieldName string) (Decoder, error) {
- return newUintDecoder(typ, structName, fieldName, func(p unsafe.Pointer, v uint64) {
- *(*uint64)(p) = v
- }), nil
-}
-
-func compileFloat32(structName, fieldName string) (Decoder, error) {
- return newFloatDecoder(structName, fieldName, func(p unsafe.Pointer, v float64) {
- *(*float32)(p) = float32(v)
- }), nil
-}
-
-func compileFloat64(structName, fieldName string) (Decoder, error) {
- return newFloatDecoder(structName, fieldName, func(p unsafe.Pointer, v float64) {
- *(*float64)(p) = v
- }), nil
-}
-
-func compileString(typ *runtime.Type, structName, fieldName string) (Decoder, error) {
- if typ == runtime.Type2RType(jsonNumberType) {
- return newNumberDecoder(structName, fieldName, func(p unsafe.Pointer, v json.Number) {
- *(*json.Number)(p) = v
- }), nil
- }
- return newStringDecoder(structName, fieldName), nil
-}
-
-func compileBool(structName, fieldName string) (Decoder, error) {
- return newBoolDecoder(structName, fieldName), nil
-}
-
-func compileBytes(typ *runtime.Type, structName, fieldName string) (Decoder, error) {
- return newBytesDecoder(typ, structName, fieldName), nil
-}
-
-func compileSlice(typ *runtime.Type, structName, fieldName string, structTypeToDecoder map[uintptr]Decoder) (Decoder, error) {
- elem := typ.Elem()
- decoder, err := compile(elem, structName, fieldName, structTypeToDecoder)
- if err != nil {
- return nil, err
- }
- return newSliceDecoder(decoder, elem, elem.Size(), structName, fieldName), nil
-}
-
-func compileArray(typ *runtime.Type, structName, fieldName string, structTypeToDecoder map[uintptr]Decoder) (Decoder, error) {
- elem := typ.Elem()
- decoder, err := compile(elem, structName, fieldName, structTypeToDecoder)
- if err != nil {
- return nil, err
- }
- return newArrayDecoder(decoder, elem, typ.Len(), structName, fieldName), nil
-}
-
-func compileMap(typ *runtime.Type, structName, fieldName string, structTypeToDecoder map[uintptr]Decoder) (Decoder, error) {
- keyDec, err := compileMapKey(typ.Key(), structName, fieldName, structTypeToDecoder)
- if err != nil {
- return nil, err
- }
- valueDec, err := compile(typ.Elem(), structName, fieldName, structTypeToDecoder)
- if err != nil {
- return nil, err
- }
- return newMapDecoder(typ, typ.Key(), keyDec, typ.Elem(), valueDec, structName, fieldName), nil
-}
-
-func compileInterface(typ *runtime.Type, structName, fieldName string) (Decoder, error) {
- return newInterfaceDecoder(typ, structName, fieldName), nil
-}
-
-func compileFunc(typ *runtime.Type, strutName, fieldName string) (Decoder, error) {
- return newFuncDecoder(typ, strutName, fieldName), nil
-}
-
-func typeToStructTags(typ *runtime.Type) runtime.StructTags {
- tags := runtime.StructTags{}
- fieldNum := typ.NumField()
- for i := 0; i < fieldNum; i++ {
- field := typ.Field(i)
- if runtime.IsIgnoredStructField(field) {
- continue
- }
- tags = append(tags, runtime.StructTagFromField(field))
- }
- return tags
-}
-
-func compileStruct(typ *runtime.Type, structName, fieldName string, structTypeToDecoder map[uintptr]Decoder) (Decoder, error) {
- fieldNum := typ.NumField()
- fieldMap := map[string]*structFieldSet{}
- typeptr := uintptr(unsafe.Pointer(typ))
- if dec, exists := structTypeToDecoder[typeptr]; exists {
- return dec, nil
- }
- structDec := newStructDecoder(structName, fieldName, fieldMap)
- structTypeToDecoder[typeptr] = structDec
- structName = typ.Name()
- tags := typeToStructTags(typ)
- allFields := []*structFieldSet{}
- for i := 0; i < fieldNum; i++ {
- field := typ.Field(i)
- if runtime.IsIgnoredStructField(field) {
- continue
- }
- isUnexportedField := unicode.IsLower([]rune(field.Name)[0])
- tag := runtime.StructTagFromField(field)
- dec, err := compile(runtime.Type2RType(field.Type), structName, field.Name, structTypeToDecoder)
- if err != nil {
- return nil, err
- }
- if field.Anonymous && !tag.IsTaggedKey {
- if stDec, ok := dec.(*structDecoder); ok {
- if runtime.Type2RType(field.Type) == typ {
- // recursive definition
- continue
- }
- for k, v := range stDec.fieldMap {
- if tags.ExistsKey(k) {
- continue
- }
- fieldSet := &structFieldSet{
- dec: v.dec,
- offset: field.Offset + v.offset,
- isTaggedKey: v.isTaggedKey,
- key: k,
- keyLen: int64(len(k)),
- }
- allFields = append(allFields, fieldSet)
- }
- } else if pdec, ok := dec.(*ptrDecoder); ok {
- contentDec := pdec.contentDecoder()
- if pdec.typ == typ {
- // recursive definition
- continue
- }
- var fieldSetErr error
- if isUnexportedField {
- fieldSetErr = fmt.Errorf(
- "json: cannot set embedded pointer to unexported struct: %v",
- field.Type.Elem(),
- )
- }
- if dec, ok := contentDec.(*structDecoder); ok {
- for k, v := range dec.fieldMap {
- if tags.ExistsKey(k) {
- continue
- }
- fieldSet := &structFieldSet{
- dec: newAnonymousFieldDecoder(pdec.typ, v.offset, v.dec),
- offset: field.Offset,
- isTaggedKey: v.isTaggedKey,
- key: k,
- keyLen: int64(len(k)),
- err: fieldSetErr,
- }
- allFields = append(allFields, fieldSet)
- }
- } else {
- fieldSet := &structFieldSet{
- dec: pdec,
- offset: field.Offset,
- isTaggedKey: tag.IsTaggedKey,
- key: field.Name,
- keyLen: int64(len(field.Name)),
- }
- allFields = append(allFields, fieldSet)
- }
- } else {
- fieldSet := &structFieldSet{
- dec: dec,
- offset: field.Offset,
- isTaggedKey: tag.IsTaggedKey,
- key: field.Name,
- keyLen: int64(len(field.Name)),
- }
- allFields = append(allFields, fieldSet)
- }
- } else {
- if tag.IsString && isStringTagSupportedType(runtime.Type2RType(field.Type)) {
- dec = newWrappedStringDecoder(runtime.Type2RType(field.Type), dec, structName, field.Name)
- }
- var key string
- if tag.Key != "" {
- key = tag.Key
- } else {
- key = field.Name
- }
- fieldSet := &structFieldSet{
- dec: dec,
- offset: field.Offset,
- isTaggedKey: tag.IsTaggedKey,
- key: key,
- keyLen: int64(len(key)),
- }
- allFields = append(allFields, fieldSet)
- }
- }
- for _, set := range filterDuplicatedFields(allFields) {
- fieldMap[set.key] = set
- lower := strings.ToLower(set.key)
- if _, exists := fieldMap[lower]; !exists {
- // first win
- fieldMap[lower] = set
- }
- }
- delete(structTypeToDecoder, typeptr)
- structDec.tryOptimize()
- return structDec, nil
-}
-
-func filterDuplicatedFields(allFields []*structFieldSet) []*structFieldSet {
- fieldMap := map[string][]*structFieldSet{}
- for _, field := range allFields {
- fieldMap[field.key] = append(fieldMap[field.key], field)
- }
- duplicatedFieldMap := map[string]struct{}{}
- for k, sets := range fieldMap {
- sets = filterFieldSets(sets)
- if len(sets) != 1 {
- duplicatedFieldMap[k] = struct{}{}
- }
- }
-
- filtered := make([]*structFieldSet, 0, len(allFields))
- for _, field := range allFields {
- if _, exists := duplicatedFieldMap[field.key]; exists {
- continue
- }
- filtered = append(filtered, field)
- }
- return filtered
-}
-
-func filterFieldSets(sets []*structFieldSet) []*structFieldSet {
- if len(sets) == 1 {
- return sets
- }
- filtered := make([]*structFieldSet, 0, len(sets))
- for _, set := range sets {
- if set.isTaggedKey {
- filtered = append(filtered, set)
- }
- }
- return filtered
-}
-
-func implementsUnmarshalJSONType(typ *runtime.Type) bool {
- return typ.Implements(unmarshalJSONType) || typ.Implements(unmarshalJSONContextType)
-}
diff --git a/vendor/github.com/goccy/go-json/internal/decoder/compile_norace.go b/vendor/github.com/goccy/go-json/internal/decoder/compile_norace.go
deleted file mode 100644
index 025ca85b..00000000
--- a/vendor/github.com/goccy/go-json/internal/decoder/compile_norace.go
+++ /dev/null
@@ -1,30 +0,0 @@
-//go:build !race
-// +build !race
-
-package decoder
-
-import (
- "unsafe"
-
- "github.com/goccy/go-json/internal/runtime"
-)
-
-func CompileToGetDecoder(typ *runtime.Type) (Decoder, error) {
- initDecoder()
- typeptr := uintptr(unsafe.Pointer(typ))
- if typeptr > typeAddr.MaxTypeAddr {
- return compileToGetDecoderSlowPath(typeptr, typ)
- }
-
- index := (typeptr - typeAddr.BaseTypeAddr) >> typeAddr.AddrShift
- if dec := cachedDecoder[index]; dec != nil {
- return dec, nil
- }
-
- dec, err := compileHead(typ, map[uintptr]Decoder{})
- if err != nil {
- return nil, err
- }
- cachedDecoder[index] = dec
- return dec, nil
-}
diff --git a/vendor/github.com/goccy/go-json/internal/decoder/compile_race.go b/vendor/github.com/goccy/go-json/internal/decoder/compile_race.go
deleted file mode 100644
index 023b817c..00000000
--- a/vendor/github.com/goccy/go-json/internal/decoder/compile_race.go
+++ /dev/null
@@ -1,38 +0,0 @@
-//go:build race
-// +build race
-
-package decoder
-
-import (
- "sync"
- "unsafe"
-
- "github.com/goccy/go-json/internal/runtime"
-)
-
-var decMu sync.RWMutex
-
-func CompileToGetDecoder(typ *runtime.Type) (Decoder, error) {
- initDecoder()
- typeptr := uintptr(unsafe.Pointer(typ))
- if typeptr > typeAddr.MaxTypeAddr {
- return compileToGetDecoderSlowPath(typeptr, typ)
- }
-
- index := (typeptr - typeAddr.BaseTypeAddr) >> typeAddr.AddrShift
- decMu.RLock()
- if dec := cachedDecoder[index]; dec != nil {
- decMu.RUnlock()
- return dec, nil
- }
- decMu.RUnlock()
-
- dec, err := compileHead(typ, map[uintptr]Decoder{})
- if err != nil {
- return nil, err
- }
- decMu.Lock()
- cachedDecoder[index] = dec
- decMu.Unlock()
- return dec, nil
-}
diff --git a/vendor/github.com/goccy/go-json/internal/decoder/context.go b/vendor/github.com/goccy/go-json/internal/decoder/context.go
deleted file mode 100644
index cb2ffdaf..00000000
--- a/vendor/github.com/goccy/go-json/internal/decoder/context.go
+++ /dev/null
@@ -1,254 +0,0 @@
-package decoder
-
-import (
- "sync"
- "unsafe"
-
- "github.com/goccy/go-json/internal/errors"
-)
-
-type RuntimeContext struct {
- Buf []byte
- Option *Option
-}
-
-var (
- runtimeContextPool = sync.Pool{
- New: func() interface{} {
- return &RuntimeContext{
- Option: &Option{},
- }
- },
- }
-)
-
-func TakeRuntimeContext() *RuntimeContext {
- return runtimeContextPool.Get().(*RuntimeContext)
-}
-
-func ReleaseRuntimeContext(ctx *RuntimeContext) {
- runtimeContextPool.Put(ctx)
-}
-
-var (
- isWhiteSpace = [256]bool{}
-)
-
-func init() {
- isWhiteSpace[' '] = true
- isWhiteSpace['\n'] = true
- isWhiteSpace['\t'] = true
- isWhiteSpace['\r'] = true
-}
-
-func char(ptr unsafe.Pointer, offset int64) byte {
- return *(*byte)(unsafe.Pointer(uintptr(ptr) + uintptr(offset)))
-}
-
-func skipWhiteSpace(buf []byte, cursor int64) int64 {
- for isWhiteSpace[buf[cursor]] {
- cursor++
- }
- return cursor
-}
-
-func skipObject(buf []byte, cursor, depth int64) (int64, error) {
- braceCount := 1
- for {
- switch buf[cursor] {
- case '{':
- braceCount++
- depth++
- if depth > maxDecodeNestingDepth {
- return 0, errors.ErrExceededMaxDepth(buf[cursor], cursor)
- }
- case '}':
- depth--
- braceCount--
- if braceCount == 0 {
- return cursor + 1, nil
- }
- case '[':
- depth++
- if depth > maxDecodeNestingDepth {
- return 0, errors.ErrExceededMaxDepth(buf[cursor], cursor)
- }
- case ']':
- depth--
- case '"':
- for {
- cursor++
- switch buf[cursor] {
- case '\\':
- cursor++
- if buf[cursor] == nul {
- return 0, errors.ErrUnexpectedEndOfJSON("string of object", cursor)
- }
- case '"':
- goto SWITCH_OUT
- case nul:
- return 0, errors.ErrUnexpectedEndOfJSON("string of object", cursor)
- }
- }
- case nul:
- return 0, errors.ErrUnexpectedEndOfJSON("object of object", cursor)
- }
- SWITCH_OUT:
- cursor++
- }
-}
-
-func skipArray(buf []byte, cursor, depth int64) (int64, error) {
- bracketCount := 1
- for {
- switch buf[cursor] {
- case '[':
- bracketCount++
- depth++
- if depth > maxDecodeNestingDepth {
- return 0, errors.ErrExceededMaxDepth(buf[cursor], cursor)
- }
- case ']':
- bracketCount--
- depth--
- if bracketCount == 0 {
- return cursor + 1, nil
- }
- case '{':
- depth++
- if depth > maxDecodeNestingDepth {
- return 0, errors.ErrExceededMaxDepth(buf[cursor], cursor)
- }
- case '}':
- depth--
- case '"':
- for {
- cursor++
- switch buf[cursor] {
- case '\\':
- cursor++
- if buf[cursor] == nul {
- return 0, errors.ErrUnexpectedEndOfJSON("string of object", cursor)
- }
- case '"':
- goto SWITCH_OUT
- case nul:
- return 0, errors.ErrUnexpectedEndOfJSON("string of object", cursor)
- }
- }
- case nul:
- return 0, errors.ErrUnexpectedEndOfJSON("array of object", cursor)
- }
- SWITCH_OUT:
- cursor++
- }
-}
-
-func skipValue(buf []byte, cursor, depth int64) (int64, error) {
- for {
- switch buf[cursor] {
- case ' ', '\t', '\n', '\r':
- cursor++
- continue
- case '{':
- return skipObject(buf, cursor+1, depth+1)
- case '[':
- return skipArray(buf, cursor+1, depth+1)
- case '"':
- for {
- cursor++
- switch buf[cursor] {
- case '\\':
- cursor++
- if buf[cursor] == nul {
- return 0, errors.ErrUnexpectedEndOfJSON("string of object", cursor)
- }
- case '"':
- return cursor + 1, nil
- case nul:
- return 0, errors.ErrUnexpectedEndOfJSON("string of object", cursor)
- }
- }
- case '-', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
- for {
- cursor++
- if floatTable[buf[cursor]] {
- continue
- }
- break
- }
- return cursor, nil
- case 't':
- if err := validateTrue(buf, cursor); err != nil {
- return 0, err
- }
- cursor += 4
- return cursor, nil
- case 'f':
- if err := validateFalse(buf, cursor); err != nil {
- return 0, err
- }
- cursor += 5
- return cursor, nil
- case 'n':
- if err := validateNull(buf, cursor); err != nil {
- return 0, err
- }
- cursor += 4
- return cursor, nil
- default:
- return cursor, errors.ErrUnexpectedEndOfJSON("null", cursor)
- }
- }
-}
-
-func validateTrue(buf []byte, cursor int64) error {
- if cursor+3 >= int64(len(buf)) {
- return errors.ErrUnexpectedEndOfJSON("true", cursor)
- }
- if buf[cursor+1] != 'r' {
- return errors.ErrInvalidCharacter(buf[cursor+1], "true", cursor)
- }
- if buf[cursor+2] != 'u' {
- return errors.ErrInvalidCharacter(buf[cursor+2], "true", cursor)
- }
- if buf[cursor+3] != 'e' {
- return errors.ErrInvalidCharacter(buf[cursor+3], "true", cursor)
- }
- return nil
-}
-
-func validateFalse(buf []byte, cursor int64) error {
- if cursor+4 >= int64(len(buf)) {
- return errors.ErrUnexpectedEndOfJSON("false", cursor)
- }
- if buf[cursor+1] != 'a' {
- return errors.ErrInvalidCharacter(buf[cursor+1], "false", cursor)
- }
- if buf[cursor+2] != 'l' {
- return errors.ErrInvalidCharacter(buf[cursor+2], "false", cursor)
- }
- if buf[cursor+3] != 's' {
- return errors.ErrInvalidCharacter(buf[cursor+3], "false", cursor)
- }
- if buf[cursor+4] != 'e' {
- return errors.ErrInvalidCharacter(buf[cursor+4], "false", cursor)
- }
- return nil
-}
-
-func validateNull(buf []byte, cursor int64) error {
- if cursor+3 >= int64(len(buf)) {
- return errors.ErrUnexpectedEndOfJSON("null", cursor)
- }
- if buf[cursor+1] != 'u' {
- return errors.ErrInvalidCharacter(buf[cursor+1], "null", cursor)
- }
- if buf[cursor+2] != 'l' {
- return errors.ErrInvalidCharacter(buf[cursor+2], "null", cursor)
- }
- if buf[cursor+3] != 'l' {
- return errors.ErrInvalidCharacter(buf[cursor+3], "null", cursor)
- }
- return nil
-}
diff --git a/vendor/github.com/goccy/go-json/internal/decoder/float.go b/vendor/github.com/goccy/go-json/internal/decoder/float.go
deleted file mode 100644
index 9b2eb8b3..00000000
--- a/vendor/github.com/goccy/go-json/internal/decoder/float.go
+++ /dev/null
@@ -1,170 +0,0 @@
-package decoder
-
-import (
- "strconv"
- "unsafe"
-
- "github.com/goccy/go-json/internal/errors"
-)
-
-type floatDecoder struct {
- op func(unsafe.Pointer, float64)
- structName string
- fieldName string
-}
-
-func newFloatDecoder(structName, fieldName string, op func(unsafe.Pointer, float64)) *floatDecoder {
- return &floatDecoder{op: op, structName: structName, fieldName: fieldName}
-}
-
-var (
- floatTable = [256]bool{
- '0': true,
- '1': true,
- '2': true,
- '3': true,
- '4': true,
- '5': true,
- '6': true,
- '7': true,
- '8': true,
- '9': true,
- '.': true,
- 'e': true,
- 'E': true,
- '+': true,
- '-': true,
- }
-
- validEndNumberChar = [256]bool{
- nul: true,
- ' ': true,
- '\t': true,
- '\r': true,
- '\n': true,
- ',': true,
- ':': true,
- '}': true,
- ']': true,
- }
-)
-
-func floatBytes(s *Stream) []byte {
- start := s.cursor
- for {
- s.cursor++
- if floatTable[s.char()] {
- continue
- } else if s.char() == nul {
- if s.read() {
- s.cursor-- // for retry current character
- continue
- }
- }
- break
- }
- return s.buf[start:s.cursor]
-}
-
-func (d *floatDecoder) decodeStreamByte(s *Stream) ([]byte, error) {
- for {
- switch s.char() {
- case ' ', '\n', '\t', '\r':
- s.cursor++
- continue
- case '-', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
- return floatBytes(s), nil
- case 'n':
- if err := nullBytes(s); err != nil {
- return nil, err
- }
- return nil, nil
- case nul:
- if s.read() {
- continue
- }
- goto ERROR
- default:
- goto ERROR
- }
- }
-ERROR:
- return nil, errors.ErrUnexpectedEndOfJSON("float", s.totalOffset())
-}
-
-func (d *floatDecoder) decodeByte(buf []byte, cursor int64) ([]byte, int64, error) {
- for {
- switch buf[cursor] {
- case ' ', '\n', '\t', '\r':
- cursor++
- continue
- case '-', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
- start := cursor
- cursor++
- for floatTable[buf[cursor]] {
- cursor++
- }
- num := buf[start:cursor]
- return num, cursor, nil
- case 'n':
- if err := validateNull(buf, cursor); err != nil {
- return nil, 0, err
- }
- cursor += 4
- return nil, cursor, nil
- default:
- return nil, 0, errors.ErrUnexpectedEndOfJSON("float", cursor)
- }
- }
-}
-
-func (d *floatDecoder) DecodeStream(s *Stream, depth int64, p unsafe.Pointer) error {
- bytes, err := d.decodeStreamByte(s)
- if err != nil {
- return err
- }
- if bytes == nil {
- return nil
- }
- str := *(*string)(unsafe.Pointer(&bytes))
- f64, err := strconv.ParseFloat(str, 64)
- if err != nil {
- return errors.ErrSyntax(err.Error(), s.totalOffset())
- }
- d.op(p, f64)
- return nil
-}
-
-func (d *floatDecoder) Decode(ctx *RuntimeContext, cursor, depth int64, p unsafe.Pointer) (int64, error) {
- buf := ctx.Buf
- bytes, c, err := d.decodeByte(buf, cursor)
- if err != nil {
- return 0, err
- }
- if bytes == nil {
- return c, nil
- }
- cursor = c
- if !validEndNumberChar[buf[cursor]] {
- return 0, errors.ErrUnexpectedEndOfJSON("float", cursor)
- }
- s := *(*string)(unsafe.Pointer(&bytes))
- f64, err := strconv.ParseFloat(s, 64)
- if err != nil {
- return 0, errors.ErrSyntax(err.Error(), cursor)
- }
- d.op(p, f64)
- return cursor, nil
-}
-
-func (d *floatDecoder) DecodePath(ctx *RuntimeContext, cursor, depth int64) ([][]byte, int64, error) {
- buf := ctx.Buf
- bytes, c, err := d.decodeByte(buf, cursor)
- if err != nil {
- return nil, 0, err
- }
- if bytes == nil {
- return [][]byte{nullbytes}, c, nil
- }
- return [][]byte{bytes}, c, nil
-}
diff --git a/vendor/github.com/goccy/go-json/internal/decoder/func.go b/vendor/github.com/goccy/go-json/internal/decoder/func.go
deleted file mode 100644
index 4cc12ca8..00000000
--- a/vendor/github.com/goccy/go-json/internal/decoder/func.go
+++ /dev/null
@@ -1,146 +0,0 @@
-package decoder
-
-import (
- "bytes"
- "fmt"
- "unsafe"
-
- "github.com/goccy/go-json/internal/errors"
- "github.com/goccy/go-json/internal/runtime"
-)
-
-type funcDecoder struct {
- typ *runtime.Type
- structName string
- fieldName string
-}
-
-func newFuncDecoder(typ *runtime.Type, structName, fieldName string) *funcDecoder {
- fnDecoder := &funcDecoder{typ, structName, fieldName}
- return fnDecoder
-}
-
-func (d *funcDecoder) DecodeStream(s *Stream, depth int64, p unsafe.Pointer) error {
- s.skipWhiteSpace()
- start := s.cursor
- if err := s.skipValue(depth); err != nil {
- return err
- }
- src := s.buf[start:s.cursor]
- if len(src) > 0 {
- switch src[0] {
- case '"':
- return &errors.UnmarshalTypeError{
- Value: "string",
- Type: runtime.RType2Type(d.typ),
- Offset: s.totalOffset(),
- }
- case '[':
- return &errors.UnmarshalTypeError{
- Value: "array",
- Type: runtime.RType2Type(d.typ),
- Offset: s.totalOffset(),
- }
- case '{':
- return &errors.UnmarshalTypeError{
- Value: "object",
- Type: runtime.RType2Type(d.typ),
- Offset: s.totalOffset(),
- }
- case '-', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
- return &errors.UnmarshalTypeError{
- Value: "number",
- Type: runtime.RType2Type(d.typ),
- Offset: s.totalOffset(),
- }
- case 'n':
- if err := nullBytes(s); err != nil {
- return err
- }
- *(*unsafe.Pointer)(p) = nil
- return nil
- case 't':
- if err := trueBytes(s); err == nil {
- return &errors.UnmarshalTypeError{
- Value: "boolean",
- Type: runtime.RType2Type(d.typ),
- Offset: s.totalOffset(),
- }
- }
- case 'f':
- if err := falseBytes(s); err == nil {
- return &errors.UnmarshalTypeError{
- Value: "boolean",
- Type: runtime.RType2Type(d.typ),
- Offset: s.totalOffset(),
- }
- }
- }
- }
- return errors.ErrInvalidBeginningOfValue(s.buf[s.cursor], s.totalOffset())
-}
-
-func (d *funcDecoder) Decode(ctx *RuntimeContext, cursor, depth int64, p unsafe.Pointer) (int64, error) {
- buf := ctx.Buf
- cursor = skipWhiteSpace(buf, cursor)
- start := cursor
- end, err := skipValue(buf, cursor, depth)
- if err != nil {
- return 0, err
- }
- src := buf[start:end]
- if len(src) > 0 {
- switch src[0] {
- case '"':
- return 0, &errors.UnmarshalTypeError{
- Value: "string",
- Type: runtime.RType2Type(d.typ),
- Offset: start,
- }
- case '[':
- return 0, &errors.UnmarshalTypeError{
- Value: "array",
- Type: runtime.RType2Type(d.typ),
- Offset: start,
- }
- case '{':
- return 0, &errors.UnmarshalTypeError{
- Value: "object",
- Type: runtime.RType2Type(d.typ),
- Offset: start,
- }
- case '-', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
- return 0, &errors.UnmarshalTypeError{
- Value: "number",
- Type: runtime.RType2Type(d.typ),
- Offset: start,
- }
- case 'n':
- if bytes.Equal(src, nullbytes) {
- *(*unsafe.Pointer)(p) = nil
- return end, nil
- }
- case 't':
- if err := validateTrue(buf, start); err == nil {
- return 0, &errors.UnmarshalTypeError{
- Value: "boolean",
- Type: runtime.RType2Type(d.typ),
- Offset: start,
- }
- }
- case 'f':
- if err := validateFalse(buf, start); err == nil {
- return 0, &errors.UnmarshalTypeError{
- Value: "boolean",
- Type: runtime.RType2Type(d.typ),
- Offset: start,
- }
- }
- }
- }
- return cursor, errors.ErrInvalidBeginningOfValue(buf[cursor], cursor)
-}
-
-func (d *funcDecoder) DecodePath(ctx *RuntimeContext, cursor, depth int64) ([][]byte, int64, error) {
- return nil, 0, fmt.Errorf("json: func decoder does not support decode path")
-}
diff --git a/vendor/github.com/goccy/go-json/internal/decoder/int.go b/vendor/github.com/goccy/go-json/internal/decoder/int.go
deleted file mode 100644
index 1a7f0819..00000000
--- a/vendor/github.com/goccy/go-json/internal/decoder/int.go
+++ /dev/null
@@ -1,246 +0,0 @@
-package decoder
-
-import (
- "fmt"
- "reflect"
- "unsafe"
-
- "github.com/goccy/go-json/internal/errors"
- "github.com/goccy/go-json/internal/runtime"
-)
-
-type intDecoder struct {
- typ *runtime.Type
- kind reflect.Kind
- op func(unsafe.Pointer, int64)
- structName string
- fieldName string
-}
-
-func newIntDecoder(typ *runtime.Type, structName, fieldName string, op func(unsafe.Pointer, int64)) *intDecoder {
- return &intDecoder{
- typ: typ,
- kind: typ.Kind(),
- op: op,
- structName: structName,
- fieldName: fieldName,
- }
-}
-
-func (d *intDecoder) typeError(buf []byte, offset int64) *errors.UnmarshalTypeError {
- return &errors.UnmarshalTypeError{
- Value: fmt.Sprintf("number %s", string(buf)),
- Type: runtime.RType2Type(d.typ),
- Struct: d.structName,
- Field: d.fieldName,
- Offset: offset,
- }
-}
-
-var (
- pow10i64 = [...]int64{
- 1e00, 1e01, 1e02, 1e03, 1e04, 1e05, 1e06, 1e07, 1e08, 1e09,
- 1e10, 1e11, 1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18,
- }
- pow10i64Len = len(pow10i64)
-)
-
-func (d *intDecoder) parseInt(b []byte) (int64, error) {
- isNegative := false
- if b[0] == '-' {
- b = b[1:]
- isNegative = true
- }
- maxDigit := len(b)
- if maxDigit > pow10i64Len {
- return 0, fmt.Errorf("invalid length of number")
- }
- sum := int64(0)
- for i := 0; i < maxDigit; i++ {
- c := int64(b[i]) - 48
- digitValue := pow10i64[maxDigit-i-1]
- sum += c * digitValue
- }
- if isNegative {
- return -1 * sum, nil
- }
- return sum, nil
-}
-
-var (
- numTable = [256]bool{
- '0': true,
- '1': true,
- '2': true,
- '3': true,
- '4': true,
- '5': true,
- '6': true,
- '7': true,
- '8': true,
- '9': true,
- }
-)
-
-var (
- numZeroBuf = []byte{'0'}
-)
-
-func (d *intDecoder) decodeStreamByte(s *Stream) ([]byte, error) {
- for {
- switch s.char() {
- case ' ', '\n', '\t', '\r':
- s.cursor++
- continue
- case '-':
- start := s.cursor
- for {
- s.cursor++
- if numTable[s.char()] {
- continue
- } else if s.char() == nul {
- if s.read() {
- s.cursor-- // for retry current character
- continue
- }
- }
- break
- }
- num := s.buf[start:s.cursor]
- if len(num) < 2 {
- goto ERROR
- }
- return num, nil
- case '0':
- s.cursor++
- return numZeroBuf, nil
- case '1', '2', '3', '4', '5', '6', '7', '8', '9':
- start := s.cursor
- for {
- s.cursor++
- if numTable[s.char()] {
- continue
- } else if s.char() == nul {
- if s.read() {
- s.cursor-- // for retry current character
- continue
- }
- }
- break
- }
- num := s.buf[start:s.cursor]
- return num, nil
- case 'n':
- if err := nullBytes(s); err != nil {
- return nil, err
- }
- return nil, nil
- case nul:
- if s.read() {
- continue
- }
- goto ERROR
- default:
- return nil, d.typeError([]byte{s.char()}, s.totalOffset())
- }
- }
-ERROR:
- return nil, errors.ErrUnexpectedEndOfJSON("number(integer)", s.totalOffset())
-}
-
-func (d *intDecoder) decodeByte(buf []byte, cursor int64) ([]byte, int64, error) {
- b := (*sliceHeader)(unsafe.Pointer(&buf)).data
- for {
- switch char(b, cursor) {
- case ' ', '\n', '\t', '\r':
- cursor++
- continue
- case '0':
- cursor++
- return numZeroBuf, cursor, nil
- case '-', '1', '2', '3', '4', '5', '6', '7', '8', '9':
- start := cursor
- cursor++
- for numTable[char(b, cursor)] {
- cursor++
- }
- num := buf[start:cursor]
- return num, cursor, nil
- case 'n':
- if err := validateNull(buf, cursor); err != nil {
- return nil, 0, err
- }
- cursor += 4
- return nil, cursor, nil
- default:
- return nil, 0, d.typeError([]byte{char(b, cursor)}, cursor)
- }
- }
-}
-
-func (d *intDecoder) DecodeStream(s *Stream, depth int64, p unsafe.Pointer) error {
- bytes, err := d.decodeStreamByte(s)
- if err != nil {
- return err
- }
- if bytes == nil {
- return nil
- }
- i64, err := d.parseInt(bytes)
- if err != nil {
- return d.typeError(bytes, s.totalOffset())
- }
- switch d.kind {
- case reflect.Int8:
- if i64 < -1*(1<<7) || (1<<7) <= i64 {
- return d.typeError(bytes, s.totalOffset())
- }
- case reflect.Int16:
- if i64 < -1*(1<<15) || (1<<15) <= i64 {
- return d.typeError(bytes, s.totalOffset())
- }
- case reflect.Int32:
- if i64 < -1*(1<<31) || (1<<31) <= i64 {
- return d.typeError(bytes, s.totalOffset())
- }
- }
- d.op(p, i64)
- s.reset()
- return nil
-}
-
-func (d *intDecoder) Decode(ctx *RuntimeContext, cursor, depth int64, p unsafe.Pointer) (int64, error) {
- bytes, c, err := d.decodeByte(ctx.Buf, cursor)
- if err != nil {
- return 0, err
- }
- if bytes == nil {
- return c, nil
- }
- cursor = c
-
- i64, err := d.parseInt(bytes)
- if err != nil {
- return 0, d.typeError(bytes, cursor)
- }
- switch d.kind {
- case reflect.Int8:
- if i64 < -1*(1<<7) || (1<<7) <= i64 {
- return 0, d.typeError(bytes, cursor)
- }
- case reflect.Int16:
- if i64 < -1*(1<<15) || (1<<15) <= i64 {
- return 0, d.typeError(bytes, cursor)
- }
- case reflect.Int32:
- if i64 < -1*(1<<31) || (1<<31) <= i64 {
- return 0, d.typeError(bytes, cursor)
- }
- }
- d.op(p, i64)
- return cursor, nil
-}
-
-func (d *intDecoder) DecodePath(ctx *RuntimeContext, cursor, depth int64) ([][]byte, int64, error) {
- return nil, 0, fmt.Errorf("json: int decoder does not support decode path")
-}
diff --git a/vendor/github.com/goccy/go-json/internal/decoder/interface.go b/vendor/github.com/goccy/go-json/internal/decoder/interface.go
deleted file mode 100644
index 45c69ab8..00000000
--- a/vendor/github.com/goccy/go-json/internal/decoder/interface.go
+++ /dev/null
@@ -1,528 +0,0 @@
-package decoder
-
-import (
- "bytes"
- "encoding"
- "encoding/json"
- "reflect"
- "unsafe"
-
- "github.com/goccy/go-json/internal/errors"
- "github.com/goccy/go-json/internal/runtime"
-)
-
-type interfaceDecoder struct {
- typ *runtime.Type
- structName string
- fieldName string
- sliceDecoder *sliceDecoder
- mapDecoder *mapDecoder
- floatDecoder *floatDecoder
- numberDecoder *numberDecoder
- stringDecoder *stringDecoder
-}
-
-func newEmptyInterfaceDecoder(structName, fieldName string) *interfaceDecoder {
- ifaceDecoder := &interfaceDecoder{
- typ: emptyInterfaceType,
- structName: structName,
- fieldName: fieldName,
- floatDecoder: newFloatDecoder(structName, fieldName, func(p unsafe.Pointer, v float64) {
- *(*interface{})(p) = v
- }),
- numberDecoder: newNumberDecoder(structName, fieldName, func(p unsafe.Pointer, v json.Number) {
- *(*interface{})(p) = v
- }),
- stringDecoder: newStringDecoder(structName, fieldName),
- }
- ifaceDecoder.sliceDecoder = newSliceDecoder(
- ifaceDecoder,
- emptyInterfaceType,
- emptyInterfaceType.Size(),
- structName, fieldName,
- )
- ifaceDecoder.mapDecoder = newMapDecoder(
- interfaceMapType,
- stringType,
- ifaceDecoder.stringDecoder,
- interfaceMapType.Elem(),
- ifaceDecoder,
- structName,
- fieldName,
- )
- return ifaceDecoder
-}
-
-func newInterfaceDecoder(typ *runtime.Type, structName, fieldName string) *interfaceDecoder {
- emptyIfaceDecoder := newEmptyInterfaceDecoder(structName, fieldName)
- stringDecoder := newStringDecoder(structName, fieldName)
- return &interfaceDecoder{
- typ: typ,
- structName: structName,
- fieldName: fieldName,
- sliceDecoder: newSliceDecoder(
- emptyIfaceDecoder,
- emptyInterfaceType,
- emptyInterfaceType.Size(),
- structName, fieldName,
- ),
- mapDecoder: newMapDecoder(
- interfaceMapType,
- stringType,
- stringDecoder,
- interfaceMapType.Elem(),
- emptyIfaceDecoder,
- structName,
- fieldName,
- ),
- floatDecoder: newFloatDecoder(structName, fieldName, func(p unsafe.Pointer, v float64) {
- *(*interface{})(p) = v
- }),
- numberDecoder: newNumberDecoder(structName, fieldName, func(p unsafe.Pointer, v json.Number) {
- *(*interface{})(p) = v
- }),
- stringDecoder: stringDecoder,
- }
-}
-
-func (d *interfaceDecoder) numDecoder(s *Stream) Decoder {
- if s.UseNumber {
- return d.numberDecoder
- }
- return d.floatDecoder
-}
-
-var (
- emptyInterfaceType = runtime.Type2RType(reflect.TypeOf((*interface{})(nil)).Elem())
- EmptyInterfaceType = emptyInterfaceType
- interfaceMapType = runtime.Type2RType(
- reflect.TypeOf((*map[string]interface{})(nil)).Elem(),
- )
- stringType = runtime.Type2RType(
- reflect.TypeOf(""),
- )
-)
-
-func decodeStreamUnmarshaler(s *Stream, depth int64, unmarshaler json.Unmarshaler) error {
- start := s.cursor
- if err := s.skipValue(depth); err != nil {
- return err
- }
- src := s.buf[start:s.cursor]
- dst := make([]byte, len(src))
- copy(dst, src)
-
- if err := unmarshaler.UnmarshalJSON(dst); err != nil {
- return err
- }
- return nil
-}
-
-func decodeStreamUnmarshalerContext(s *Stream, depth int64, unmarshaler unmarshalerContext) error {
- start := s.cursor
- if err := s.skipValue(depth); err != nil {
- return err
- }
- src := s.buf[start:s.cursor]
- dst := make([]byte, len(src))
- copy(dst, src)
-
- if err := unmarshaler.UnmarshalJSON(s.Option.Context, dst); err != nil {
- return err
- }
- return nil
-}
-
-func decodeUnmarshaler(buf []byte, cursor, depth int64, unmarshaler json.Unmarshaler) (int64, error) {
- cursor = skipWhiteSpace(buf, cursor)
- start := cursor
- end, err := skipValue(buf, cursor, depth)
- if err != nil {
- return 0, err
- }
- src := buf[start:end]
- dst := make([]byte, len(src))
- copy(dst, src)
-
- if err := unmarshaler.UnmarshalJSON(dst); err != nil {
- return 0, err
- }
- return end, nil
-}
-
-func decodeUnmarshalerContext(ctx *RuntimeContext, buf []byte, cursor, depth int64, unmarshaler unmarshalerContext) (int64, error) {
- cursor = skipWhiteSpace(buf, cursor)
- start := cursor
- end, err := skipValue(buf, cursor, depth)
- if err != nil {
- return 0, err
- }
- src := buf[start:end]
- dst := make([]byte, len(src))
- copy(dst, src)
-
- if err := unmarshaler.UnmarshalJSON(ctx.Option.Context, dst); err != nil {
- return 0, err
- }
- return end, nil
-}
-
-func decodeStreamTextUnmarshaler(s *Stream, depth int64, unmarshaler encoding.TextUnmarshaler, p unsafe.Pointer) error {
- start := s.cursor
- if err := s.skipValue(depth); err != nil {
- return err
- }
- src := s.buf[start:s.cursor]
- if bytes.Equal(src, nullbytes) {
- *(*unsafe.Pointer)(p) = nil
- return nil
- }
-
- dst := make([]byte, len(src))
- copy(dst, src)
-
- if err := unmarshaler.UnmarshalText(dst); err != nil {
- return err
- }
- return nil
-}
-
-func decodeTextUnmarshaler(buf []byte, cursor, depth int64, unmarshaler encoding.TextUnmarshaler, p unsafe.Pointer) (int64, error) {
- cursor = skipWhiteSpace(buf, cursor)
- start := cursor
- end, err := skipValue(buf, cursor, depth)
- if err != nil {
- return 0, err
- }
- src := buf[start:end]
- if bytes.Equal(src, nullbytes) {
- *(*unsafe.Pointer)(p) = nil
- return end, nil
- }
- if s, ok := unquoteBytes(src); ok {
- src = s
- }
- if err := unmarshaler.UnmarshalText(src); err != nil {
- return 0, err
- }
- return end, nil
-}
-
-func (d *interfaceDecoder) decodeStreamEmptyInterface(s *Stream, depth int64, p unsafe.Pointer) error {
- c := s.skipWhiteSpace()
- for {
- switch c {
- case '{':
- var v map[string]interface{}
- ptr := unsafe.Pointer(&v)
- if err := d.mapDecoder.DecodeStream(s, depth, ptr); err != nil {
- return err
- }
- *(*interface{})(p) = v
- return nil
- case '[':
- var v []interface{}
- ptr := unsafe.Pointer(&v)
- if err := d.sliceDecoder.DecodeStream(s, depth, ptr); err != nil {
- return err
- }
- *(*interface{})(p) = v
- return nil
- case '-', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
- return d.numDecoder(s).DecodeStream(s, depth, p)
- case '"':
- s.cursor++
- start := s.cursor
- for {
- switch s.char() {
- case '\\':
- if _, err := decodeEscapeString(s, nil); err != nil {
- return err
- }
- case '"':
- literal := s.buf[start:s.cursor]
- s.cursor++
- *(*interface{})(p) = string(literal)
- return nil
- case nul:
- if s.read() {
- continue
- }
- return errors.ErrUnexpectedEndOfJSON("string", s.totalOffset())
- }
- s.cursor++
- }
- case 't':
- if err := trueBytes(s); err != nil {
- return err
- }
- **(**interface{})(unsafe.Pointer(&p)) = true
- return nil
- case 'f':
- if err := falseBytes(s); err != nil {
- return err
- }
- **(**interface{})(unsafe.Pointer(&p)) = false
- return nil
- case 'n':
- if err := nullBytes(s); err != nil {
- return err
- }
- *(*interface{})(p) = nil
- return nil
- case nul:
- if s.read() {
- c = s.char()
- continue
- }
- }
- break
- }
- return errors.ErrInvalidBeginningOfValue(c, s.totalOffset())
-}
-
-type emptyInterface struct {
- typ *runtime.Type
- ptr unsafe.Pointer
-}
-
-func (d *interfaceDecoder) DecodeStream(s *Stream, depth int64, p unsafe.Pointer) error {
- runtimeInterfaceValue := *(*interface{})(unsafe.Pointer(&emptyInterface{
- typ: d.typ,
- ptr: p,
- }))
- rv := reflect.ValueOf(runtimeInterfaceValue)
- if rv.NumMethod() > 0 && rv.CanInterface() {
- if u, ok := rv.Interface().(unmarshalerContext); ok {
- return decodeStreamUnmarshalerContext(s, depth, u)
- }
- if u, ok := rv.Interface().(json.Unmarshaler); ok {
- return decodeStreamUnmarshaler(s, depth, u)
- }
- if u, ok := rv.Interface().(encoding.TextUnmarshaler); ok {
- return decodeStreamTextUnmarshaler(s, depth, u, p)
- }
- if s.skipWhiteSpace() == 'n' {
- if err := nullBytes(s); err != nil {
- return err
- }
- *(*interface{})(p) = nil
- return nil
- }
- return d.errUnmarshalType(rv.Type(), s.totalOffset())
- }
- iface := rv.Interface()
- ifaceHeader := (*emptyInterface)(unsafe.Pointer(&iface))
- typ := ifaceHeader.typ
- if ifaceHeader.ptr == nil || d.typ == typ || typ == nil {
- // concrete type is empty interface
- return d.decodeStreamEmptyInterface(s, depth, p)
- }
- if typ.Kind() == reflect.Ptr && typ.Elem() == d.typ || typ.Kind() != reflect.Ptr {
- return d.decodeStreamEmptyInterface(s, depth, p)
- }
- if s.skipWhiteSpace() == 'n' {
- if err := nullBytes(s); err != nil {
- return err
- }
- *(*interface{})(p) = nil
- return nil
- }
- decoder, err := CompileToGetDecoder(typ)
- if err != nil {
- return err
- }
- return decoder.DecodeStream(s, depth, ifaceHeader.ptr)
-}
-
-func (d *interfaceDecoder) errUnmarshalType(typ reflect.Type, offset int64) *errors.UnmarshalTypeError {
- return &errors.UnmarshalTypeError{
- Value: typ.String(),
- Type: typ,
- Offset: offset,
- Struct: d.structName,
- Field: d.fieldName,
- }
-}
-
-func (d *interfaceDecoder) Decode(ctx *RuntimeContext, cursor, depth int64, p unsafe.Pointer) (int64, error) {
- buf := ctx.Buf
- runtimeInterfaceValue := *(*interface{})(unsafe.Pointer(&emptyInterface{
- typ: d.typ,
- ptr: p,
- }))
- rv := reflect.ValueOf(runtimeInterfaceValue)
- if rv.NumMethod() > 0 && rv.CanInterface() {
- if u, ok := rv.Interface().(unmarshalerContext); ok {
- return decodeUnmarshalerContext(ctx, buf, cursor, depth, u)
- }
- if u, ok := rv.Interface().(json.Unmarshaler); ok {
- return decodeUnmarshaler(buf, cursor, depth, u)
- }
- if u, ok := rv.Interface().(encoding.TextUnmarshaler); ok {
- return decodeTextUnmarshaler(buf, cursor, depth, u, p)
- }
- cursor = skipWhiteSpace(buf, cursor)
- if buf[cursor] == 'n' {
- if err := validateNull(buf, cursor); err != nil {
- return 0, err
- }
- cursor += 4
- **(**interface{})(unsafe.Pointer(&p)) = nil
- return cursor, nil
- }
- return 0, d.errUnmarshalType(rv.Type(), cursor)
- }
-
- iface := rv.Interface()
- ifaceHeader := (*emptyInterface)(unsafe.Pointer(&iface))
- typ := ifaceHeader.typ
- if ifaceHeader.ptr == nil || d.typ == typ || typ == nil {
- // concrete type is empty interface
- return d.decodeEmptyInterface(ctx, cursor, depth, p)
- }
- if typ.Kind() == reflect.Ptr && typ.Elem() == d.typ || typ.Kind() != reflect.Ptr {
- return d.decodeEmptyInterface(ctx, cursor, depth, p)
- }
- cursor = skipWhiteSpace(buf, cursor)
- if buf[cursor] == 'n' {
- if err := validateNull(buf, cursor); err != nil {
- return 0, err
- }
- cursor += 4
- **(**interface{})(unsafe.Pointer(&p)) = nil
- return cursor, nil
- }
- decoder, err := CompileToGetDecoder(typ)
- if err != nil {
- return 0, err
- }
- return decoder.Decode(ctx, cursor, depth, ifaceHeader.ptr)
-}
-
-func (d *interfaceDecoder) decodeEmptyInterface(ctx *RuntimeContext, cursor, depth int64, p unsafe.Pointer) (int64, error) {
- buf := ctx.Buf
- cursor = skipWhiteSpace(buf, cursor)
- switch buf[cursor] {
- case '{':
- var v map[string]interface{}
- ptr := unsafe.Pointer(&v)
- cursor, err := d.mapDecoder.Decode(ctx, cursor, depth, ptr)
- if err != nil {
- return 0, err
- }
- **(**interface{})(unsafe.Pointer(&p)) = v
- return cursor, nil
- case '[':
- var v []interface{}
- ptr := unsafe.Pointer(&v)
- cursor, err := d.sliceDecoder.Decode(ctx, cursor, depth, ptr)
- if err != nil {
- return 0, err
- }
- **(**interface{})(unsafe.Pointer(&p)) = v
- return cursor, nil
- case '-', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
- return d.floatDecoder.Decode(ctx, cursor, depth, p)
- case '"':
- var v string
- ptr := unsafe.Pointer(&v)
- cursor, err := d.stringDecoder.Decode(ctx, cursor, depth, ptr)
- if err != nil {
- return 0, err
- }
- **(**interface{})(unsafe.Pointer(&p)) = v
- return cursor, nil
- case 't':
- if err := validateTrue(buf, cursor); err != nil {
- return 0, err
- }
- cursor += 4
- **(**interface{})(unsafe.Pointer(&p)) = true
- return cursor, nil
- case 'f':
- if err := validateFalse(buf, cursor); err != nil {
- return 0, err
- }
- cursor += 5
- **(**interface{})(unsafe.Pointer(&p)) = false
- return cursor, nil
- case 'n':
- if err := validateNull(buf, cursor); err != nil {
- return 0, err
- }
- cursor += 4
- **(**interface{})(unsafe.Pointer(&p)) = nil
- return cursor, nil
- }
- return cursor, errors.ErrInvalidBeginningOfValue(buf[cursor], cursor)
-}
-
-func NewPathDecoder() Decoder {
- ifaceDecoder := &interfaceDecoder{
- typ: emptyInterfaceType,
- structName: "",
- fieldName: "",
- floatDecoder: newFloatDecoder("", "", func(p unsafe.Pointer, v float64) {
- *(*interface{})(p) = v
- }),
- numberDecoder: newNumberDecoder("", "", func(p unsafe.Pointer, v json.Number) {
- *(*interface{})(p) = v
- }),
- stringDecoder: newStringDecoder("", ""),
- }
- ifaceDecoder.sliceDecoder = newSliceDecoder(
- ifaceDecoder,
- emptyInterfaceType,
- emptyInterfaceType.Size(),
- "", "",
- )
- ifaceDecoder.mapDecoder = newMapDecoder(
- interfaceMapType,
- stringType,
- ifaceDecoder.stringDecoder,
- interfaceMapType.Elem(),
- ifaceDecoder,
- "", "",
- )
- return ifaceDecoder
-}
-
-var (
- truebytes = []byte("true")
- falsebytes = []byte("false")
-)
-
-func (d *interfaceDecoder) DecodePath(ctx *RuntimeContext, cursor, depth int64) ([][]byte, int64, error) {
- buf := ctx.Buf
- cursor = skipWhiteSpace(buf, cursor)
- switch buf[cursor] {
- case '{':
- return d.mapDecoder.DecodePath(ctx, cursor, depth)
- case '[':
- return d.sliceDecoder.DecodePath(ctx, cursor, depth)
- case '-', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
- return d.floatDecoder.DecodePath(ctx, cursor, depth)
- case '"':
- return d.stringDecoder.DecodePath(ctx, cursor, depth)
- case 't':
- if err := validateTrue(buf, cursor); err != nil {
- return nil, 0, err
- }
- cursor += 4
- return [][]byte{truebytes}, cursor, nil
- case 'f':
- if err := validateFalse(buf, cursor); err != nil {
- return nil, 0, err
- }
- cursor += 5
- return [][]byte{falsebytes}, cursor, nil
- case 'n':
- if err := validateNull(buf, cursor); err != nil {
- return nil, 0, err
- }
- cursor += 4
- return [][]byte{nullbytes}, cursor, nil
- }
- return nil, cursor, errors.ErrInvalidBeginningOfValue(buf[cursor], cursor)
-}
diff --git a/vendor/github.com/goccy/go-json/internal/decoder/invalid.go b/vendor/github.com/goccy/go-json/internal/decoder/invalid.go
deleted file mode 100644
index 4c9721b0..00000000
--- a/vendor/github.com/goccy/go-json/internal/decoder/invalid.go
+++ /dev/null
@@ -1,55 +0,0 @@
-package decoder
-
-import (
- "reflect"
- "unsafe"
-
- "github.com/goccy/go-json/internal/errors"
- "github.com/goccy/go-json/internal/runtime"
-)
-
-type invalidDecoder struct {
- typ *runtime.Type
- kind reflect.Kind
- structName string
- fieldName string
-}
-
-func newInvalidDecoder(typ *runtime.Type, structName, fieldName string) *invalidDecoder {
- return &invalidDecoder{
- typ: typ,
- kind: typ.Kind(),
- structName: structName,
- fieldName: fieldName,
- }
-}
-
-func (d *invalidDecoder) DecodeStream(s *Stream, depth int64, p unsafe.Pointer) error {
- return &errors.UnmarshalTypeError{
- Value: "object",
- Type: runtime.RType2Type(d.typ),
- Offset: s.totalOffset(),
- Struct: d.structName,
- Field: d.fieldName,
- }
-}
-
-func (d *invalidDecoder) Decode(ctx *RuntimeContext, cursor, depth int64, p unsafe.Pointer) (int64, error) {
- return 0, &errors.UnmarshalTypeError{
- Value: "object",
- Type: runtime.RType2Type(d.typ),
- Offset: cursor,
- Struct: d.structName,
- Field: d.fieldName,
- }
-}
-
-func (d *invalidDecoder) DecodePath(ctx *RuntimeContext, cursor, depth int64) ([][]byte, int64, error) {
- return nil, 0, &errors.UnmarshalTypeError{
- Value: "object",
- Type: runtime.RType2Type(d.typ),
- Offset: cursor,
- Struct: d.structName,
- Field: d.fieldName,
- }
-}
diff --git a/vendor/github.com/goccy/go-json/internal/decoder/map.go b/vendor/github.com/goccy/go-json/internal/decoder/map.go
deleted file mode 100644
index 07a9caea..00000000
--- a/vendor/github.com/goccy/go-json/internal/decoder/map.go
+++ /dev/null
@@ -1,280 +0,0 @@
-package decoder
-
-import (
- "reflect"
- "unsafe"
-
- "github.com/goccy/go-json/internal/errors"
- "github.com/goccy/go-json/internal/runtime"
-)
-
-type mapDecoder struct {
- mapType *runtime.Type
- keyType *runtime.Type
- valueType *runtime.Type
- canUseAssignFaststrType bool
- keyDecoder Decoder
- valueDecoder Decoder
- structName string
- fieldName string
-}
-
-func newMapDecoder(mapType *runtime.Type, keyType *runtime.Type, keyDec Decoder, valueType *runtime.Type, valueDec Decoder, structName, fieldName string) *mapDecoder {
- return &mapDecoder{
- mapType: mapType,
- keyDecoder: keyDec,
- keyType: keyType,
- canUseAssignFaststrType: canUseAssignFaststrType(keyType, valueType),
- valueType: valueType,
- valueDecoder: valueDec,
- structName: structName,
- fieldName: fieldName,
- }
-}
-
-const (
- mapMaxElemSize = 128
-)
-
-// See detail: https://github.com/goccy/go-json/pull/283
-func canUseAssignFaststrType(key *runtime.Type, value *runtime.Type) bool {
- indirectElem := value.Size() > mapMaxElemSize
- if indirectElem {
- return false
- }
- return key.Kind() == reflect.String
-}
-
-//go:linkname makemap reflect.makemap
-func makemap(*runtime.Type, int) unsafe.Pointer
-
-//nolint:golint
-//go:linkname mapassign_faststr runtime.mapassign_faststr
-//go:noescape
-func mapassign_faststr(t *runtime.Type, m unsafe.Pointer, s string) unsafe.Pointer
-
-//go:linkname mapassign reflect.mapassign
-//go:noescape
-func mapassign(t *runtime.Type, m unsafe.Pointer, k, v unsafe.Pointer)
-
-func (d *mapDecoder) mapassign(t *runtime.Type, m, k, v unsafe.Pointer) {
- if d.canUseAssignFaststrType {
- mapV := mapassign_faststr(t, m, *(*string)(k))
- typedmemmove(d.valueType, mapV, v)
- } else {
- mapassign(t, m, k, v)
- }
-}
-
-func (d *mapDecoder) DecodeStream(s *Stream, depth int64, p unsafe.Pointer) error {
- depth++
- if depth > maxDecodeNestingDepth {
- return errors.ErrExceededMaxDepth(s.char(), s.cursor)
- }
-
- switch s.skipWhiteSpace() {
- case 'n':
- if err := nullBytes(s); err != nil {
- return err
- }
- **(**unsafe.Pointer)(unsafe.Pointer(&p)) = nil
- return nil
- case '{':
- default:
- return errors.ErrExpected("{ character for map value", s.totalOffset())
- }
- mapValue := *(*unsafe.Pointer)(p)
- if mapValue == nil {
- mapValue = makemap(d.mapType, 0)
- }
- s.cursor++
- if s.skipWhiteSpace() == '}' {
- *(*unsafe.Pointer)(p) = mapValue
- s.cursor++
- return nil
- }
- for {
- k := unsafe_New(d.keyType)
- if err := d.keyDecoder.DecodeStream(s, depth, k); err != nil {
- return err
- }
- s.skipWhiteSpace()
- if !s.equalChar(':') {
- return errors.ErrExpected("colon after object key", s.totalOffset())
- }
- s.cursor++
- v := unsafe_New(d.valueType)
- if err := d.valueDecoder.DecodeStream(s, depth, v); err != nil {
- return err
- }
- d.mapassign(d.mapType, mapValue, k, v)
- s.skipWhiteSpace()
- if s.equalChar('}') {
- **(**unsafe.Pointer)(unsafe.Pointer(&p)) = mapValue
- s.cursor++
- return nil
- }
- if !s.equalChar(',') {
- return errors.ErrExpected("comma after object value", s.totalOffset())
- }
- s.cursor++
- }
-}
-
-func (d *mapDecoder) Decode(ctx *RuntimeContext, cursor, depth int64, p unsafe.Pointer) (int64, error) {
- buf := ctx.Buf
- depth++
- if depth > maxDecodeNestingDepth {
- return 0, errors.ErrExceededMaxDepth(buf[cursor], cursor)
- }
-
- cursor = skipWhiteSpace(buf, cursor)
- buflen := int64(len(buf))
- if buflen < 2 {
- return 0, errors.ErrExpected("{} for map", cursor)
- }
- switch buf[cursor] {
- case 'n':
- if err := validateNull(buf, cursor); err != nil {
- return 0, err
- }
- cursor += 4
- **(**unsafe.Pointer)(unsafe.Pointer(&p)) = nil
- return cursor, nil
- case '{':
- default:
- return 0, errors.ErrExpected("{ character for map value", cursor)
- }
- cursor++
- cursor = skipWhiteSpace(buf, cursor)
- mapValue := *(*unsafe.Pointer)(p)
- if mapValue == nil {
- mapValue = makemap(d.mapType, 0)
- }
- if buf[cursor] == '}' {
- **(**unsafe.Pointer)(unsafe.Pointer(&p)) = mapValue
- cursor++
- return cursor, nil
- }
- for {
- k := unsafe_New(d.keyType)
- keyCursor, err := d.keyDecoder.Decode(ctx, cursor, depth, k)
- if err != nil {
- return 0, err
- }
- cursor = skipWhiteSpace(buf, keyCursor)
- if buf[cursor] != ':' {
- return 0, errors.ErrExpected("colon after object key", cursor)
- }
- cursor++
- v := unsafe_New(d.valueType)
- valueCursor, err := d.valueDecoder.Decode(ctx, cursor, depth, v)
- if err != nil {
- return 0, err
- }
- d.mapassign(d.mapType, mapValue, k, v)
- cursor = skipWhiteSpace(buf, valueCursor)
- if buf[cursor] == '}' {
- **(**unsafe.Pointer)(unsafe.Pointer(&p)) = mapValue
- cursor++
- return cursor, nil
- }
- if buf[cursor] != ',' {
- return 0, errors.ErrExpected("comma after object value", cursor)
- }
- cursor++
- }
-}
-
-func (d *mapDecoder) DecodePath(ctx *RuntimeContext, cursor, depth int64) ([][]byte, int64, error) {
- buf := ctx.Buf
- depth++
- if depth > maxDecodeNestingDepth {
- return nil, 0, errors.ErrExceededMaxDepth(buf[cursor], cursor)
- }
-
- cursor = skipWhiteSpace(buf, cursor)
- buflen := int64(len(buf))
- if buflen < 2 {
- return nil, 0, errors.ErrExpected("{} for map", cursor)
- }
- switch buf[cursor] {
- case 'n':
- if err := validateNull(buf, cursor); err != nil {
- return nil, 0, err
- }
- cursor += 4
- return [][]byte{nullbytes}, cursor, nil
- case '{':
- default:
- return nil, 0, errors.ErrExpected("{ character for map value", cursor)
- }
- cursor++
- cursor = skipWhiteSpace(buf, cursor)
- if buf[cursor] == '}' {
- cursor++
- return nil, cursor, nil
- }
- keyDecoder, ok := d.keyDecoder.(*stringDecoder)
- if !ok {
- return nil, 0, &errors.UnmarshalTypeError{
- Value: "string",
- Type: reflect.TypeOf(""),
- Offset: cursor,
- Struct: d.structName,
- Field: d.fieldName,
- }
- }
- ret := [][]byte{}
- for {
- key, keyCursor, err := keyDecoder.decodeByte(buf, cursor)
- if err != nil {
- return nil, 0, err
- }
- cursor = skipWhiteSpace(buf, keyCursor)
- if buf[cursor] != ':' {
- return nil, 0, errors.ErrExpected("colon after object key", cursor)
- }
- cursor++
- child, found, err := ctx.Option.Path.Field(string(key))
- if err != nil {
- return nil, 0, err
- }
- if found {
- if child != nil {
- oldPath := ctx.Option.Path.node
- ctx.Option.Path.node = child
- paths, c, err := d.valueDecoder.DecodePath(ctx, cursor, depth)
- if err != nil {
- return nil, 0, err
- }
- ctx.Option.Path.node = oldPath
- ret = append(ret, paths...)
- cursor = c
- } else {
- start := cursor
- end, err := skipValue(buf, cursor, depth)
- if err != nil {
- return nil, 0, err
- }
- ret = append(ret, buf[start:end])
- cursor = end
- }
- } else {
- c, err := skipValue(buf, cursor, depth)
- if err != nil {
- return nil, 0, err
- }
- cursor = c
- }
- cursor = skipWhiteSpace(buf, cursor)
- if buf[cursor] == '}' {
- cursor++
- return ret, cursor, nil
- }
- if buf[cursor] != ',' {
- return nil, 0, errors.ErrExpected("comma after object value", cursor)
- }
- cursor++
- }
-}
diff --git a/vendor/github.com/goccy/go-json/internal/decoder/number.go b/vendor/github.com/goccy/go-json/internal/decoder/number.go
deleted file mode 100644
index 10e5435e..00000000
--- a/vendor/github.com/goccy/go-json/internal/decoder/number.go
+++ /dev/null
@@ -1,123 +0,0 @@
-package decoder
-
-import (
- "encoding/json"
- "strconv"
- "unsafe"
-
- "github.com/goccy/go-json/internal/errors"
-)
-
-type numberDecoder struct {
- stringDecoder *stringDecoder
- op func(unsafe.Pointer, json.Number)
- structName string
- fieldName string
-}
-
-func newNumberDecoder(structName, fieldName string, op func(unsafe.Pointer, json.Number)) *numberDecoder {
- return &numberDecoder{
- stringDecoder: newStringDecoder(structName, fieldName),
- op: op,
- structName: structName,
- fieldName: fieldName,
- }
-}
-
-func (d *numberDecoder) DecodeStream(s *Stream, depth int64, p unsafe.Pointer) error {
- bytes, err := d.decodeStreamByte(s)
- if err != nil {
- return err
- }
- if _, err := strconv.ParseFloat(*(*string)(unsafe.Pointer(&bytes)), 64); err != nil {
- return errors.ErrSyntax(err.Error(), s.totalOffset())
- }
- d.op(p, json.Number(string(bytes)))
- s.reset()
- return nil
-}
-
-func (d *numberDecoder) Decode(ctx *RuntimeContext, cursor, depth int64, p unsafe.Pointer) (int64, error) {
- bytes, c, err := d.decodeByte(ctx.Buf, cursor)
- if err != nil {
- return 0, err
- }
- if _, err := strconv.ParseFloat(*(*string)(unsafe.Pointer(&bytes)), 64); err != nil {
- return 0, errors.ErrSyntax(err.Error(), c)
- }
- cursor = c
- s := *(*string)(unsafe.Pointer(&bytes))
- d.op(p, json.Number(s))
- return cursor, nil
-}
-
-func (d *numberDecoder) DecodePath(ctx *RuntimeContext, cursor, depth int64) ([][]byte, int64, error) {
- bytes, c, err := d.decodeByte(ctx.Buf, cursor)
- if err != nil {
- return nil, 0, err
- }
- if bytes == nil {
- return [][]byte{nullbytes}, c, nil
- }
- return [][]byte{bytes}, c, nil
-}
-
-func (d *numberDecoder) decodeStreamByte(s *Stream) ([]byte, error) {
- start := s.cursor
- for {
- switch s.char() {
- case ' ', '\n', '\t', '\r':
- s.cursor++
- continue
- case '-', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
- return floatBytes(s), nil
- case 'n':
- if err := nullBytes(s); err != nil {
- return nil, err
- }
- return nil, nil
- case '"':
- return d.stringDecoder.decodeStreamByte(s)
- case nul:
- if s.read() {
- continue
- }
- goto ERROR
- default:
- goto ERROR
- }
- }
-ERROR:
- if s.cursor == start {
- return nil, errors.ErrInvalidBeginningOfValue(s.char(), s.totalOffset())
- }
- return nil, errors.ErrUnexpectedEndOfJSON("json.Number", s.totalOffset())
-}
-
-func (d *numberDecoder) decodeByte(buf []byte, cursor int64) ([]byte, int64, error) {
- for {
- switch buf[cursor] {
- case ' ', '\n', '\t', '\r':
- cursor++
- continue
- case '-', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
- start := cursor
- cursor++
- for floatTable[buf[cursor]] {
- cursor++
- }
- num := buf[start:cursor]
- return num, cursor, nil
- case 'n':
- if err := validateNull(buf, cursor); err != nil {
- return nil, 0, err
- }
- cursor += 4
- return nil, cursor, nil
- case '"':
- return d.stringDecoder.decodeByte(buf, cursor)
- default:
- return nil, 0, errors.ErrUnexpectedEndOfJSON("json.Number", cursor)
- }
- }
-}
diff --git a/vendor/github.com/goccy/go-json/internal/decoder/option.go b/vendor/github.com/goccy/go-json/internal/decoder/option.go
deleted file mode 100644
index 502f772e..00000000
--- a/vendor/github.com/goccy/go-json/internal/decoder/option.go
+++ /dev/null
@@ -1,17 +0,0 @@
-package decoder
-
-import "context"
-
-type OptionFlags uint8
-
-const (
- FirstWinOption OptionFlags = 1 << iota
- ContextOption
- PathOption
-)
-
-type Option struct {
- Flags OptionFlags
- Context context.Context
- Path *Path
-}
diff --git a/vendor/github.com/goccy/go-json/internal/decoder/path.go b/vendor/github.com/goccy/go-json/internal/decoder/path.go
deleted file mode 100644
index a15ff69e..00000000
--- a/vendor/github.com/goccy/go-json/internal/decoder/path.go
+++ /dev/null
@@ -1,670 +0,0 @@
-package decoder
-
-import (
- "fmt"
- "reflect"
- "strconv"
-
- "github.com/goccy/go-json/internal/errors"
- "github.com/goccy/go-json/internal/runtime"
-)
-
-type PathString string
-
-func (s PathString) Build() (*Path, error) {
- builder := new(PathBuilder)
- return builder.Build([]rune(s))
-}
-
-type PathBuilder struct {
- root PathNode
- node PathNode
- singleQuotePathSelector bool
- doubleQuotePathSelector bool
-}
-
-func (b *PathBuilder) Build(buf []rune) (*Path, error) {
- node, err := b.build(buf)
- if err != nil {
- return nil, err
- }
- return &Path{
- node: node,
- RootSelectorOnly: node == nil,
- SingleQuotePathSelector: b.singleQuotePathSelector,
- DoubleQuotePathSelector: b.doubleQuotePathSelector,
- }, nil
-}
-
-func (b *PathBuilder) build(buf []rune) (PathNode, error) {
- if len(buf) == 0 {
- return nil, errors.ErrEmptyPath()
- }
- if buf[0] != '$' {
- return nil, errors.ErrInvalidPath("JSON Path must start with a $ character")
- }
- if len(buf) == 1 {
- return nil, nil
- }
- buf = buf[1:]
- offset, err := b.buildNext(buf)
- if err != nil {
- return nil, err
- }
- if len(buf) > offset {
- return nil, errors.ErrInvalidPath("remain invalid path %q", buf[offset:])
- }
- return b.root, nil
-}
-
-func (b *PathBuilder) buildNextCharIfExists(buf []rune, cursor int) (int, error) {
- if len(buf) > cursor {
- offset, err := b.buildNext(buf[cursor:])
- if err != nil {
- return 0, err
- }
- return cursor + 1 + offset, nil
- }
- return cursor, nil
-}
-
-func (b *PathBuilder) buildNext(buf []rune) (int, error) {
- switch buf[0] {
- case '.':
- if len(buf) == 1 {
- return 0, errors.ErrInvalidPath("JSON Path ends with dot character")
- }
- offset, err := b.buildSelector(buf[1:])
- if err != nil {
- return 0, err
- }
- return offset + 1, nil
- case '[':
- if len(buf) == 1 {
- return 0, errors.ErrInvalidPath("JSON Path ends with left bracket character")
- }
- offset, err := b.buildIndex(buf[1:])
- if err != nil {
- return 0, err
- }
- return offset + 1, nil
- default:
- return 0, errors.ErrInvalidPath("expect dot or left bracket character. but found %c character", buf[0])
- }
-}
-
-func (b *PathBuilder) buildSelector(buf []rune) (int, error) {
- switch buf[0] {
- case '.':
- if len(buf) == 1 {
- return 0, errors.ErrInvalidPath("JSON Path ends with double dot character")
- }
- offset, err := b.buildPathRecursive(buf[1:])
- if err != nil {
- return 0, err
- }
- return 1 + offset, nil
- case '[', ']', '$', '*':
- return 0, errors.ErrInvalidPath("found invalid path character %c after dot", buf[0])
- }
- for cursor := 0; cursor < len(buf); cursor++ {
- switch buf[cursor] {
- case '$', '*', ']':
- return 0, errors.ErrInvalidPath("found %c character in field selector context", buf[cursor])
- case '.':
- if cursor+1 >= len(buf) {
- return 0, errors.ErrInvalidPath("JSON Path ends with dot character")
- }
- selector := buf[:cursor]
- b.addSelectorNode(string(selector))
- offset, err := b.buildSelector(buf[cursor+1:])
- if err != nil {
- return 0, err
- }
- return cursor + 1 + offset, nil
- case '[':
- if cursor+1 >= len(buf) {
- return 0, errors.ErrInvalidPath("JSON Path ends with left bracket character")
- }
- selector := buf[:cursor]
- b.addSelectorNode(string(selector))
- offset, err := b.buildIndex(buf[cursor+1:])
- if err != nil {
- return 0, err
- }
- return cursor + 1 + offset, nil
- case '"':
- if cursor+1 >= len(buf) {
- return 0, errors.ErrInvalidPath("JSON Path ends with double quote character")
- }
- offset, err := b.buildQuoteSelector(buf[cursor+1:], DoubleQuotePathSelector)
- if err != nil {
- return 0, err
- }
- return cursor + 1 + offset, nil
- }
- }
- b.addSelectorNode(string(buf))
- return len(buf), nil
-}
-
-func (b *PathBuilder) buildQuoteSelector(buf []rune, sel QuotePathSelector) (int, error) {
- switch buf[0] {
- case '[', ']', '$', '.', '*', '\'', '"':
- return 0, errors.ErrInvalidPath("found invalid path character %c after quote", buf[0])
- }
- for cursor := 0; cursor < len(buf); cursor++ {
- switch buf[cursor] {
- case '\'':
- if sel != SingleQuotePathSelector {
- return 0, errors.ErrInvalidPath("found double quote character in field selector with single quote context")
- }
- if len(buf) <= cursor+1 {
- return 0, errors.ErrInvalidPath("JSON Path ends with single quote character in field selector context")
- }
- if buf[cursor+1] != ']' {
- return 0, errors.ErrInvalidPath("expect right bracket for field selector with single quote but found %c", buf[cursor+1])
- }
- selector := buf[:cursor]
- b.addSelectorNode(string(selector))
- b.singleQuotePathSelector = true
- return b.buildNextCharIfExists(buf, cursor+2)
- case '"':
- if sel != DoubleQuotePathSelector {
- return 0, errors.ErrInvalidPath("found single quote character in field selector with double quote context")
- }
- selector := buf[:cursor]
- b.addSelectorNode(string(selector))
- b.doubleQuotePathSelector = true
- return b.buildNextCharIfExists(buf, cursor+1)
- }
- }
- return 0, errors.ErrInvalidPath("couldn't find quote character in selector quote path context")
-}
-
-func (b *PathBuilder) buildPathRecursive(buf []rune) (int, error) {
- switch buf[0] {
- case '.', '[', ']', '$', '*':
- return 0, errors.ErrInvalidPath("found invalid path character %c after double dot", buf[0])
- }
- for cursor := 0; cursor < len(buf); cursor++ {
- switch buf[cursor] {
- case '$', '*', ']':
- return 0, errors.ErrInvalidPath("found %c character in field selector context", buf[cursor])
- case '.':
- if cursor+1 >= len(buf) {
- return 0, errors.ErrInvalidPath("JSON Path ends with dot character")
- }
- selector := buf[:cursor]
- b.addRecursiveNode(string(selector))
- offset, err := b.buildSelector(buf[cursor+1:])
- if err != nil {
- return 0, err
- }
- return cursor + 1 + offset, nil
- case '[':
- if cursor+1 >= len(buf) {
- return 0, errors.ErrInvalidPath("JSON Path ends with left bracket character")
- }
- selector := buf[:cursor]
- b.addRecursiveNode(string(selector))
- offset, err := b.buildIndex(buf[cursor+1:])
- if err != nil {
- return 0, err
- }
- return cursor + 1 + offset, nil
- }
- }
- b.addRecursiveNode(string(buf))
- return len(buf), nil
-}
-
-func (b *PathBuilder) buildIndex(buf []rune) (int, error) {
- switch buf[0] {
- case '.', '[', ']', '$':
- return 0, errors.ErrInvalidPath("found invalid path character %c after left bracket", buf[0])
- case '\'':
- if len(buf) == 1 {
- return 0, errors.ErrInvalidPath("JSON Path ends with single quote character")
- }
- offset, err := b.buildQuoteSelector(buf[1:], SingleQuotePathSelector)
- if err != nil {
- return 0, err
- }
- return 1 + offset, nil
- case '*':
- if len(buf) == 1 {
- return 0, errors.ErrInvalidPath("JSON Path ends with star character")
- }
- if buf[1] != ']' {
- return 0, errors.ErrInvalidPath("expect right bracket character for index all path but found %c character", buf[1])
- }
- b.addIndexAllNode()
- offset := len("*]")
- if len(buf) > 2 {
- buildOffset, err := b.buildNext(buf[2:])
- if err != nil {
- return 0, err
- }
- return offset + buildOffset, nil
- }
- return offset, nil
- }
-
- for cursor := 0; cursor < len(buf); cursor++ {
- switch buf[cursor] {
- case ']':
- index, err := strconv.ParseInt(string(buf[:cursor]), 10, 64)
- if err != nil {
- return 0, errors.ErrInvalidPath("%q is unexpected index path", buf[:cursor])
- }
- b.addIndexNode(int(index))
- return b.buildNextCharIfExists(buf, cursor+1)
- }
- }
- return 0, errors.ErrInvalidPath("couldn't find right bracket character in index path context")
-}
-
-func (b *PathBuilder) addIndexAllNode() {
- node := newPathIndexAllNode()
- if b.root == nil {
- b.root = node
- b.node = node
- } else {
- b.node = b.node.chain(node)
- }
-}
-
-func (b *PathBuilder) addRecursiveNode(selector string) {
- node := newPathRecursiveNode(selector)
- if b.root == nil {
- b.root = node
- b.node = node
- } else {
- b.node = b.node.chain(node)
- }
-}
-
-func (b *PathBuilder) addSelectorNode(name string) {
- node := newPathSelectorNode(name)
- if b.root == nil {
- b.root = node
- b.node = node
- } else {
- b.node = b.node.chain(node)
- }
-}
-
-func (b *PathBuilder) addIndexNode(idx int) {
- node := newPathIndexNode(idx)
- if b.root == nil {
- b.root = node
- b.node = node
- } else {
- b.node = b.node.chain(node)
- }
-}
-
-type QuotePathSelector int
-
-const (
- SingleQuotePathSelector QuotePathSelector = 1
- DoubleQuotePathSelector QuotePathSelector = 2
-)
-
-type Path struct {
- node PathNode
- RootSelectorOnly bool
- SingleQuotePathSelector bool
- DoubleQuotePathSelector bool
-}
-
-func (p *Path) Field(sel string) (PathNode, bool, error) {
- if p.node == nil {
- return nil, false, nil
- }
- return p.node.Field(sel)
-}
-
-func (p *Path) Get(src, dst reflect.Value) error {
- if p.node == nil {
- return nil
- }
- return p.node.Get(src, dst)
-}
-
-func (p *Path) String() string {
- if p.node == nil {
- return "$"
- }
- return p.node.String()
-}
-
-type PathNode interface {
- fmt.Stringer
- Index(idx int) (PathNode, bool, error)
- Field(fieldName string) (PathNode, bool, error)
- Get(src, dst reflect.Value) error
- chain(PathNode) PathNode
- target() bool
- single() bool
-}
-
-type BasePathNode struct {
- child PathNode
-}
-
-func (n *BasePathNode) chain(node PathNode) PathNode {
- n.child = node
- return node
-}
-
-func (n *BasePathNode) target() bool {
- return n.child == nil
-}
-
-func (n *BasePathNode) single() bool {
- return true
-}
-
-type PathSelectorNode struct {
- *BasePathNode
- selector string
-}
-
-func newPathSelectorNode(selector string) *PathSelectorNode {
- return &PathSelectorNode{
- BasePathNode: &BasePathNode{},
- selector: selector,
- }
-}
-
-func (n *PathSelectorNode) Index(idx int) (PathNode, bool, error) {
- return nil, false, &errors.PathError{}
-}
-
-func (n *PathSelectorNode) Field(fieldName string) (PathNode, bool, error) {
- if n.selector == fieldName {
- return n.child, true, nil
- }
- return nil, false, nil
-}
-
-func (n *PathSelectorNode) Get(src, dst reflect.Value) error {
- switch src.Type().Kind() {
- case reflect.Map:
- iter := src.MapRange()
- for iter.Next() {
- key, ok := iter.Key().Interface().(string)
- if !ok {
- return fmt.Errorf("invalid map key type %T", src.Type().Key())
- }
- child, found, err := n.Field(key)
- if err != nil {
- return err
- }
- if found {
- if child != nil {
- return child.Get(iter.Value(), dst)
- }
- return AssignValue(iter.Value(), dst)
- }
- }
- case reflect.Struct:
- typ := src.Type()
- for i := 0; i < typ.Len(); i++ {
- tag := runtime.StructTagFromField(typ.Field(i))
- child, found, err := n.Field(tag.Key)
- if err != nil {
- return err
- }
- if found {
- if child != nil {
- return child.Get(src.Field(i), dst)
- }
- return AssignValue(src.Field(i), dst)
- }
- }
- case reflect.Ptr:
- return n.Get(src.Elem(), dst)
- case reflect.Interface:
- return n.Get(reflect.ValueOf(src.Interface()), dst)
- case reflect.Float64, reflect.String, reflect.Bool:
- return AssignValue(src, dst)
- }
- return fmt.Errorf("failed to get %s value from %s", n.selector, src.Type())
-}
-
-func (n *PathSelectorNode) String() string {
- s := fmt.Sprintf(".%s", n.selector)
- if n.child != nil {
- s += n.child.String()
- }
- return s
-}
-
-type PathIndexNode struct {
- *BasePathNode
- selector int
-}
-
-func newPathIndexNode(selector int) *PathIndexNode {
- return &PathIndexNode{
- BasePathNode: &BasePathNode{},
- selector: selector,
- }
-}
-
-func (n *PathIndexNode) Index(idx int) (PathNode, bool, error) {
- if n.selector == idx {
- return n.child, true, nil
- }
- return nil, false, nil
-}
-
-func (n *PathIndexNode) Field(fieldName string) (PathNode, bool, error) {
- return nil, false, &errors.PathError{}
-}
-
-func (n *PathIndexNode) Get(src, dst reflect.Value) error {
- switch src.Type().Kind() {
- case reflect.Array, reflect.Slice:
- if src.Len() > n.selector {
- if n.child != nil {
- return n.child.Get(src.Index(n.selector), dst)
- }
- return AssignValue(src.Index(n.selector), dst)
- }
- case reflect.Ptr:
- return n.Get(src.Elem(), dst)
- case reflect.Interface:
- return n.Get(reflect.ValueOf(src.Interface()), dst)
- }
- return fmt.Errorf("failed to get [%d] value from %s", n.selector, src.Type())
-}
-
-func (n *PathIndexNode) String() string {
- s := fmt.Sprintf("[%d]", n.selector)
- if n.child != nil {
- s += n.child.String()
- }
- return s
-}
-
-type PathIndexAllNode struct {
- *BasePathNode
-}
-
-func newPathIndexAllNode() *PathIndexAllNode {
- return &PathIndexAllNode{
- BasePathNode: &BasePathNode{},
- }
-}
-
-func (n *PathIndexAllNode) Index(idx int) (PathNode, bool, error) {
- return n.child, true, nil
-}
-
-func (n *PathIndexAllNode) Field(fieldName string) (PathNode, bool, error) {
- return nil, false, &errors.PathError{}
-}
-
-func (n *PathIndexAllNode) Get(src, dst reflect.Value) error {
- switch src.Type().Kind() {
- case reflect.Array, reflect.Slice:
- var arr []interface{}
- for i := 0; i < src.Len(); i++ {
- var v interface{}
- rv := reflect.ValueOf(&v)
- if n.child != nil {
- if err := n.child.Get(src.Index(i), rv); err != nil {
- return err
- }
- } else {
- if err := AssignValue(src.Index(i), rv); err != nil {
- return err
- }
- }
- arr = append(arr, v)
- }
- if err := AssignValue(reflect.ValueOf(arr), dst); err != nil {
- return err
- }
- return nil
- case reflect.Ptr:
- return n.Get(src.Elem(), dst)
- case reflect.Interface:
- return n.Get(reflect.ValueOf(src.Interface()), dst)
- }
- return fmt.Errorf("failed to get all value from %s", src.Type())
-}
-
-func (n *PathIndexAllNode) String() string {
- s := "[*]"
- if n.child != nil {
- s += n.child.String()
- }
- return s
-}
-
-type PathRecursiveNode struct {
- *BasePathNode
- selector string
-}
-
-func newPathRecursiveNode(selector string) *PathRecursiveNode {
- node := newPathSelectorNode(selector)
- return &PathRecursiveNode{
- BasePathNode: &BasePathNode{
- child: node,
- },
- selector: selector,
- }
-}
-
-func (n *PathRecursiveNode) Field(fieldName string) (PathNode, bool, error) {
- if n.selector == fieldName {
- return n.child, true, nil
- }
- return nil, false, nil
-}
-
-func (n *PathRecursiveNode) Index(_ int) (PathNode, bool, error) {
- return n, true, nil
-}
-
-func valueToSliceValue(v interface{}) []interface{} {
- rv := reflect.ValueOf(v)
- ret := []interface{}{}
- if rv.Type().Kind() == reflect.Slice || rv.Type().Kind() == reflect.Array {
- for i := 0; i < rv.Len(); i++ {
- ret = append(ret, rv.Index(i).Interface())
- }
- return ret
- }
- return []interface{}{v}
-}
-
-func (n *PathRecursiveNode) Get(src, dst reflect.Value) error {
- if n.child == nil {
- return fmt.Errorf("failed to get by recursive path ..%s", n.selector)
- }
- var arr []interface{}
- switch src.Type().Kind() {
- case reflect.Map:
- iter := src.MapRange()
- for iter.Next() {
- key, ok := iter.Key().Interface().(string)
- if !ok {
- return fmt.Errorf("invalid map key type %T", src.Type().Key())
- }
- child, found, err := n.Field(key)
- if err != nil {
- return err
- }
- if found {
- var v interface{}
- rv := reflect.ValueOf(&v)
- _ = child.Get(iter.Value(), rv)
- arr = append(arr, valueToSliceValue(v)...)
- } else {
- var v interface{}
- rv := reflect.ValueOf(&v)
- _ = n.Get(iter.Value(), rv)
- if v != nil {
- arr = append(arr, valueToSliceValue(v)...)
- }
- }
- }
- _ = AssignValue(reflect.ValueOf(arr), dst)
- return nil
- case reflect.Struct:
- typ := src.Type()
- for i := 0; i < typ.Len(); i++ {
- tag := runtime.StructTagFromField(typ.Field(i))
- child, found, err := n.Field(tag.Key)
- if err != nil {
- return err
- }
- if found {
- var v interface{}
- rv := reflect.ValueOf(&v)
- _ = child.Get(src.Field(i), rv)
- arr = append(arr, valueToSliceValue(v)...)
- } else {
- var v interface{}
- rv := reflect.ValueOf(&v)
- _ = n.Get(src.Field(i), rv)
- if v != nil {
- arr = append(arr, valueToSliceValue(v)...)
- }
- }
- }
- _ = AssignValue(reflect.ValueOf(arr), dst)
- return nil
- case reflect.Array, reflect.Slice:
- for i := 0; i < src.Len(); i++ {
- var v interface{}
- rv := reflect.ValueOf(&v)
- _ = n.Get(src.Index(i), rv)
- if v != nil {
- arr = append(arr, valueToSliceValue(v)...)
- }
- }
- _ = AssignValue(reflect.ValueOf(arr), dst)
- return nil
- case reflect.Ptr:
- return n.Get(src.Elem(), dst)
- case reflect.Interface:
- return n.Get(reflect.ValueOf(src.Interface()), dst)
- }
- return fmt.Errorf("failed to get %s value from %s", n.selector, src.Type())
-}
-
-func (n *PathRecursiveNode) String() string {
- s := fmt.Sprintf("..%s", n.selector)
- if n.child != nil {
- s += n.child.String()
- }
- return s
-}
diff --git a/vendor/github.com/goccy/go-json/internal/decoder/ptr.go b/vendor/github.com/goccy/go-json/internal/decoder/ptr.go
deleted file mode 100644
index ae229946..00000000
--- a/vendor/github.com/goccy/go-json/internal/decoder/ptr.go
+++ /dev/null
@@ -1,97 +0,0 @@
-package decoder
-
-import (
- "fmt"
- "unsafe"
-
- "github.com/goccy/go-json/internal/runtime"
-)
-
-type ptrDecoder struct {
- dec Decoder
- typ *runtime.Type
- structName string
- fieldName string
-}
-
-func newPtrDecoder(dec Decoder, typ *runtime.Type, structName, fieldName string) *ptrDecoder {
- return &ptrDecoder{
- dec: dec,
- typ: typ,
- structName: structName,
- fieldName: fieldName,
- }
-}
-
-func (d *ptrDecoder) contentDecoder() Decoder {
- dec, ok := d.dec.(*ptrDecoder)
- if !ok {
- return d.dec
- }
- return dec.contentDecoder()
-}
-
-//nolint:golint
-//go:linkname unsafe_New reflect.unsafe_New
-func unsafe_New(*runtime.Type) unsafe.Pointer
-
-func UnsafeNew(t *runtime.Type) unsafe.Pointer {
- return unsafe_New(t)
-}
-
-func (d *ptrDecoder) DecodeStream(s *Stream, depth int64, p unsafe.Pointer) error {
- if s.skipWhiteSpace() == nul {
- s.read()
- }
- if s.char() == 'n' {
- if err := nullBytes(s); err != nil {
- return err
- }
- *(*unsafe.Pointer)(p) = nil
- return nil
- }
- var newptr unsafe.Pointer
- if *(*unsafe.Pointer)(p) == nil {
- newptr = unsafe_New(d.typ)
- *(*unsafe.Pointer)(p) = newptr
- } else {
- newptr = *(*unsafe.Pointer)(p)
- }
- if err := d.dec.DecodeStream(s, depth, newptr); err != nil {
- return err
- }
- return nil
-}
-
-func (d *ptrDecoder) Decode(ctx *RuntimeContext, cursor, depth int64, p unsafe.Pointer) (int64, error) {
- buf := ctx.Buf
- cursor = skipWhiteSpace(buf, cursor)
- if buf[cursor] == 'n' {
- if err := validateNull(buf, cursor); err != nil {
- return 0, err
- }
- if p != nil {
- *(*unsafe.Pointer)(p) = nil
- }
- cursor += 4
- return cursor, nil
- }
- var newptr unsafe.Pointer
- if *(*unsafe.Pointer)(p) == nil {
- newptr = unsafe_New(d.typ)
- *(*unsafe.Pointer)(p) = newptr
- } else {
- newptr = *(*unsafe.Pointer)(p)
- }
- c, err := d.dec.Decode(ctx, cursor, depth, newptr)
- if err != nil {
- *(*unsafe.Pointer)(p) = nil
- return 0, err
- }
- cursor = c
- return cursor, nil
-}
-
-func (d *ptrDecoder) DecodePath(ctx *RuntimeContext, cursor, depth int64) ([][]byte, int64, error) {
- return nil, 0, fmt.Errorf("json: ptr decoder does not support decode path")
-}
diff --git a/vendor/github.com/goccy/go-json/internal/decoder/slice.go b/vendor/github.com/goccy/go-json/internal/decoder/slice.go
deleted file mode 100644
index 30a23e4b..00000000
--- a/vendor/github.com/goccy/go-json/internal/decoder/slice.go
+++ /dev/null
@@ -1,380 +0,0 @@
-package decoder
-
-import (
- "reflect"
- "sync"
- "unsafe"
-
- "github.com/goccy/go-json/internal/errors"
- "github.com/goccy/go-json/internal/runtime"
-)
-
-var (
- sliceType = runtime.Type2RType(
- reflect.TypeOf((*sliceHeader)(nil)).Elem(),
- )
- nilSlice = unsafe.Pointer(&sliceHeader{})
-)
-
-type sliceDecoder struct {
- elemType *runtime.Type
- isElemPointerType bool
- valueDecoder Decoder
- size uintptr
- arrayPool sync.Pool
- structName string
- fieldName string
-}
-
-// If use reflect.SliceHeader, data type is uintptr.
-// In this case, Go compiler cannot trace reference created by newArray().
-// So, define using unsafe.Pointer as data type
-type sliceHeader struct {
- data unsafe.Pointer
- len int
- cap int
-}
-
-const (
- defaultSliceCapacity = 2
-)
-
-func newSliceDecoder(dec Decoder, elemType *runtime.Type, size uintptr, structName, fieldName string) *sliceDecoder {
- return &sliceDecoder{
- valueDecoder: dec,
- elemType: elemType,
- isElemPointerType: elemType.Kind() == reflect.Ptr || elemType.Kind() == reflect.Map,
- size: size,
- arrayPool: sync.Pool{
- New: func() interface{} {
- return &sliceHeader{
- data: newArray(elemType, defaultSliceCapacity),
- len: 0,
- cap: defaultSliceCapacity,
- }
- },
- },
- structName: structName,
- fieldName: fieldName,
- }
-}
-
-func (d *sliceDecoder) newSlice(src *sliceHeader) *sliceHeader {
- slice := d.arrayPool.Get().(*sliceHeader)
- if src.len > 0 {
- // copy original elem
- if slice.cap < src.cap {
- data := newArray(d.elemType, src.cap)
- slice = &sliceHeader{data: data, len: src.len, cap: src.cap}
- } else {
- slice.len = src.len
- }
- copySlice(d.elemType, *slice, *src)
- } else {
- slice.len = 0
- }
- return slice
-}
-
-func (d *sliceDecoder) releaseSlice(p *sliceHeader) {
- d.arrayPool.Put(p)
-}
-
-//go:linkname copySlice reflect.typedslicecopy
-func copySlice(elemType *runtime.Type, dst, src sliceHeader) int
-
-//go:linkname newArray reflect.unsafe_NewArray
-func newArray(*runtime.Type, int) unsafe.Pointer
-
-//go:linkname typedmemmove reflect.typedmemmove
-func typedmemmove(t *runtime.Type, dst, src unsafe.Pointer)
-
-func (d *sliceDecoder) errNumber(offset int64) *errors.UnmarshalTypeError {
- return &errors.UnmarshalTypeError{
- Value: "number",
- Type: reflect.SliceOf(runtime.RType2Type(d.elemType)),
- Struct: d.structName,
- Field: d.fieldName,
- Offset: offset,
- }
-}
-
-func (d *sliceDecoder) DecodeStream(s *Stream, depth int64, p unsafe.Pointer) error {
- depth++
- if depth > maxDecodeNestingDepth {
- return errors.ErrExceededMaxDepth(s.char(), s.cursor)
- }
-
- for {
- switch s.char() {
- case ' ', '\n', '\t', '\r':
- s.cursor++
- continue
- case 'n':
- if err := nullBytes(s); err != nil {
- return err
- }
- typedmemmove(sliceType, p, nilSlice)
- return nil
- case '[':
- s.cursor++
- if s.skipWhiteSpace() == ']' {
- dst := (*sliceHeader)(p)
- if dst.data == nil {
- dst.data = newArray(d.elemType, 0)
- } else {
- dst.len = 0
- }
- s.cursor++
- return nil
- }
- idx := 0
- slice := d.newSlice((*sliceHeader)(p))
- srcLen := slice.len
- capacity := slice.cap
- data := slice.data
- for {
- if capacity <= idx {
- src := sliceHeader{data: data, len: idx, cap: capacity}
- capacity *= 2
- data = newArray(d.elemType, capacity)
- dst := sliceHeader{data: data, len: idx, cap: capacity}
- copySlice(d.elemType, dst, src)
- }
- ep := unsafe.Pointer(uintptr(data) + uintptr(idx)*d.size)
-
- // if srcLen is greater than idx, keep the original reference
- if srcLen <= idx {
- if d.isElemPointerType {
- **(**unsafe.Pointer)(unsafe.Pointer(&ep)) = nil // initialize elem pointer
- } else {
- // assign new element to the slice
- typedmemmove(d.elemType, ep, unsafe_New(d.elemType))
- }
- }
-
- if err := d.valueDecoder.DecodeStream(s, depth, ep); err != nil {
- return err
- }
- s.skipWhiteSpace()
- RETRY:
- switch s.char() {
- case ']':
- slice.cap = capacity
- slice.len = idx + 1
- slice.data = data
- dst := (*sliceHeader)(p)
- dst.len = idx + 1
- if dst.len > dst.cap {
- dst.data = newArray(d.elemType, dst.len)
- dst.cap = dst.len
- }
- copySlice(d.elemType, *dst, *slice)
- d.releaseSlice(slice)
- s.cursor++
- return nil
- case ',':
- idx++
- case nul:
- if s.read() {
- goto RETRY
- }
- slice.cap = capacity
- slice.data = data
- d.releaseSlice(slice)
- goto ERROR
- default:
- slice.cap = capacity
- slice.data = data
- d.releaseSlice(slice)
- goto ERROR
- }
- s.cursor++
- }
- case '-', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
- return d.errNumber(s.totalOffset())
- case nul:
- if s.read() {
- continue
- }
- goto ERROR
- default:
- goto ERROR
- }
- }
-ERROR:
- return errors.ErrUnexpectedEndOfJSON("slice", s.totalOffset())
-}
-
-func (d *sliceDecoder) Decode(ctx *RuntimeContext, cursor, depth int64, p unsafe.Pointer) (int64, error) {
- buf := ctx.Buf
- depth++
- if depth > maxDecodeNestingDepth {
- return 0, errors.ErrExceededMaxDepth(buf[cursor], cursor)
- }
-
- for {
- switch buf[cursor] {
- case ' ', '\n', '\t', '\r':
- cursor++
- continue
- case 'n':
- if err := validateNull(buf, cursor); err != nil {
- return 0, err
- }
- cursor += 4
- typedmemmove(sliceType, p, nilSlice)
- return cursor, nil
- case '[':
- cursor++
- cursor = skipWhiteSpace(buf, cursor)
- if buf[cursor] == ']' {
- dst := (*sliceHeader)(p)
- if dst.data == nil {
- dst.data = newArray(d.elemType, 0)
- } else {
- dst.len = 0
- }
- cursor++
- return cursor, nil
- }
- idx := 0
- slice := d.newSlice((*sliceHeader)(p))
- srcLen := slice.len
- capacity := slice.cap
- data := slice.data
- for {
- if capacity <= idx {
- src := sliceHeader{data: data, len: idx, cap: capacity}
- capacity *= 2
- data = newArray(d.elemType, capacity)
- dst := sliceHeader{data: data, len: idx, cap: capacity}
- copySlice(d.elemType, dst, src)
- }
- ep := unsafe.Pointer(uintptr(data) + uintptr(idx)*d.size)
- // if srcLen is greater than idx, keep the original reference
- if srcLen <= idx {
- if d.isElemPointerType {
- **(**unsafe.Pointer)(unsafe.Pointer(&ep)) = nil // initialize elem pointer
- } else {
- // assign new element to the slice
- typedmemmove(d.elemType, ep, unsafe_New(d.elemType))
- }
- }
- c, err := d.valueDecoder.Decode(ctx, cursor, depth, ep)
- if err != nil {
- return 0, err
- }
- cursor = c
- cursor = skipWhiteSpace(buf, cursor)
- switch buf[cursor] {
- case ']':
- slice.cap = capacity
- slice.len = idx + 1
- slice.data = data
- dst := (*sliceHeader)(p)
- dst.len = idx + 1
- if dst.len > dst.cap {
- dst.data = newArray(d.elemType, dst.len)
- dst.cap = dst.len
- }
- copySlice(d.elemType, *dst, *slice)
- d.releaseSlice(slice)
- cursor++
- return cursor, nil
- case ',':
- idx++
- default:
- slice.cap = capacity
- slice.data = data
- d.releaseSlice(slice)
- return 0, errors.ErrInvalidCharacter(buf[cursor], "slice", cursor)
- }
- cursor++
- }
- case '-', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
- return 0, d.errNumber(cursor)
- default:
- return 0, errors.ErrUnexpectedEndOfJSON("slice", cursor)
- }
- }
-}
-
-func (d *sliceDecoder) DecodePath(ctx *RuntimeContext, cursor, depth int64) ([][]byte, int64, error) {
- buf := ctx.Buf
- depth++
- if depth > maxDecodeNestingDepth {
- return nil, 0, errors.ErrExceededMaxDepth(buf[cursor], cursor)
- }
-
- ret := [][]byte{}
- for {
- switch buf[cursor] {
- case ' ', '\n', '\t', '\r':
- cursor++
- continue
- case 'n':
- if err := validateNull(buf, cursor); err != nil {
- return nil, 0, err
- }
- cursor += 4
- return [][]byte{nullbytes}, cursor, nil
- case '[':
- cursor++
- cursor = skipWhiteSpace(buf, cursor)
- if buf[cursor] == ']' {
- cursor++
- return ret, cursor, nil
- }
- idx := 0
- for {
- child, found, err := ctx.Option.Path.node.Index(idx)
- if err != nil {
- return nil, 0, err
- }
- if found {
- if child != nil {
- oldPath := ctx.Option.Path.node
- ctx.Option.Path.node = child
- paths, c, err := d.valueDecoder.DecodePath(ctx, cursor, depth)
- if err != nil {
- return nil, 0, err
- }
- ctx.Option.Path.node = oldPath
- ret = append(ret, paths...)
- cursor = c
- } else {
- start := cursor
- end, err := skipValue(buf, cursor, depth)
- if err != nil {
- return nil, 0, err
- }
- ret = append(ret, buf[start:end])
- cursor = end
- }
- } else {
- c, err := skipValue(buf, cursor, depth)
- if err != nil {
- return nil, 0, err
- }
- cursor = c
- }
- cursor = skipWhiteSpace(buf, cursor)
- switch buf[cursor] {
- case ']':
- cursor++
- return ret, cursor, nil
- case ',':
- idx++
- default:
- return nil, 0, errors.ErrInvalidCharacter(buf[cursor], "slice", cursor)
- }
- cursor++
- }
- case '-', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
- return nil, 0, d.errNumber(cursor)
- default:
- return nil, 0, errors.ErrUnexpectedEndOfJSON("slice", cursor)
- }
- }
-}
diff --git a/vendor/github.com/goccy/go-json/internal/decoder/stream.go b/vendor/github.com/goccy/go-json/internal/decoder/stream.go
deleted file mode 100644
index a383f725..00000000
--- a/vendor/github.com/goccy/go-json/internal/decoder/stream.go
+++ /dev/null
@@ -1,556 +0,0 @@
-package decoder
-
-import (
- "bytes"
- "encoding/json"
- "io"
- "strconv"
- "unsafe"
-
- "github.com/goccy/go-json/internal/errors"
-)
-
-const (
- initBufSize = 512
-)
-
-type Stream struct {
- buf []byte
- bufSize int64
- length int64
- r io.Reader
- offset int64
- cursor int64
- filledBuffer bool
- allRead bool
- UseNumber bool
- DisallowUnknownFields bool
- Option *Option
-}
-
-func NewStream(r io.Reader) *Stream {
- return &Stream{
- r: r,
- bufSize: initBufSize,
- buf: make([]byte, initBufSize),
- Option: &Option{},
- }
-}
-
-func (s *Stream) TotalOffset() int64 {
- return s.totalOffset()
-}
-
-func (s *Stream) Buffered() io.Reader {
- buflen := int64(len(s.buf))
- for i := s.cursor; i < buflen; i++ {
- if s.buf[i] == nul {
- return bytes.NewReader(s.buf[s.cursor:i])
- }
- }
- return bytes.NewReader(s.buf[s.cursor:])
-}
-
-func (s *Stream) PrepareForDecode() error {
- for {
- switch s.char() {
- case ' ', '\t', '\r', '\n':
- s.cursor++
- continue
- case ',', ':':
- s.cursor++
- return nil
- case nul:
- if s.read() {
- continue
- }
- return io.EOF
- }
- break
- }
- return nil
-}
-
-func (s *Stream) totalOffset() int64 {
- return s.offset + s.cursor
-}
-
-func (s *Stream) char() byte {
- return s.buf[s.cursor]
-}
-
-func (s *Stream) equalChar(c byte) bool {
- cur := s.buf[s.cursor]
- if cur == nul {
- s.read()
- cur = s.buf[s.cursor]
- }
- return cur == c
-}
-
-func (s *Stream) stat() ([]byte, int64, unsafe.Pointer) {
- return s.buf, s.cursor, (*sliceHeader)(unsafe.Pointer(&s.buf)).data
-}
-
-func (s *Stream) bufptr() unsafe.Pointer {
- return (*sliceHeader)(unsafe.Pointer(&s.buf)).data
-}
-
-func (s *Stream) statForRetry() ([]byte, int64, unsafe.Pointer) {
- s.cursor-- // for retry ( because caller progress cursor position in each loop )
- return s.buf, s.cursor, (*sliceHeader)(unsafe.Pointer(&s.buf)).data
-}
-
-func (s *Stream) Reset() {
- s.reset()
- s.bufSize = int64(len(s.buf))
-}
-
-func (s *Stream) More() bool {
- for {
- switch s.char() {
- case ' ', '\n', '\r', '\t':
- s.cursor++
- continue
- case '}', ']':
- return false
- case nul:
- if s.read() {
- continue
- }
- return false
- }
- break
- }
- return true
-}
-
-func (s *Stream) Token() (interface{}, error) {
- for {
- c := s.char()
- switch c {
- case ' ', '\n', '\r', '\t':
- s.cursor++
- case '{', '[', ']', '}':
- s.cursor++
- return json.Delim(c), nil
- case ',', ':':
- s.cursor++
- case '-', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
- bytes := floatBytes(s)
- str := *(*string)(unsafe.Pointer(&bytes))
- if s.UseNumber {
- return json.Number(str), nil
- }
- f64, err := strconv.ParseFloat(str, 64)
- if err != nil {
- return nil, err
- }
- return f64, nil
- case '"':
- bytes, err := stringBytes(s)
- if err != nil {
- return nil, err
- }
- return string(bytes), nil
- case 't':
- if err := trueBytes(s); err != nil {
- return nil, err
- }
- return true, nil
- case 'f':
- if err := falseBytes(s); err != nil {
- return nil, err
- }
- return false, nil
- case 'n':
- if err := nullBytes(s); err != nil {
- return nil, err
- }
- return nil, nil
- case nul:
- if s.read() {
- continue
- }
- goto END
- default:
- return nil, errors.ErrInvalidCharacter(s.char(), "token", s.totalOffset())
- }
- }
-END:
- return nil, io.EOF
-}
-
-func (s *Stream) reset() {
- s.offset += s.cursor
- s.buf = s.buf[s.cursor:]
- s.length -= s.cursor
- s.cursor = 0
-}
-
-func (s *Stream) readBuf() []byte {
- if s.filledBuffer {
- s.bufSize *= 2
- remainBuf := s.buf
- s.buf = make([]byte, s.bufSize)
- copy(s.buf, remainBuf)
- }
- remainLen := s.length - s.cursor
- remainNotNulCharNum := int64(0)
- for i := int64(0); i < remainLen; i++ {
- if s.buf[s.cursor+i] == nul {
- break
- }
- remainNotNulCharNum++
- }
- s.length = s.cursor + remainNotNulCharNum
- return s.buf[s.cursor+remainNotNulCharNum:]
-}
-
-func (s *Stream) read() bool {
- if s.allRead {
- return false
- }
- buf := s.readBuf()
- last := len(buf) - 1
- buf[last] = nul
- n, err := s.r.Read(buf[:last])
- s.length += int64(n)
- if n == last {
- s.filledBuffer = true
- } else {
- s.filledBuffer = false
- }
- if err == io.EOF {
- s.allRead = true
- } else if err != nil {
- return false
- }
- return true
-}
-
-func (s *Stream) skipWhiteSpace() byte {
- p := s.bufptr()
-LOOP:
- c := char(p, s.cursor)
- switch c {
- case ' ', '\n', '\t', '\r':
- s.cursor++
- goto LOOP
- case nul:
- if s.read() {
- p = s.bufptr()
- goto LOOP
- }
- }
- return c
-}
-
-func (s *Stream) skipObject(depth int64) error {
- braceCount := 1
- _, cursor, p := s.stat()
- for {
- switch char(p, cursor) {
- case '{':
- braceCount++
- depth++
- if depth > maxDecodeNestingDepth {
- return errors.ErrExceededMaxDepth(s.char(), s.cursor)
- }
- case '}':
- braceCount--
- depth--
- if braceCount == 0 {
- s.cursor = cursor + 1
- return nil
- }
- case '[':
- depth++
- if depth > maxDecodeNestingDepth {
- return errors.ErrExceededMaxDepth(s.char(), s.cursor)
- }
- case ']':
- depth--
- case '"':
- for {
- cursor++
- switch char(p, cursor) {
- case '\\':
- cursor++
- if char(p, cursor) == nul {
- s.cursor = cursor
- if s.read() {
- _, cursor, p = s.stat()
- continue
- }
- return errors.ErrUnexpectedEndOfJSON("string of object", cursor)
- }
- case '"':
- goto SWITCH_OUT
- case nul:
- s.cursor = cursor
- if s.read() {
- _, cursor, p = s.statForRetry()
- continue
- }
- return errors.ErrUnexpectedEndOfJSON("string of object", cursor)
- }
- }
- case nul:
- s.cursor = cursor
- if s.read() {
- _, cursor, p = s.stat()
- continue
- }
- return errors.ErrUnexpectedEndOfJSON("object of object", cursor)
- }
- SWITCH_OUT:
- cursor++
- }
-}
-
-func (s *Stream) skipArray(depth int64) error {
- bracketCount := 1
- _, cursor, p := s.stat()
- for {
- switch char(p, cursor) {
- case '[':
- bracketCount++
- depth++
- if depth > maxDecodeNestingDepth {
- return errors.ErrExceededMaxDepth(s.char(), s.cursor)
- }
- case ']':
- bracketCount--
- depth--
- if bracketCount == 0 {
- s.cursor = cursor + 1
- return nil
- }
- case '{':
- depth++
- if depth > maxDecodeNestingDepth {
- return errors.ErrExceededMaxDepth(s.char(), s.cursor)
- }
- case '}':
- depth--
- case '"':
- for {
- cursor++
- switch char(p, cursor) {
- case '\\':
- cursor++
- if char(p, cursor) == nul {
- s.cursor = cursor
- if s.read() {
- _, cursor, p = s.stat()
- continue
- }
- return errors.ErrUnexpectedEndOfJSON("string of object", cursor)
- }
- case '"':
- goto SWITCH_OUT
- case nul:
- s.cursor = cursor
- if s.read() {
- _, cursor, p = s.statForRetry()
- continue
- }
- return errors.ErrUnexpectedEndOfJSON("string of object", cursor)
- }
- }
- case nul:
- s.cursor = cursor
- if s.read() {
- _, cursor, p = s.stat()
- continue
- }
- return errors.ErrUnexpectedEndOfJSON("array of object", cursor)
- }
- SWITCH_OUT:
- cursor++
- }
-}
-
-func (s *Stream) skipValue(depth int64) error {
- _, cursor, p := s.stat()
- for {
- switch char(p, cursor) {
- case ' ', '\n', '\t', '\r':
- cursor++
- continue
- case nul:
- s.cursor = cursor
- if s.read() {
- _, cursor, p = s.stat()
- continue
- }
- return errors.ErrUnexpectedEndOfJSON("value of object", s.totalOffset())
- case '{':
- s.cursor = cursor + 1
- return s.skipObject(depth + 1)
- case '[':
- s.cursor = cursor + 1
- return s.skipArray(depth + 1)
- case '"':
- for {
- cursor++
- switch char(p, cursor) {
- case '\\':
- cursor++
- if char(p, cursor) == nul {
- s.cursor = cursor
- if s.read() {
- _, cursor, p = s.stat()
- continue
- }
- return errors.ErrUnexpectedEndOfJSON("value of string", s.totalOffset())
- }
- case '"':
- s.cursor = cursor + 1
- return nil
- case nul:
- s.cursor = cursor
- if s.read() {
- _, cursor, p = s.statForRetry()
- continue
- }
- return errors.ErrUnexpectedEndOfJSON("value of string", s.totalOffset())
- }
- }
- case '-', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
- for {
- cursor++
- c := char(p, cursor)
- if floatTable[c] {
- continue
- } else if c == nul {
- if s.read() {
- _, cursor, p = s.stat()
- continue
- }
- }
- s.cursor = cursor
- return nil
- }
- case 't':
- s.cursor = cursor
- if err := trueBytes(s); err != nil {
- return err
- }
- return nil
- case 'f':
- s.cursor = cursor
- if err := falseBytes(s); err != nil {
- return err
- }
- return nil
- case 'n':
- s.cursor = cursor
- if err := nullBytes(s); err != nil {
- return err
- }
- return nil
- }
- cursor++
- }
-}
-
-func nullBytes(s *Stream) error {
- // current cursor's character is 'n'
- s.cursor++
- if s.char() != 'u' {
- if err := retryReadNull(s); err != nil {
- return err
- }
- }
- s.cursor++
- if s.char() != 'l' {
- if err := retryReadNull(s); err != nil {
- return err
- }
- }
- s.cursor++
- if s.char() != 'l' {
- if err := retryReadNull(s); err != nil {
- return err
- }
- }
- s.cursor++
- return nil
-}
-
-func retryReadNull(s *Stream) error {
- if s.char() == nul && s.read() {
- return nil
- }
- return errors.ErrInvalidCharacter(s.char(), "null", s.totalOffset())
-}
-
-func trueBytes(s *Stream) error {
- // current cursor's character is 't'
- s.cursor++
- if s.char() != 'r' {
- if err := retryReadTrue(s); err != nil {
- return err
- }
- }
- s.cursor++
- if s.char() != 'u' {
- if err := retryReadTrue(s); err != nil {
- return err
- }
- }
- s.cursor++
- if s.char() != 'e' {
- if err := retryReadTrue(s); err != nil {
- return err
- }
- }
- s.cursor++
- return nil
-}
-
-func retryReadTrue(s *Stream) error {
- if s.char() == nul && s.read() {
- return nil
- }
- return errors.ErrInvalidCharacter(s.char(), "bool(true)", s.totalOffset())
-}
-
-func falseBytes(s *Stream) error {
- // current cursor's character is 'f'
- s.cursor++
- if s.char() != 'a' {
- if err := retryReadFalse(s); err != nil {
- return err
- }
- }
- s.cursor++
- if s.char() != 'l' {
- if err := retryReadFalse(s); err != nil {
- return err
- }
- }
- s.cursor++
- if s.char() != 's' {
- if err := retryReadFalse(s); err != nil {
- return err
- }
- }
- s.cursor++
- if s.char() != 'e' {
- if err := retryReadFalse(s); err != nil {
- return err
- }
- }
- s.cursor++
- return nil
-}
-
-func retryReadFalse(s *Stream) error {
- if s.char() == nul && s.read() {
- return nil
- }
- return errors.ErrInvalidCharacter(s.char(), "bool(false)", s.totalOffset())
-}
diff --git a/vendor/github.com/goccy/go-json/internal/decoder/string.go b/vendor/github.com/goccy/go-json/internal/decoder/string.go
deleted file mode 100644
index 32602c90..00000000
--- a/vendor/github.com/goccy/go-json/internal/decoder/string.go
+++ /dev/null
@@ -1,452 +0,0 @@
-package decoder
-
-import (
- "bytes"
- "fmt"
- "reflect"
- "unicode"
- "unicode/utf16"
- "unicode/utf8"
- "unsafe"
-
- "github.com/goccy/go-json/internal/errors"
-)
-
-type stringDecoder struct {
- structName string
- fieldName string
-}
-
-func newStringDecoder(structName, fieldName string) *stringDecoder {
- return &stringDecoder{
- structName: structName,
- fieldName: fieldName,
- }
-}
-
-func (d *stringDecoder) errUnmarshalType(typeName string, offset int64) *errors.UnmarshalTypeError {
- return &errors.UnmarshalTypeError{
- Value: typeName,
- Type: reflect.TypeOf(""),
- Offset: offset,
- Struct: d.structName,
- Field: d.fieldName,
- }
-}
-
-func (d *stringDecoder) DecodeStream(s *Stream, depth int64, p unsafe.Pointer) error {
- bytes, err := d.decodeStreamByte(s)
- if err != nil {
- return err
- }
- if bytes == nil {
- return nil
- }
- **(**string)(unsafe.Pointer(&p)) = *(*string)(unsafe.Pointer(&bytes))
- s.reset()
- return nil
-}
-
-func (d *stringDecoder) Decode(ctx *RuntimeContext, cursor, depth int64, p unsafe.Pointer) (int64, error) {
- bytes, c, err := d.decodeByte(ctx.Buf, cursor)
- if err != nil {
- return 0, err
- }
- if bytes == nil {
- return c, nil
- }
- cursor = c
- **(**string)(unsafe.Pointer(&p)) = *(*string)(unsafe.Pointer(&bytes))
- return cursor, nil
-}
-
-func (d *stringDecoder) DecodePath(ctx *RuntimeContext, cursor, depth int64) ([][]byte, int64, error) {
- bytes, c, err := d.decodeByte(ctx.Buf, cursor)
- if err != nil {
- return nil, 0, err
- }
- if bytes == nil {
- return [][]byte{nullbytes}, c, nil
- }
- return [][]byte{bytes}, c, nil
-}
-
-var (
- hexToInt = [256]int{
- '0': 0,
- '1': 1,
- '2': 2,
- '3': 3,
- '4': 4,
- '5': 5,
- '6': 6,
- '7': 7,
- '8': 8,
- '9': 9,
- 'A': 10,
- 'B': 11,
- 'C': 12,
- 'D': 13,
- 'E': 14,
- 'F': 15,
- 'a': 10,
- 'b': 11,
- 'c': 12,
- 'd': 13,
- 'e': 14,
- 'f': 15,
- }
-)
-
-func unicodeToRune(code []byte) rune {
- var r rune
- for i := 0; i < len(code); i++ {
- r = r*16 + rune(hexToInt[code[i]])
- }
- return r
-}
-
-func readAtLeast(s *Stream, n int64, p *unsafe.Pointer) bool {
- for s.cursor+n >= s.length {
- if !s.read() {
- return false
- }
- *p = s.bufptr()
- }
- return true
-}
-
-func decodeUnicodeRune(s *Stream, p unsafe.Pointer) (rune, int64, unsafe.Pointer, error) {
- const defaultOffset = 5
- const surrogateOffset = 11
-
- if !readAtLeast(s, defaultOffset, &p) {
- return rune(0), 0, nil, errors.ErrInvalidCharacter(s.char(), "escaped string", s.totalOffset())
- }
-
- r := unicodeToRune(s.buf[s.cursor+1 : s.cursor+defaultOffset])
- if utf16.IsSurrogate(r) {
- if !readAtLeast(s, surrogateOffset, &p) {
- return unicode.ReplacementChar, defaultOffset, p, nil
- }
- if s.buf[s.cursor+defaultOffset] != '\\' || s.buf[s.cursor+defaultOffset+1] != 'u' {
- return unicode.ReplacementChar, defaultOffset, p, nil
- }
- r2 := unicodeToRune(s.buf[s.cursor+defaultOffset+2 : s.cursor+surrogateOffset])
- if r := utf16.DecodeRune(r, r2); r != unicode.ReplacementChar {
- return r, surrogateOffset, p, nil
- }
- }
- return r, defaultOffset, p, nil
-}
-
-func decodeUnicode(s *Stream, p unsafe.Pointer) (unsafe.Pointer, error) {
- const backSlashAndULen = 2 // length of \u
-
- r, offset, pp, err := decodeUnicodeRune(s, p)
- if err != nil {
- return nil, err
- }
- unicode := []byte(string(r))
- unicodeLen := int64(len(unicode))
- s.buf = append(append(s.buf[:s.cursor-1], unicode...), s.buf[s.cursor+offset:]...)
- unicodeOrgLen := offset - 1
- s.length = s.length - (backSlashAndULen + (unicodeOrgLen - unicodeLen))
- s.cursor = s.cursor - backSlashAndULen + unicodeLen
- return pp, nil
-}
-
-func decodeEscapeString(s *Stream, p unsafe.Pointer) (unsafe.Pointer, error) {
- s.cursor++
-RETRY:
- switch s.buf[s.cursor] {
- case '"':
- s.buf[s.cursor] = '"'
- case '\\':
- s.buf[s.cursor] = '\\'
- case '/':
- s.buf[s.cursor] = '/'
- case 'b':
- s.buf[s.cursor] = '\b'
- case 'f':
- s.buf[s.cursor] = '\f'
- case 'n':
- s.buf[s.cursor] = '\n'
- case 'r':
- s.buf[s.cursor] = '\r'
- case 't':
- s.buf[s.cursor] = '\t'
- case 'u':
- return decodeUnicode(s, p)
- case nul:
- if !s.read() {
- return nil, errors.ErrInvalidCharacter(s.char(), "escaped string", s.totalOffset())
- }
- p = s.bufptr()
- goto RETRY
- default:
- return nil, errors.ErrUnexpectedEndOfJSON("string", s.totalOffset())
- }
- s.buf = append(s.buf[:s.cursor-1], s.buf[s.cursor:]...)
- s.length--
- s.cursor--
- p = s.bufptr()
- return p, nil
-}
-
-var (
- runeErrBytes = []byte(string(utf8.RuneError))
- runeErrBytesLen = int64(len(runeErrBytes))
-)
-
-func stringBytes(s *Stream) ([]byte, error) {
- _, cursor, p := s.stat()
- cursor++ // skip double quote char
- start := cursor
- for {
- switch char(p, cursor) {
- case '\\':
- s.cursor = cursor
- pp, err := decodeEscapeString(s, p)
- if err != nil {
- return nil, err
- }
- p = pp
- cursor = s.cursor
- case '"':
- literal := s.buf[start:cursor]
- cursor++
- s.cursor = cursor
- return literal, nil
- case
- // 0x00 is nul, 0x5c is '\\', 0x22 is '"' .
- 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, // 0x00-0x0F
- 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, // 0x10-0x1F
- 0x20, 0x21 /*0x22,*/, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F, // 0x20-0x2F
- 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0x3F, // 0x30-0x3F
- 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F, // 0x40-0x4F
- 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x5B /*0x5C,*/, 0x5D, 0x5E, 0x5F, // 0x50-0x5F
- 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F, // 0x60-0x6F
- 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x7B, 0x7C, 0x7D, 0x7E, 0x7F: // 0x70-0x7F
- // character is ASCII. skip to next char
- case
- 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F, // 0x80-0x8F
- 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9A, 0x9B, 0x9C, 0x9D, 0x9E, 0x9F, // 0x90-0x9F
- 0xA0, 0xA1, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8, 0xA9, 0xAA, 0xAB, 0xAC, 0xAD, 0xAE, 0xAF, // 0xA0-0xAF
- 0xB0, 0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA, 0xBB, 0xBC, 0xBD, 0xBE, 0xBF, // 0xB0-0xBF
- 0xC0, 0xC1, // 0xC0-0xC1
- 0xF5, 0xF6, 0xF7, 0xF8, 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE, 0xFF: // 0xF5-0xFE
- // character is invalid
- s.buf = append(append(append([]byte{}, s.buf[:cursor]...), runeErrBytes...), s.buf[cursor+1:]...)
- _, _, p = s.stat()
- cursor += runeErrBytesLen
- s.length += runeErrBytesLen
- continue
- case nul:
- s.cursor = cursor
- if s.read() {
- _, cursor, p = s.stat()
- continue
- }
- goto ERROR
- case 0xEF:
- // RuneError is {0xEF, 0xBF, 0xBD}
- if s.buf[cursor+1] == 0xBF && s.buf[cursor+2] == 0xBD {
- // found RuneError: skip
- cursor += 2
- break
- }
- fallthrough
- default:
- // multi bytes character
- if !utf8.FullRune(s.buf[cursor : len(s.buf)-1]) {
- s.cursor = cursor
- if s.read() {
- _, cursor, p = s.stat()
- continue
- }
- goto ERROR
- }
- r, size := utf8.DecodeRune(s.buf[cursor:])
- if r == utf8.RuneError {
- s.buf = append(append(append([]byte{}, s.buf[:cursor]...), runeErrBytes...), s.buf[cursor+1:]...)
- cursor += runeErrBytesLen
- s.length += runeErrBytesLen
- _, _, p = s.stat()
- } else {
- cursor += int64(size)
- }
- continue
- }
- cursor++
- }
-ERROR:
- return nil, errors.ErrUnexpectedEndOfJSON("string", s.totalOffset())
-}
-
-func (d *stringDecoder) decodeStreamByte(s *Stream) ([]byte, error) {
- for {
- switch s.char() {
- case ' ', '\n', '\t', '\r':
- s.cursor++
- continue
- case '[':
- return nil, d.errUnmarshalType("array", s.totalOffset())
- case '{':
- return nil, d.errUnmarshalType("object", s.totalOffset())
- case '-', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
- return nil, d.errUnmarshalType("number", s.totalOffset())
- case '"':
- return stringBytes(s)
- case 'n':
- if err := nullBytes(s); err != nil {
- return nil, err
- }
- return nil, nil
- case nul:
- if s.read() {
- continue
- }
- }
- break
- }
- return nil, errors.ErrInvalidBeginningOfValue(s.char(), s.totalOffset())
-}
-
-func (d *stringDecoder) decodeByte(buf []byte, cursor int64) ([]byte, int64, error) {
- for {
- switch buf[cursor] {
- case ' ', '\n', '\t', '\r':
- cursor++
- case '[':
- return nil, 0, d.errUnmarshalType("array", cursor)
- case '{':
- return nil, 0, d.errUnmarshalType("object", cursor)
- case '-', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
- return nil, 0, d.errUnmarshalType("number", cursor)
- case '"':
- cursor++
- start := cursor
- b := (*sliceHeader)(unsafe.Pointer(&buf)).data
- escaped := 0
- for {
- switch char(b, cursor) {
- case '\\':
- escaped++
- cursor++
- switch char(b, cursor) {
- case '"', '\\', '/', 'b', 'f', 'n', 'r', 't':
- cursor++
- case 'u':
- buflen := int64(len(buf))
- if cursor+5 >= buflen {
- return nil, 0, errors.ErrUnexpectedEndOfJSON("escaped string", cursor)
- }
- for i := int64(1); i <= 4; i++ {
- c := char(b, cursor+i)
- if !(('0' <= c && c <= '9') || ('a' <= c && c <= 'f') || ('A' <= c && c <= 'F')) {
- return nil, 0, errors.ErrSyntax(fmt.Sprintf("json: invalid character %c in \\u hexadecimal character escape", c), cursor+i)
- }
- }
- cursor += 5
- default:
- return nil, 0, errors.ErrUnexpectedEndOfJSON("escaped string", cursor)
- }
- continue
- case '"':
- literal := buf[start:cursor]
- if escaped > 0 {
- literal = literal[:unescapeString(literal)]
- }
- cursor++
- return literal, cursor, nil
- case nul:
- return nil, 0, errors.ErrUnexpectedEndOfJSON("string", cursor)
- }
- cursor++
- }
- case 'n':
- if err := validateNull(buf, cursor); err != nil {
- return nil, 0, err
- }
- cursor += 4
- return nil, cursor, nil
- default:
- return nil, 0, errors.ErrInvalidBeginningOfValue(buf[cursor], cursor)
- }
- }
-}
-
-var unescapeMap = [256]byte{
- '"': '"',
- '\\': '\\',
- '/': '/',
- 'b': '\b',
- 'f': '\f',
- 'n': '\n',
- 'r': '\r',
- 't': '\t',
-}
-
-func unsafeAdd(ptr unsafe.Pointer, offset int) unsafe.Pointer {
- return unsafe.Pointer(uintptr(ptr) + uintptr(offset))
-}
-
-func unescapeString(buf []byte) int {
- p := (*sliceHeader)(unsafe.Pointer(&buf)).data
- end := unsafeAdd(p, len(buf))
- src := unsafeAdd(p, bytes.IndexByte(buf, '\\'))
- dst := src
- for src != end {
- c := char(src, 0)
- if c == '\\' {
- escapeChar := char(src, 1)
- if escapeChar != 'u' {
- *(*byte)(dst) = unescapeMap[escapeChar]
- src = unsafeAdd(src, 2)
- dst = unsafeAdd(dst, 1)
- } else {
- v1 := hexToInt[char(src, 2)]
- v2 := hexToInt[char(src, 3)]
- v3 := hexToInt[char(src, 4)]
- v4 := hexToInt[char(src, 5)]
- code := rune((v1 << 12) | (v2 << 8) | (v3 << 4) | v4)
- if code >= 0xd800 && code < 0xdc00 && uintptr(unsafeAdd(src, 11)) < uintptr(end) {
- if char(src, 6) == '\\' && char(src, 7) == 'u' {
- v1 := hexToInt[char(src, 8)]
- v2 := hexToInt[char(src, 9)]
- v3 := hexToInt[char(src, 10)]
- v4 := hexToInt[char(src, 11)]
- lo := rune((v1 << 12) | (v2 << 8) | (v3 << 4) | v4)
- if lo >= 0xdc00 && lo < 0xe000 {
- code = (code-0xd800)<<10 | (lo - 0xdc00) + 0x10000
- src = unsafeAdd(src, 6)
- }
- }
- }
- var b [utf8.UTFMax]byte
- n := utf8.EncodeRune(b[:], code)
- switch n {
- case 4:
- *(*byte)(unsafeAdd(dst, 3)) = b[3]
- fallthrough
- case 3:
- *(*byte)(unsafeAdd(dst, 2)) = b[2]
- fallthrough
- case 2:
- *(*byte)(unsafeAdd(dst, 1)) = b[1]
- fallthrough
- case 1:
- *(*byte)(unsafeAdd(dst, 0)) = b[0]
- }
- src = unsafeAdd(src, 6)
- dst = unsafeAdd(dst, n)
- }
- } else {
- *(*byte)(dst) = c
- src = unsafeAdd(src, 1)
- dst = unsafeAdd(dst, 1)
- }
- }
- return int(uintptr(dst) - uintptr(p))
-}
diff --git a/vendor/github.com/goccy/go-json/internal/decoder/struct.go b/vendor/github.com/goccy/go-json/internal/decoder/struct.go
deleted file mode 100644
index 313da153..00000000
--- a/vendor/github.com/goccy/go-json/internal/decoder/struct.go
+++ /dev/null
@@ -1,845 +0,0 @@
-package decoder
-
-import (
- "fmt"
- "math"
- "math/bits"
- "sort"
- "strings"
- "unicode"
- "unicode/utf16"
- "unsafe"
-
- "github.com/goccy/go-json/internal/errors"
-)
-
-type structFieldSet struct {
- dec Decoder
- offset uintptr
- isTaggedKey bool
- fieldIdx int
- key string
- keyLen int64
- err error
-}
-
-type structDecoder struct {
- fieldMap map[string]*structFieldSet
- fieldUniqueNameNum int
- stringDecoder *stringDecoder
- structName string
- fieldName string
- isTriedOptimize bool
- keyBitmapUint8 [][256]uint8
- keyBitmapUint16 [][256]uint16
- sortedFieldSets []*structFieldSet
- keyDecoder func(*structDecoder, []byte, int64) (int64, *structFieldSet, error)
- keyStreamDecoder func(*structDecoder, *Stream) (*structFieldSet, string, error)
-}
-
-var (
- largeToSmallTable [256]byte
-)
-
-func init() {
- for i := 0; i < 256; i++ {
- c := i
- if 'A' <= c && c <= 'Z' {
- c += 'a' - 'A'
- }
- largeToSmallTable[i] = byte(c)
- }
-}
-
-func toASCIILower(s string) string {
- b := []byte(s)
- for i := range b {
- b[i] = largeToSmallTable[b[i]]
- }
- return string(b)
-}
-
-func newStructDecoder(structName, fieldName string, fieldMap map[string]*structFieldSet) *structDecoder {
- return &structDecoder{
- fieldMap: fieldMap,
- stringDecoder: newStringDecoder(structName, fieldName),
- structName: structName,
- fieldName: fieldName,
- keyDecoder: decodeKey,
- keyStreamDecoder: decodeKeyStream,
- }
-}
-
-const (
- allowOptimizeMaxKeyLen = 64
- allowOptimizeMaxFieldLen = 16
-)
-
-func (d *structDecoder) tryOptimize() {
- fieldUniqueNameMap := map[string]int{}
- fieldIdx := -1
- for k, v := range d.fieldMap {
- lower := strings.ToLower(k)
- idx, exists := fieldUniqueNameMap[lower]
- if exists {
- v.fieldIdx = idx
- } else {
- fieldIdx++
- v.fieldIdx = fieldIdx
- }
- fieldUniqueNameMap[lower] = fieldIdx
- }
- d.fieldUniqueNameNum = len(fieldUniqueNameMap)
-
- if d.isTriedOptimize {
- return
- }
- fieldMap := map[string]*structFieldSet{}
- conflicted := map[string]struct{}{}
- for k, v := range d.fieldMap {
- key := strings.ToLower(k)
- if key != k {
- if key != toASCIILower(k) {
- d.isTriedOptimize = true
- return
- }
- // already exists same key (e.g. Hello and HELLO has same lower case key
- if _, exists := conflicted[key]; exists {
- d.isTriedOptimize = true
- return
- }
- conflicted[key] = struct{}{}
- }
- if field, exists := fieldMap[key]; exists {
- if field != v {
- d.isTriedOptimize = true
- return
- }
- }
- fieldMap[key] = v
- }
-
- if len(fieldMap) > allowOptimizeMaxFieldLen {
- d.isTriedOptimize = true
- return
- }
-
- var maxKeyLen int
- sortedKeys := []string{}
- for key := range fieldMap {
- keyLen := len(key)
- if keyLen > allowOptimizeMaxKeyLen {
- d.isTriedOptimize = true
- return
- }
- if maxKeyLen < keyLen {
- maxKeyLen = keyLen
- }
- sortedKeys = append(sortedKeys, key)
- }
- sort.Strings(sortedKeys)
-
- // By allocating one extra capacity than `maxKeyLen`,
- // it is possible to avoid the process of comparing the index of the key with the length of the bitmap each time.
- bitmapLen := maxKeyLen + 1
- if len(sortedKeys) <= 8 {
- keyBitmap := make([][256]uint8, bitmapLen)
- for i, key := range sortedKeys {
- for j := 0; j < len(key); j++ {
- c := key[j]
- keyBitmap[j][c] |= (1 << uint(i))
- }
- d.sortedFieldSets = append(d.sortedFieldSets, fieldMap[key])
- }
- d.keyBitmapUint8 = keyBitmap
- d.keyDecoder = decodeKeyByBitmapUint8
- d.keyStreamDecoder = decodeKeyByBitmapUint8Stream
- } else {
- keyBitmap := make([][256]uint16, bitmapLen)
- for i, key := range sortedKeys {
- for j := 0; j < len(key); j++ {
- c := key[j]
- keyBitmap[j][c] |= (1 << uint(i))
- }
- d.sortedFieldSets = append(d.sortedFieldSets, fieldMap[key])
- }
- d.keyBitmapUint16 = keyBitmap
- d.keyDecoder = decodeKeyByBitmapUint16
- d.keyStreamDecoder = decodeKeyByBitmapUint16Stream
- }
-}
-
-// decode from '\uXXXX'
-func decodeKeyCharByUnicodeRune(buf []byte, cursor int64) ([]byte, int64, error) {
- const defaultOffset = 4
- const surrogateOffset = 6
-
- if cursor+defaultOffset >= int64(len(buf)) {
- return nil, 0, errors.ErrUnexpectedEndOfJSON("escaped string", cursor)
- }
-
- r := unicodeToRune(buf[cursor : cursor+defaultOffset])
- if utf16.IsSurrogate(r) {
- cursor += defaultOffset
- if cursor+surrogateOffset >= int64(len(buf)) || buf[cursor] != '\\' || buf[cursor+1] != 'u' {
- return []byte(string(unicode.ReplacementChar)), cursor + defaultOffset - 1, nil
- }
- cursor += 2
- r2 := unicodeToRune(buf[cursor : cursor+defaultOffset])
- if r := utf16.DecodeRune(r, r2); r != unicode.ReplacementChar {
- return []byte(string(r)), cursor + defaultOffset - 1, nil
- }
- }
- return []byte(string(r)), cursor + defaultOffset - 1, nil
-}
-
-func decodeKeyCharByEscapedChar(buf []byte, cursor int64) ([]byte, int64, error) {
- c := buf[cursor]
- cursor++
- switch c {
- case '"':
- return []byte{'"'}, cursor, nil
- case '\\':
- return []byte{'\\'}, cursor, nil
- case '/':
- return []byte{'/'}, cursor, nil
- case 'b':
- return []byte{'\b'}, cursor, nil
- case 'f':
- return []byte{'\f'}, cursor, nil
- case 'n':
- return []byte{'\n'}, cursor, nil
- case 'r':
- return []byte{'\r'}, cursor, nil
- case 't':
- return []byte{'\t'}, cursor, nil
- case 'u':
- return decodeKeyCharByUnicodeRune(buf, cursor)
- }
- return nil, cursor, nil
-}
-
-func decodeKeyByBitmapUint8(d *structDecoder, buf []byte, cursor int64) (int64, *structFieldSet, error) {
- var (
- curBit uint8 = math.MaxUint8
- )
- b := (*sliceHeader)(unsafe.Pointer(&buf)).data
- for {
- switch char(b, cursor) {
- case ' ', '\n', '\t', '\r':
- cursor++
- case '"':
- cursor++
- c := char(b, cursor)
- switch c {
- case '"':
- cursor++
- return cursor, nil, nil
- case nul:
- return 0, nil, errors.ErrUnexpectedEndOfJSON("string", cursor)
- }
- keyIdx := 0
- bitmap := d.keyBitmapUint8
- start := cursor
- for {
- c := char(b, cursor)
- switch c {
- case '"':
- fieldSetIndex := bits.TrailingZeros8(curBit)
- field := d.sortedFieldSets[fieldSetIndex]
- keyLen := cursor - start
- cursor++
- if keyLen < field.keyLen {
- // early match
- return cursor, nil, nil
- }
- return cursor, field, nil
- case nul:
- return 0, nil, errors.ErrUnexpectedEndOfJSON("string", cursor)
- case '\\':
- cursor++
- chars, nextCursor, err := decodeKeyCharByEscapedChar(buf, cursor)
- if err != nil {
- return 0, nil, err
- }
- for _, c := range chars {
- curBit &= bitmap[keyIdx][largeToSmallTable[c]]
- if curBit == 0 {
- return decodeKeyNotFound(b, cursor)
- }
- keyIdx++
- }
- cursor = nextCursor
- default:
- curBit &= bitmap[keyIdx][largeToSmallTable[c]]
- if curBit == 0 {
- return decodeKeyNotFound(b, cursor)
- }
- keyIdx++
- }
- cursor++
- }
- default:
- return cursor, nil, errors.ErrInvalidBeginningOfValue(char(b, cursor), cursor)
- }
- }
-}
-
-func decodeKeyByBitmapUint16(d *structDecoder, buf []byte, cursor int64) (int64, *structFieldSet, error) {
- var (
- curBit uint16 = math.MaxUint16
- )
- b := (*sliceHeader)(unsafe.Pointer(&buf)).data
- for {
- switch char(b, cursor) {
- case ' ', '\n', '\t', '\r':
- cursor++
- case '"':
- cursor++
- c := char(b, cursor)
- switch c {
- case '"':
- cursor++
- return cursor, nil, nil
- case nul:
- return 0, nil, errors.ErrUnexpectedEndOfJSON("string", cursor)
- }
- keyIdx := 0
- bitmap := d.keyBitmapUint16
- start := cursor
- for {
- c := char(b, cursor)
- switch c {
- case '"':
- fieldSetIndex := bits.TrailingZeros16(curBit)
- field := d.sortedFieldSets[fieldSetIndex]
- keyLen := cursor - start
- cursor++
- if keyLen < field.keyLen {
- // early match
- return cursor, nil, nil
- }
- return cursor, field, nil
- case nul:
- return 0, nil, errors.ErrUnexpectedEndOfJSON("string", cursor)
- case '\\':
- cursor++
- chars, nextCursor, err := decodeKeyCharByEscapedChar(buf, cursor)
- if err != nil {
- return 0, nil, err
- }
- for _, c := range chars {
- curBit &= bitmap[keyIdx][largeToSmallTable[c]]
- if curBit == 0 {
- return decodeKeyNotFound(b, cursor)
- }
- keyIdx++
- }
- cursor = nextCursor
- default:
- curBit &= bitmap[keyIdx][largeToSmallTable[c]]
- if curBit == 0 {
- return decodeKeyNotFound(b, cursor)
- }
- keyIdx++
- }
- cursor++
- }
- default:
- return cursor, nil, errors.ErrInvalidBeginningOfValue(char(b, cursor), cursor)
- }
- }
-}
-
-func decodeKeyNotFound(b unsafe.Pointer, cursor int64) (int64, *structFieldSet, error) {
- for {
- cursor++
- switch char(b, cursor) {
- case '"':
- cursor++
- return cursor, nil, nil
- case '\\':
- cursor++
- if char(b, cursor) == nul {
- return 0, nil, errors.ErrUnexpectedEndOfJSON("string", cursor)
- }
- case nul:
- return 0, nil, errors.ErrUnexpectedEndOfJSON("string", cursor)
- }
- }
-}
-
-func decodeKey(d *structDecoder, buf []byte, cursor int64) (int64, *structFieldSet, error) {
- key, c, err := d.stringDecoder.decodeByte(buf, cursor)
- if err != nil {
- return 0, nil, err
- }
- cursor = c
- k := *(*string)(unsafe.Pointer(&key))
- field, exists := d.fieldMap[k]
- if !exists {
- return cursor, nil, nil
- }
- return cursor, field, nil
-}
-
-func decodeKeyByBitmapUint8Stream(d *structDecoder, s *Stream) (*structFieldSet, string, error) {
- var (
- curBit uint8 = math.MaxUint8
- )
- _, cursor, p := s.stat()
- for {
- switch char(p, cursor) {
- case ' ', '\n', '\t', '\r':
- cursor++
- case nul:
- s.cursor = cursor
- if s.read() {
- _, cursor, p = s.stat()
- continue
- }
- return nil, "", errors.ErrInvalidBeginningOfValue(char(p, cursor), s.totalOffset())
- case '"':
- cursor++
- FIRST_CHAR:
- start := cursor
- switch char(p, cursor) {
- case '"':
- cursor++
- s.cursor = cursor
- return nil, "", nil
- case nul:
- s.cursor = cursor
- if s.read() {
- _, cursor, p = s.stat()
- goto FIRST_CHAR
- }
- return nil, "", errors.ErrUnexpectedEndOfJSON("string", s.totalOffset())
- }
- keyIdx := 0
- bitmap := d.keyBitmapUint8
- for {
- c := char(p, cursor)
- switch c {
- case '"':
- fieldSetIndex := bits.TrailingZeros8(curBit)
- field := d.sortedFieldSets[fieldSetIndex]
- keyLen := cursor - start
- cursor++
- s.cursor = cursor
- if keyLen < field.keyLen {
- // early match
- return nil, field.key, nil
- }
- return field, field.key, nil
- case nul:
- s.cursor = cursor
- if s.read() {
- _, cursor, p = s.stat()
- continue
- }
- return nil, "", errors.ErrUnexpectedEndOfJSON("string", s.totalOffset())
- case '\\':
- s.cursor = cursor + 1 // skip '\' char
- chars, err := decodeKeyCharByEscapeCharStream(s)
- if err != nil {
- return nil, "", err
- }
- cursor = s.cursor
- for _, c := range chars {
- curBit &= bitmap[keyIdx][largeToSmallTable[c]]
- if curBit == 0 {
- s.cursor = cursor
- return decodeKeyNotFoundStream(s, start)
- }
- keyIdx++
- }
- default:
- curBit &= bitmap[keyIdx][largeToSmallTable[c]]
- if curBit == 0 {
- s.cursor = cursor
- return decodeKeyNotFoundStream(s, start)
- }
- keyIdx++
- }
- cursor++
- }
- default:
- return nil, "", errors.ErrInvalidBeginningOfValue(char(p, cursor), s.totalOffset())
- }
- }
-}
-
-func decodeKeyByBitmapUint16Stream(d *structDecoder, s *Stream) (*structFieldSet, string, error) {
- var (
- curBit uint16 = math.MaxUint16
- )
- _, cursor, p := s.stat()
- for {
- switch char(p, cursor) {
- case ' ', '\n', '\t', '\r':
- cursor++
- case nul:
- s.cursor = cursor
- if s.read() {
- _, cursor, p = s.stat()
- continue
- }
- return nil, "", errors.ErrInvalidBeginningOfValue(char(p, cursor), s.totalOffset())
- case '"':
- cursor++
- FIRST_CHAR:
- start := cursor
- switch char(p, cursor) {
- case '"':
- cursor++
- s.cursor = cursor
- return nil, "", nil
- case nul:
- s.cursor = cursor
- if s.read() {
- _, cursor, p = s.stat()
- goto FIRST_CHAR
- }
- return nil, "", errors.ErrUnexpectedEndOfJSON("string", s.totalOffset())
- }
- keyIdx := 0
- bitmap := d.keyBitmapUint16
- for {
- c := char(p, cursor)
- switch c {
- case '"':
- fieldSetIndex := bits.TrailingZeros16(curBit)
- field := d.sortedFieldSets[fieldSetIndex]
- keyLen := cursor - start
- cursor++
- s.cursor = cursor
- if keyLen < field.keyLen {
- // early match
- return nil, field.key, nil
- }
- return field, field.key, nil
- case nul:
- s.cursor = cursor
- if s.read() {
- _, cursor, p = s.stat()
- continue
- }
- return nil, "", errors.ErrUnexpectedEndOfJSON("string", s.totalOffset())
- case '\\':
- s.cursor = cursor + 1 // skip '\' char
- chars, err := decodeKeyCharByEscapeCharStream(s)
- if err != nil {
- return nil, "", err
- }
- cursor = s.cursor
- for _, c := range chars {
- curBit &= bitmap[keyIdx][largeToSmallTable[c]]
- if curBit == 0 {
- s.cursor = cursor
- return decodeKeyNotFoundStream(s, start)
- }
- keyIdx++
- }
- default:
- curBit &= bitmap[keyIdx][largeToSmallTable[c]]
- if curBit == 0 {
- s.cursor = cursor
- return decodeKeyNotFoundStream(s, start)
- }
- keyIdx++
- }
- cursor++
- }
- default:
- return nil, "", errors.ErrInvalidBeginningOfValue(char(p, cursor), s.totalOffset())
- }
- }
-}
-
-// decode from '\uXXXX'
-func decodeKeyCharByUnicodeRuneStream(s *Stream) ([]byte, error) {
- const defaultOffset = 4
- const surrogateOffset = 6
-
- if s.cursor+defaultOffset >= s.length {
- if !s.read() {
- return nil, errors.ErrInvalidCharacter(s.char(), "escaped unicode char", s.totalOffset())
- }
- }
-
- r := unicodeToRune(s.buf[s.cursor : s.cursor+defaultOffset])
- if utf16.IsSurrogate(r) {
- s.cursor += defaultOffset
- if s.cursor+surrogateOffset >= s.length {
- s.read()
- }
- if s.cursor+surrogateOffset >= s.length || s.buf[s.cursor] != '\\' || s.buf[s.cursor+1] != 'u' {
- s.cursor += defaultOffset - 1
- return []byte(string(unicode.ReplacementChar)), nil
- }
- r2 := unicodeToRune(s.buf[s.cursor+defaultOffset+2 : s.cursor+surrogateOffset])
- if r := utf16.DecodeRune(r, r2); r != unicode.ReplacementChar {
- s.cursor += defaultOffset - 1
- return []byte(string(r)), nil
- }
- }
- s.cursor += defaultOffset - 1
- return []byte(string(r)), nil
-}
-
-func decodeKeyCharByEscapeCharStream(s *Stream) ([]byte, error) {
- c := s.buf[s.cursor]
- s.cursor++
-RETRY:
- switch c {
- case '"':
- return []byte{'"'}, nil
- case '\\':
- return []byte{'\\'}, nil
- case '/':
- return []byte{'/'}, nil
- case 'b':
- return []byte{'\b'}, nil
- case 'f':
- return []byte{'\f'}, nil
- case 'n':
- return []byte{'\n'}, nil
- case 'r':
- return []byte{'\r'}, nil
- case 't':
- return []byte{'\t'}, nil
- case 'u':
- return decodeKeyCharByUnicodeRuneStream(s)
- case nul:
- if !s.read() {
- return nil, errors.ErrInvalidCharacter(s.char(), "escaped char", s.totalOffset())
- }
- goto RETRY
- default:
- return nil, errors.ErrUnexpectedEndOfJSON("struct field", s.totalOffset())
- }
-}
-
-func decodeKeyNotFoundStream(s *Stream, start int64) (*structFieldSet, string, error) {
- buf, cursor, p := s.stat()
- for {
- cursor++
- switch char(p, cursor) {
- case '"':
- b := buf[start:cursor]
- key := *(*string)(unsafe.Pointer(&b))
- cursor++
- s.cursor = cursor
- return nil, key, nil
- case '\\':
- cursor++
- if char(p, cursor) == nul {
- s.cursor = cursor
- if !s.read() {
- return nil, "", errors.ErrUnexpectedEndOfJSON("string", s.totalOffset())
- }
- buf, cursor, p = s.statForRetry()
- }
- case nul:
- s.cursor = cursor
- if !s.read() {
- return nil, "", errors.ErrUnexpectedEndOfJSON("string", s.totalOffset())
- }
- buf, cursor, p = s.statForRetry()
- }
- }
-}
-
-func decodeKeyStream(d *structDecoder, s *Stream) (*structFieldSet, string, error) {
- key, err := d.stringDecoder.decodeStreamByte(s)
- if err != nil {
- return nil, "", err
- }
- k := *(*string)(unsafe.Pointer(&key))
- return d.fieldMap[k], k, nil
-}
-
-func (d *structDecoder) DecodeStream(s *Stream, depth int64, p unsafe.Pointer) error {
- depth++
- if depth > maxDecodeNestingDepth {
- return errors.ErrExceededMaxDepth(s.char(), s.cursor)
- }
-
- c := s.skipWhiteSpace()
- switch c {
- case 'n':
- if err := nullBytes(s); err != nil {
- return err
- }
- return nil
- default:
- if s.char() != '{' {
- return errors.ErrInvalidBeginningOfValue(s.char(), s.totalOffset())
- }
- }
- s.cursor++
- if s.skipWhiteSpace() == '}' {
- s.cursor++
- return nil
- }
- var (
- seenFields map[int]struct{}
- seenFieldNum int
- )
- firstWin := (s.Option.Flags & FirstWinOption) != 0
- if firstWin {
- seenFields = make(map[int]struct{}, d.fieldUniqueNameNum)
- }
- for {
- s.reset()
- field, key, err := d.keyStreamDecoder(d, s)
- if err != nil {
- return err
- }
- if s.skipWhiteSpace() != ':' {
- return errors.ErrExpected("colon after object key", s.totalOffset())
- }
- s.cursor++
- if field != nil {
- if field.err != nil {
- return field.err
- }
- if firstWin {
- if _, exists := seenFields[field.fieldIdx]; exists {
- if err := s.skipValue(depth); err != nil {
- return err
- }
- } else {
- if err := field.dec.DecodeStream(s, depth, unsafe.Pointer(uintptr(p)+field.offset)); err != nil {
- return err
- }
- seenFieldNum++
- if d.fieldUniqueNameNum <= seenFieldNum {
- return s.skipObject(depth)
- }
- seenFields[field.fieldIdx] = struct{}{}
- }
- } else {
- if err := field.dec.DecodeStream(s, depth, unsafe.Pointer(uintptr(p)+field.offset)); err != nil {
- return err
- }
- }
- } else if s.DisallowUnknownFields {
- return fmt.Errorf("json: unknown field %q", key)
- } else {
- if err := s.skipValue(depth); err != nil {
- return err
- }
- }
- c := s.skipWhiteSpace()
- if c == '}' {
- s.cursor++
- return nil
- }
- if c != ',' {
- return errors.ErrExpected("comma after object element", s.totalOffset())
- }
- s.cursor++
- }
-}
-
-func (d *structDecoder) Decode(ctx *RuntimeContext, cursor, depth int64, p unsafe.Pointer) (int64, error) {
- buf := ctx.Buf
- depth++
- if depth > maxDecodeNestingDepth {
- return 0, errors.ErrExceededMaxDepth(buf[cursor], cursor)
- }
- buflen := int64(len(buf))
- cursor = skipWhiteSpace(buf, cursor)
- b := (*sliceHeader)(unsafe.Pointer(&buf)).data
- switch char(b, cursor) {
- case 'n':
- if err := validateNull(buf, cursor); err != nil {
- return 0, err
- }
- cursor += 4
- return cursor, nil
- case '{':
- default:
- return 0, errors.ErrInvalidBeginningOfValue(char(b, cursor), cursor)
- }
- cursor++
- cursor = skipWhiteSpace(buf, cursor)
- if buf[cursor] == '}' {
- cursor++
- return cursor, nil
- }
- var (
- seenFields map[int]struct{}
- seenFieldNum int
- )
- firstWin := (ctx.Option.Flags & FirstWinOption) != 0
- if firstWin {
- seenFields = make(map[int]struct{}, d.fieldUniqueNameNum)
- }
- for {
- c, field, err := d.keyDecoder(d, buf, cursor)
- if err != nil {
- return 0, err
- }
- cursor = skipWhiteSpace(buf, c)
- if char(b, cursor) != ':' {
- return 0, errors.ErrExpected("colon after object key", cursor)
- }
- cursor++
- if cursor >= buflen {
- return 0, errors.ErrExpected("object value after colon", cursor)
- }
- if field != nil {
- if field.err != nil {
- return 0, field.err
- }
- if firstWin {
- if _, exists := seenFields[field.fieldIdx]; exists {
- c, err := skipValue(buf, cursor, depth)
- if err != nil {
- return 0, err
- }
- cursor = c
- } else {
- c, err := field.dec.Decode(ctx, cursor, depth, unsafe.Pointer(uintptr(p)+field.offset))
- if err != nil {
- return 0, err
- }
- cursor = c
- seenFieldNum++
- if d.fieldUniqueNameNum <= seenFieldNum {
- return skipObject(buf, cursor, depth)
- }
- seenFields[field.fieldIdx] = struct{}{}
- }
- } else {
- c, err := field.dec.Decode(ctx, cursor, depth, unsafe.Pointer(uintptr(p)+field.offset))
- if err != nil {
- return 0, err
- }
- cursor = c
- }
- } else {
- c, err := skipValue(buf, cursor, depth)
- if err != nil {
- return 0, err
- }
- cursor = c
- }
- cursor = skipWhiteSpace(buf, cursor)
- if char(b, cursor) == '}' {
- cursor++
- return cursor, nil
- }
- if char(b, cursor) != ',' {
- return 0, errors.ErrExpected("comma after object element", cursor)
- }
- cursor++
- }
-}
-
-func (d *structDecoder) DecodePath(ctx *RuntimeContext, cursor, depth int64) ([][]byte, int64, error) {
- return nil, 0, fmt.Errorf("json: struct decoder does not support decode path")
-}
diff --git a/vendor/github.com/goccy/go-json/internal/decoder/type.go b/vendor/github.com/goccy/go-json/internal/decoder/type.go
deleted file mode 100644
index beaf3ab8..00000000
--- a/vendor/github.com/goccy/go-json/internal/decoder/type.go
+++ /dev/null
@@ -1,30 +0,0 @@
-package decoder
-
-import (
- "context"
- "encoding"
- "encoding/json"
- "reflect"
- "unsafe"
-)
-
-type Decoder interface {
- Decode(*RuntimeContext, int64, int64, unsafe.Pointer) (int64, error)
- DecodePath(*RuntimeContext, int64, int64) ([][]byte, int64, error)
- DecodeStream(*Stream, int64, unsafe.Pointer) error
-}
-
-const (
- nul = '\000'
- maxDecodeNestingDepth = 10000
-)
-
-type unmarshalerContext interface {
- UnmarshalJSON(context.Context, []byte) error
-}
-
-var (
- unmarshalJSONType = reflect.TypeOf((*json.Unmarshaler)(nil)).Elem()
- unmarshalJSONContextType = reflect.TypeOf((*unmarshalerContext)(nil)).Elem()
- unmarshalTextType = reflect.TypeOf((*encoding.TextUnmarshaler)(nil)).Elem()
-)
diff --git a/vendor/github.com/goccy/go-json/internal/decoder/uint.go b/vendor/github.com/goccy/go-json/internal/decoder/uint.go
deleted file mode 100644
index 4131731b..00000000
--- a/vendor/github.com/goccy/go-json/internal/decoder/uint.go
+++ /dev/null
@@ -1,194 +0,0 @@
-package decoder
-
-import (
- "fmt"
- "reflect"
- "unsafe"
-
- "github.com/goccy/go-json/internal/errors"
- "github.com/goccy/go-json/internal/runtime"
-)
-
-type uintDecoder struct {
- typ *runtime.Type
- kind reflect.Kind
- op func(unsafe.Pointer, uint64)
- structName string
- fieldName string
-}
-
-func newUintDecoder(typ *runtime.Type, structName, fieldName string, op func(unsafe.Pointer, uint64)) *uintDecoder {
- return &uintDecoder{
- typ: typ,
- kind: typ.Kind(),
- op: op,
- structName: structName,
- fieldName: fieldName,
- }
-}
-
-func (d *uintDecoder) typeError(buf []byte, offset int64) *errors.UnmarshalTypeError {
- return &errors.UnmarshalTypeError{
- Value: fmt.Sprintf("number %s", string(buf)),
- Type: runtime.RType2Type(d.typ),
- Offset: offset,
- }
-}
-
-var (
- pow10u64 = [...]uint64{
- 1e00, 1e01, 1e02, 1e03, 1e04, 1e05, 1e06, 1e07, 1e08, 1e09,
- 1e10, 1e11, 1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19,
- }
- pow10u64Len = len(pow10u64)
-)
-
-func (d *uintDecoder) parseUint(b []byte) (uint64, error) {
- maxDigit := len(b)
- if maxDigit > pow10u64Len {
- return 0, fmt.Errorf("invalid length of number")
- }
- sum := uint64(0)
- for i := 0; i < maxDigit; i++ {
- c := uint64(b[i]) - 48
- digitValue := pow10u64[maxDigit-i-1]
- sum += c * digitValue
- }
- return sum, nil
-}
-
-func (d *uintDecoder) decodeStreamByte(s *Stream) ([]byte, error) {
- for {
- switch s.char() {
- case ' ', '\n', '\t', '\r':
- s.cursor++
- continue
- case '0':
- s.cursor++
- return numZeroBuf, nil
- case '1', '2', '3', '4', '5', '6', '7', '8', '9':
- start := s.cursor
- for {
- s.cursor++
- if numTable[s.char()] {
- continue
- } else if s.char() == nul {
- if s.read() {
- s.cursor-- // for retry current character
- continue
- }
- }
- break
- }
- num := s.buf[start:s.cursor]
- return num, nil
- case 'n':
- if err := nullBytes(s); err != nil {
- return nil, err
- }
- return nil, nil
- case nul:
- if s.read() {
- continue
- }
- default:
- return nil, d.typeError([]byte{s.char()}, s.totalOffset())
- }
- break
- }
- return nil, errors.ErrUnexpectedEndOfJSON("number(unsigned integer)", s.totalOffset())
-}
-
-func (d *uintDecoder) decodeByte(buf []byte, cursor int64) ([]byte, int64, error) {
- for {
- switch buf[cursor] {
- case ' ', '\n', '\t', '\r':
- cursor++
- continue
- case '0':
- cursor++
- return numZeroBuf, cursor, nil
- case '1', '2', '3', '4', '5', '6', '7', '8', '9':
- start := cursor
- cursor++
- for numTable[buf[cursor]] {
- cursor++
- }
- num := buf[start:cursor]
- return num, cursor, nil
- case 'n':
- if err := validateNull(buf, cursor); err != nil {
- return nil, 0, err
- }
- cursor += 4
- return nil, cursor, nil
- default:
- return nil, 0, d.typeError([]byte{buf[cursor]}, cursor)
- }
- }
-}
-
-func (d *uintDecoder) DecodeStream(s *Stream, depth int64, p unsafe.Pointer) error {
- bytes, err := d.decodeStreamByte(s)
- if err != nil {
- return err
- }
- if bytes == nil {
- return nil
- }
- u64, err := d.parseUint(bytes)
- if err != nil {
- return d.typeError(bytes, s.totalOffset())
- }
- switch d.kind {
- case reflect.Uint8:
- if (1 << 8) <= u64 {
- return d.typeError(bytes, s.totalOffset())
- }
- case reflect.Uint16:
- if (1 << 16) <= u64 {
- return d.typeError(bytes, s.totalOffset())
- }
- case reflect.Uint32:
- if (1 << 32) <= u64 {
- return d.typeError(bytes, s.totalOffset())
- }
- }
- d.op(p, u64)
- return nil
-}
-
-func (d *uintDecoder) Decode(ctx *RuntimeContext, cursor, depth int64, p unsafe.Pointer) (int64, error) {
- bytes, c, err := d.decodeByte(ctx.Buf, cursor)
- if err != nil {
- return 0, err
- }
- if bytes == nil {
- return c, nil
- }
- cursor = c
- u64, err := d.parseUint(bytes)
- if err != nil {
- return 0, d.typeError(bytes, cursor)
- }
- switch d.kind {
- case reflect.Uint8:
- if (1 << 8) <= u64 {
- return 0, d.typeError(bytes, cursor)
- }
- case reflect.Uint16:
- if (1 << 16) <= u64 {
- return 0, d.typeError(bytes, cursor)
- }
- case reflect.Uint32:
- if (1 << 32) <= u64 {
- return 0, d.typeError(bytes, cursor)
- }
- }
- d.op(p, u64)
- return cursor, nil
-}
-
-func (d *uintDecoder) DecodePath(ctx *RuntimeContext, cursor, depth int64) ([][]byte, int64, error) {
- return nil, 0, fmt.Errorf("json: uint decoder does not support decode path")
-}
diff --git a/vendor/github.com/goccy/go-json/internal/decoder/unmarshal_json.go b/vendor/github.com/goccy/go-json/internal/decoder/unmarshal_json.go
deleted file mode 100644
index 4cd6dbd5..00000000
--- a/vendor/github.com/goccy/go-json/internal/decoder/unmarshal_json.go
+++ /dev/null
@@ -1,104 +0,0 @@
-package decoder
-
-import (
- "context"
- "encoding/json"
- "fmt"
- "unsafe"
-
- "github.com/goccy/go-json/internal/errors"
- "github.com/goccy/go-json/internal/runtime"
-)
-
-type unmarshalJSONDecoder struct {
- typ *runtime.Type
- structName string
- fieldName string
-}
-
-func newUnmarshalJSONDecoder(typ *runtime.Type, structName, fieldName string) *unmarshalJSONDecoder {
- return &unmarshalJSONDecoder{
- typ: typ,
- structName: structName,
- fieldName: fieldName,
- }
-}
-
-func (d *unmarshalJSONDecoder) annotateError(cursor int64, err error) {
- switch e := err.(type) {
- case *errors.UnmarshalTypeError:
- e.Struct = d.structName
- e.Field = d.fieldName
- case *errors.SyntaxError:
- e.Offset = cursor
- }
-}
-
-func (d *unmarshalJSONDecoder) DecodeStream(s *Stream, depth int64, p unsafe.Pointer) error {
- s.skipWhiteSpace()
- start := s.cursor
- if err := s.skipValue(depth); err != nil {
- return err
- }
- src := s.buf[start:s.cursor]
- dst := make([]byte, len(src))
- copy(dst, src)
-
- v := *(*interface{})(unsafe.Pointer(&emptyInterface{
- typ: d.typ,
- ptr: p,
- }))
- switch v := v.(type) {
- case unmarshalerContext:
- var ctx context.Context
- if (s.Option.Flags & ContextOption) != 0 {
- ctx = s.Option.Context
- } else {
- ctx = context.Background()
- }
- if err := v.UnmarshalJSON(ctx, dst); err != nil {
- d.annotateError(s.cursor, err)
- return err
- }
- case json.Unmarshaler:
- if err := v.UnmarshalJSON(dst); err != nil {
- d.annotateError(s.cursor, err)
- return err
- }
- }
- return nil
-}
-
-func (d *unmarshalJSONDecoder) Decode(ctx *RuntimeContext, cursor, depth int64, p unsafe.Pointer) (int64, error) {
- buf := ctx.Buf
- cursor = skipWhiteSpace(buf, cursor)
- start := cursor
- end, err := skipValue(buf, cursor, depth)
- if err != nil {
- return 0, err
- }
- src := buf[start:end]
- dst := make([]byte, len(src))
- copy(dst, src)
-
- v := *(*interface{})(unsafe.Pointer(&emptyInterface{
- typ: d.typ,
- ptr: p,
- }))
- if (ctx.Option.Flags & ContextOption) != 0 {
- if err := v.(unmarshalerContext).UnmarshalJSON(ctx.Option.Context, dst); err != nil {
- d.annotateError(cursor, err)
- return 0, err
- }
- } else {
- if err := v.(json.Unmarshaler).UnmarshalJSON(dst); err != nil {
- d.annotateError(cursor, err)
- return 0, err
- }
- }
- return end, nil
-}
-
-func (d *unmarshalJSONDecoder) DecodePath(ctx *RuntimeContext, cursor, depth int64) ([][]byte, int64, error) {
- return nil, 0, fmt.Errorf("json: unmarshal json decoder does not support decode path")
-}
diff --git a/vendor/github.com/goccy/go-json/internal/decoder/unmarshal_text.go b/vendor/github.com/goccy/go-json/internal/decoder/unmarshal_text.go
deleted file mode 100644
index d711d0f8..00000000
--- a/vendor/github.com/goccy/go-json/internal/decoder/unmarshal_text.go
+++ /dev/null
@@ -1,285 +0,0 @@
-package decoder
-
-import (
- "bytes"
- "encoding"
- "fmt"
- "unicode"
- "unicode/utf16"
- "unicode/utf8"
- "unsafe"
-
- "github.com/goccy/go-json/internal/errors"
- "github.com/goccy/go-json/internal/runtime"
-)
-
-type unmarshalTextDecoder struct {
- typ *runtime.Type
- structName string
- fieldName string
-}
-
-func newUnmarshalTextDecoder(typ *runtime.Type, structName, fieldName string) *unmarshalTextDecoder {
- return &unmarshalTextDecoder{
- typ: typ,
- structName: structName,
- fieldName: fieldName,
- }
-}
-
-func (d *unmarshalTextDecoder) annotateError(cursor int64, err error) {
- switch e := err.(type) {
- case *errors.UnmarshalTypeError:
- e.Struct = d.structName
- e.Field = d.fieldName
- case *errors.SyntaxError:
- e.Offset = cursor
- }
-}
-
-var (
- nullbytes = []byte(`null`)
-)
-
-func (d *unmarshalTextDecoder) DecodeStream(s *Stream, depth int64, p unsafe.Pointer) error {
- s.skipWhiteSpace()
- start := s.cursor
- if err := s.skipValue(depth); err != nil {
- return err
- }
- src := s.buf[start:s.cursor]
- if len(src) > 0 {
- switch src[0] {
- case '[':
- return &errors.UnmarshalTypeError{
- Value: "array",
- Type: runtime.RType2Type(d.typ),
- Offset: s.totalOffset(),
- }
- case '{':
- return &errors.UnmarshalTypeError{
- Value: "object",
- Type: runtime.RType2Type(d.typ),
- Offset: s.totalOffset(),
- }
- case '-', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
- return &errors.UnmarshalTypeError{
- Value: "number",
- Type: runtime.RType2Type(d.typ),
- Offset: s.totalOffset(),
- }
- case 'n':
- if bytes.Equal(src, nullbytes) {
- *(*unsafe.Pointer)(p) = nil
- return nil
- }
- }
- }
- dst := make([]byte, len(src))
- copy(dst, src)
-
- if b, ok := unquoteBytes(dst); ok {
- dst = b
- }
- v := *(*interface{})(unsafe.Pointer(&emptyInterface{
- typ: d.typ,
- ptr: p,
- }))
- if err := v.(encoding.TextUnmarshaler).UnmarshalText(dst); err != nil {
- d.annotateError(s.cursor, err)
- return err
- }
- return nil
-}
-
-func (d *unmarshalTextDecoder) Decode(ctx *RuntimeContext, cursor, depth int64, p unsafe.Pointer) (int64, error) {
- buf := ctx.Buf
- cursor = skipWhiteSpace(buf, cursor)
- start := cursor
- end, err := skipValue(buf, cursor, depth)
- if err != nil {
- return 0, err
- }
- src := buf[start:end]
- if len(src) > 0 {
- switch src[0] {
- case '[':
- return 0, &errors.UnmarshalTypeError{
- Value: "array",
- Type: runtime.RType2Type(d.typ),
- Offset: start,
- }
- case '{':
- return 0, &errors.UnmarshalTypeError{
- Value: "object",
- Type: runtime.RType2Type(d.typ),
- Offset: start,
- }
- case '-', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
- return 0, &errors.UnmarshalTypeError{
- Value: "number",
- Type: runtime.RType2Type(d.typ),
- Offset: start,
- }
- case 'n':
- if bytes.Equal(src, nullbytes) {
- *(*unsafe.Pointer)(p) = nil
- return end, nil
- }
- }
- }
-
- if s, ok := unquoteBytes(src); ok {
- src = s
- }
- v := *(*interface{})(unsafe.Pointer(&emptyInterface{
- typ: d.typ,
- ptr: *(*unsafe.Pointer)(unsafe.Pointer(&p)),
- }))
- if err := v.(encoding.TextUnmarshaler).UnmarshalText(src); err != nil {
- d.annotateError(cursor, err)
- return 0, err
- }
- return end, nil
-}
-
-func (d *unmarshalTextDecoder) DecodePath(ctx *RuntimeContext, cursor, depth int64) ([][]byte, int64, error) {
- return nil, 0, fmt.Errorf("json: unmarshal text decoder does not support decode path")
-}
-
-func unquoteBytes(s []byte) (t []byte, ok bool) { //nolint: nonamedreturns
- length := len(s)
- if length < 2 || s[0] != '"' || s[length-1] != '"' {
- return
- }
- s = s[1 : length-1]
- length -= 2
-
- // Check for unusual characters. If there are none,
- // then no unquoting is needed, so return a slice of the
- // original bytes.
- r := 0
- for r < length {
- c := s[r]
- if c == '\\' || c == '"' || c < ' ' {
- break
- }
- if c < utf8.RuneSelf {
- r++
- continue
- }
- rr, size := utf8.DecodeRune(s[r:])
- if rr == utf8.RuneError && size == 1 {
- break
- }
- r += size
- }
- if r == length {
- return s, true
- }
-
- b := make([]byte, length+2*utf8.UTFMax)
- w := copy(b, s[0:r])
- for r < length {
- // Out of room? Can only happen if s is full of
- // malformed UTF-8 and we're replacing each
- // byte with RuneError.
- if w >= len(b)-2*utf8.UTFMax {
- nb := make([]byte, (len(b)+utf8.UTFMax)*2)
- copy(nb, b[0:w])
- b = nb
- }
- switch c := s[r]; {
- case c == '\\':
- r++
- if r >= length {
- return
- }
- switch s[r] {
- default:
- return
- case '"', '\\', '/', '\'':
- b[w] = s[r]
- r++
- w++
- case 'b':
- b[w] = '\b'
- r++
- w++
- case 'f':
- b[w] = '\f'
- r++
- w++
- case 'n':
- b[w] = '\n'
- r++
- w++
- case 'r':
- b[w] = '\r'
- r++
- w++
- case 't':
- b[w] = '\t'
- r++
- w++
- case 'u':
- r--
- rr := getu4(s[r:])
- if rr < 0 {
- return
- }
- r += 6
- if utf16.IsSurrogate(rr) {
- rr1 := getu4(s[r:])
- if dec := utf16.DecodeRune(rr, rr1); dec != unicode.ReplacementChar {
- // A valid pair; consume.
- r += 6
- w += utf8.EncodeRune(b[w:], dec)
- break
- }
- // Invalid surrogate; fall back to replacement rune.
- rr = unicode.ReplacementChar
- }
- w += utf8.EncodeRune(b[w:], rr)
- }
-
- // Quote, control characters are invalid.
- case c == '"', c < ' ':
- return
-
- // ASCII
- case c < utf8.RuneSelf:
- b[w] = c
- r++
- w++
-
- // Coerce to well-formed UTF-8.
- default:
- rr, size := utf8.DecodeRune(s[r:])
- r += size
- w += utf8.EncodeRune(b[w:], rr)
- }
- }
- return b[0:w], true
-}
-
-func getu4(s []byte) rune {
- if len(s) < 6 || s[0] != '\\' || s[1] != 'u' {
- return -1
- }
- var r rune
- for _, c := range s[2:6] {
- switch {
- case '0' <= c && c <= '9':
- c = c - '0'
- case 'a' <= c && c <= 'f':
- c = c - 'a' + 10
- case 'A' <= c && c <= 'F':
- c = c - 'A' + 10
- default:
- return -1
- }
- r = r*16 + rune(c)
- }
- return r
-}
diff --git a/vendor/github.com/goccy/go-json/internal/decoder/wrapped_string.go b/vendor/github.com/goccy/go-json/internal/decoder/wrapped_string.go
deleted file mode 100644
index 0c4e2e6e..00000000
--- a/vendor/github.com/goccy/go-json/internal/decoder/wrapped_string.go
+++ /dev/null
@@ -1,73 +0,0 @@
-package decoder
-
-import (
- "fmt"
- "reflect"
- "unsafe"
-
- "github.com/goccy/go-json/internal/runtime"
-)
-
-type wrappedStringDecoder struct {
- typ *runtime.Type
- dec Decoder
- stringDecoder *stringDecoder
- structName string
- fieldName string
- isPtrType bool
-}
-
-func newWrappedStringDecoder(typ *runtime.Type, dec Decoder, structName, fieldName string) *wrappedStringDecoder {
- return &wrappedStringDecoder{
- typ: typ,
- dec: dec,
- stringDecoder: newStringDecoder(structName, fieldName),
- structName: structName,
- fieldName: fieldName,
- isPtrType: typ.Kind() == reflect.Ptr,
- }
-}
-
-func (d *wrappedStringDecoder) DecodeStream(s *Stream, depth int64, p unsafe.Pointer) error {
- bytes, err := d.stringDecoder.decodeStreamByte(s)
- if err != nil {
- return err
- }
- if bytes == nil {
- if d.isPtrType {
- *(*unsafe.Pointer)(p) = nil
- }
- return nil
- }
- b := make([]byte, len(bytes)+1)
- copy(b, bytes)
- if _, err := d.dec.Decode(&RuntimeContext{Buf: b}, 0, depth, p); err != nil {
- return err
- }
- return nil
-}
-
-func (d *wrappedStringDecoder) Decode(ctx *RuntimeContext, cursor, depth int64, p unsafe.Pointer) (int64, error) {
- bytes, c, err := d.stringDecoder.decodeByte(ctx.Buf, cursor)
- if err != nil {
- return 0, err
- }
- if bytes == nil {
- if d.isPtrType {
- *(*unsafe.Pointer)(p) = nil
- }
- return c, nil
- }
- bytes = append(bytes, nul)
- oldBuf := ctx.Buf
- ctx.Buf = bytes
- if _, err := d.dec.Decode(ctx, 0, depth, p); err != nil {
- return 0, err
- }
- ctx.Buf = oldBuf
- return c, nil
-}
-
-func (d *wrappedStringDecoder) DecodePath(ctx *RuntimeContext, cursor, depth int64) ([][]byte, int64, error) {
- return nil, 0, fmt.Errorf("json: wrapped string decoder does not support decode path")
-}
diff --git a/vendor/github.com/goccy/go-json/internal/encoder/code.go b/vendor/github.com/goccy/go-json/internal/encoder/code.go
deleted file mode 100644
index 5b08faef..00000000
--- a/vendor/github.com/goccy/go-json/internal/encoder/code.go
+++ /dev/null
@@ -1,1023 +0,0 @@
-package encoder
-
-import (
- "fmt"
- "reflect"
- "unsafe"
-
- "github.com/goccy/go-json/internal/runtime"
-)
-
-type Code interface {
- Kind() CodeKind
- ToOpcode(*compileContext) Opcodes
- Filter(*FieldQuery) Code
-}
-
-type AnonymousCode interface {
- ToAnonymousOpcode(*compileContext) Opcodes
-}
-
-type Opcodes []*Opcode
-
-func (o Opcodes) First() *Opcode {
- if len(o) == 0 {
- return nil
- }
- return o[0]
-}
-
-func (o Opcodes) Last() *Opcode {
- if len(o) == 0 {
- return nil
- }
- return o[len(o)-1]
-}
-
-func (o Opcodes) Add(codes ...*Opcode) Opcodes {
- return append(o, codes...)
-}
-
-type CodeKind int
-
-const (
- CodeKindInterface CodeKind = iota
- CodeKindPtr
- CodeKindInt
- CodeKindUint
- CodeKindFloat
- CodeKindString
- CodeKindBool
- CodeKindStruct
- CodeKindMap
- CodeKindSlice
- CodeKindArray
- CodeKindBytes
- CodeKindMarshalJSON
- CodeKindMarshalText
- CodeKindRecursive
-)
-
-type IntCode struct {
- typ *runtime.Type
- bitSize uint8
- isString bool
- isPtr bool
-}
-
-func (c *IntCode) Kind() CodeKind {
- return CodeKindInt
-}
-
-func (c *IntCode) ToOpcode(ctx *compileContext) Opcodes {
- var code *Opcode
- switch {
- case c.isPtr:
- code = newOpCode(ctx, c.typ, OpIntPtr)
- case c.isString:
- code = newOpCode(ctx, c.typ, OpIntString)
- default:
- code = newOpCode(ctx, c.typ, OpInt)
- }
- code.NumBitSize = c.bitSize
- ctx.incIndex()
- return Opcodes{code}
-}
-
-func (c *IntCode) Filter(_ *FieldQuery) Code {
- return c
-}
-
-type UintCode struct {
- typ *runtime.Type
- bitSize uint8
- isString bool
- isPtr bool
-}
-
-func (c *UintCode) Kind() CodeKind {
- return CodeKindUint
-}
-
-func (c *UintCode) ToOpcode(ctx *compileContext) Opcodes {
- var code *Opcode
- switch {
- case c.isPtr:
- code = newOpCode(ctx, c.typ, OpUintPtr)
- case c.isString:
- code = newOpCode(ctx, c.typ, OpUintString)
- default:
- code = newOpCode(ctx, c.typ, OpUint)
- }
- code.NumBitSize = c.bitSize
- ctx.incIndex()
- return Opcodes{code}
-}
-
-func (c *UintCode) Filter(_ *FieldQuery) Code {
- return c
-}
-
-type FloatCode struct {
- typ *runtime.Type
- bitSize uint8
- isPtr bool
-}
-
-func (c *FloatCode) Kind() CodeKind {
- return CodeKindFloat
-}
-
-func (c *FloatCode) ToOpcode(ctx *compileContext) Opcodes {
- var code *Opcode
- switch {
- case c.isPtr:
- switch c.bitSize {
- case 32:
- code = newOpCode(ctx, c.typ, OpFloat32Ptr)
- default:
- code = newOpCode(ctx, c.typ, OpFloat64Ptr)
- }
- default:
- switch c.bitSize {
- case 32:
- code = newOpCode(ctx, c.typ, OpFloat32)
- default:
- code = newOpCode(ctx, c.typ, OpFloat64)
- }
- }
- ctx.incIndex()
- return Opcodes{code}
-}
-
-func (c *FloatCode) Filter(_ *FieldQuery) Code {
- return c
-}
-
-type StringCode struct {
- typ *runtime.Type
- isPtr bool
-}
-
-func (c *StringCode) Kind() CodeKind {
- return CodeKindString
-}
-
-func (c *StringCode) ToOpcode(ctx *compileContext) Opcodes {
- isJSONNumberType := c.typ == runtime.Type2RType(jsonNumberType)
- var code *Opcode
- if c.isPtr {
- if isJSONNumberType {
- code = newOpCode(ctx, c.typ, OpNumberPtr)
- } else {
- code = newOpCode(ctx, c.typ, OpStringPtr)
- }
- } else {
- if isJSONNumberType {
- code = newOpCode(ctx, c.typ, OpNumber)
- } else {
- code = newOpCode(ctx, c.typ, OpString)
- }
- }
- ctx.incIndex()
- return Opcodes{code}
-}
-
-func (c *StringCode) Filter(_ *FieldQuery) Code {
- return c
-}
-
-type BoolCode struct {
- typ *runtime.Type
- isPtr bool
-}
-
-func (c *BoolCode) Kind() CodeKind {
- return CodeKindBool
-}
-
-func (c *BoolCode) ToOpcode(ctx *compileContext) Opcodes {
- var code *Opcode
- switch {
- case c.isPtr:
- code = newOpCode(ctx, c.typ, OpBoolPtr)
- default:
- code = newOpCode(ctx, c.typ, OpBool)
- }
- ctx.incIndex()
- return Opcodes{code}
-}
-
-func (c *BoolCode) Filter(_ *FieldQuery) Code {
- return c
-}
-
-type BytesCode struct {
- typ *runtime.Type
- isPtr bool
-}
-
-func (c *BytesCode) Kind() CodeKind {
- return CodeKindBytes
-}
-
-func (c *BytesCode) ToOpcode(ctx *compileContext) Opcodes {
- var code *Opcode
- switch {
- case c.isPtr:
- code = newOpCode(ctx, c.typ, OpBytesPtr)
- default:
- code = newOpCode(ctx, c.typ, OpBytes)
- }
- ctx.incIndex()
- return Opcodes{code}
-}
-
-func (c *BytesCode) Filter(_ *FieldQuery) Code {
- return c
-}
-
-type SliceCode struct {
- typ *runtime.Type
- value Code
-}
-
-func (c *SliceCode) Kind() CodeKind {
- return CodeKindSlice
-}
-
-func (c *SliceCode) ToOpcode(ctx *compileContext) Opcodes {
- // header => opcode => elem => end
- // ^ |
- // |________|
- size := c.typ.Elem().Size()
- header := newSliceHeaderCode(ctx, c.typ)
- ctx.incIndex()
-
- ctx.incIndent()
- codes := c.value.ToOpcode(ctx)
- ctx.decIndent()
-
- codes.First().Flags |= IndirectFlags
- elemCode := newSliceElemCode(ctx, c.typ.Elem(), header, size)
- ctx.incIndex()
- end := newOpCode(ctx, c.typ, OpSliceEnd)
- ctx.incIndex()
- header.End = end
- header.Next = codes.First()
- codes.Last().Next = elemCode
- elemCode.Next = codes.First()
- elemCode.End = end
- return Opcodes{header}.Add(codes...).Add(elemCode).Add(end)
-}
-
-func (c *SliceCode) Filter(_ *FieldQuery) Code {
- return c
-}
-
-type ArrayCode struct {
- typ *runtime.Type
- value Code
-}
-
-func (c *ArrayCode) Kind() CodeKind {
- return CodeKindArray
-}
-
-func (c *ArrayCode) ToOpcode(ctx *compileContext) Opcodes {
- // header => opcode => elem => end
- // ^ |
- // |________|
- elem := c.typ.Elem()
- alen := c.typ.Len()
- size := elem.Size()
-
- header := newArrayHeaderCode(ctx, c.typ, alen)
- ctx.incIndex()
-
- ctx.incIndent()
- codes := c.value.ToOpcode(ctx)
- ctx.decIndent()
-
- codes.First().Flags |= IndirectFlags
-
- elemCode := newArrayElemCode(ctx, elem, header, alen, size)
- ctx.incIndex()
-
- end := newOpCode(ctx, c.typ, OpArrayEnd)
- ctx.incIndex()
-
- header.End = end
- header.Next = codes.First()
- codes.Last().Next = elemCode
- elemCode.Next = codes.First()
- elemCode.End = end
-
- return Opcodes{header}.Add(codes...).Add(elemCode).Add(end)
-}
-
-func (c *ArrayCode) Filter(_ *FieldQuery) Code {
- return c
-}
-
-type MapCode struct {
- typ *runtime.Type
- key Code
- value Code
-}
-
-func (c *MapCode) Kind() CodeKind {
- return CodeKindMap
-}
-
-func (c *MapCode) ToOpcode(ctx *compileContext) Opcodes {
- // header => code => value => code => key => code => value => code => end
- // ^ |
- // |_______________________|
- header := newMapHeaderCode(ctx, c.typ)
- ctx.incIndex()
-
- keyCodes := c.key.ToOpcode(ctx)
-
- value := newMapValueCode(ctx, c.typ.Elem(), header)
- ctx.incIndex()
-
- ctx.incIndent()
- valueCodes := c.value.ToOpcode(ctx)
- ctx.decIndent()
-
- valueCodes.First().Flags |= IndirectFlags
-
- key := newMapKeyCode(ctx, c.typ.Key(), header)
- ctx.incIndex()
-
- end := newMapEndCode(ctx, c.typ, header)
- ctx.incIndex()
-
- header.Next = keyCodes.First()
- keyCodes.Last().Next = value
- value.Next = valueCodes.First()
- valueCodes.Last().Next = key
- key.Next = keyCodes.First()
-
- header.End = end
- key.End = end
- value.End = end
- return Opcodes{header}.Add(keyCodes...).Add(value).Add(valueCodes...).Add(key).Add(end)
-}
-
-func (c *MapCode) Filter(_ *FieldQuery) Code {
- return c
-}
-
-type StructCode struct {
- typ *runtime.Type
- fields []*StructFieldCode
- isPtr bool
- disableIndirectConversion bool
- isIndirect bool
- isRecursive bool
-}
-
-func (c *StructCode) Kind() CodeKind {
- return CodeKindStruct
-}
-
-func (c *StructCode) lastFieldCode(field *StructFieldCode, firstField *Opcode) *Opcode {
- if isEmbeddedStruct(field) {
- return c.lastAnonymousFieldCode(firstField)
- }
- lastField := firstField
- for lastField.NextField != nil {
- lastField = lastField.NextField
- }
- return lastField
-}
-
-func (c *StructCode) lastAnonymousFieldCode(firstField *Opcode) *Opcode {
- // firstField is special StructHead operation for anonymous structure.
- // So, StructHead's next operation is truly struct head operation.
- for firstField.Op == OpStructHead || firstField.Op == OpStructField {
- firstField = firstField.Next
- }
- lastField := firstField
- for lastField.NextField != nil {
- lastField = lastField.NextField
- }
- return lastField
-}
-
-func (c *StructCode) ToOpcode(ctx *compileContext) Opcodes {
- // header => code => structField => code => end
- // ^ |
- // |__________|
- if c.isRecursive {
- recursive := newRecursiveCode(ctx, c.typ, &CompiledCode{})
- recursive.Type = c.typ
- ctx.incIndex()
- *ctx.recursiveCodes = append(*ctx.recursiveCodes, recursive)
- return Opcodes{recursive}
- }
- codes := Opcodes{}
- var prevField *Opcode
- ctx.incIndent()
- for idx, field := range c.fields {
- isFirstField := idx == 0
- isEndField := idx == len(c.fields)-1
- fieldCodes := field.ToOpcode(ctx, isFirstField, isEndField)
- for _, code := range fieldCodes {
- if c.isIndirect {
- code.Flags |= IndirectFlags
- }
- }
- firstField := fieldCodes.First()
- if len(codes) > 0 {
- codes.Last().Next = firstField
- firstField.Idx = codes.First().Idx
- }
- if prevField != nil {
- prevField.NextField = firstField
- }
- if isEndField {
- endField := fieldCodes.Last()
- if len(codes) > 0 {
- codes.First().End = endField
- } else {
- firstField.End = endField
- }
- codes = codes.Add(fieldCodes...)
- break
- }
- prevField = c.lastFieldCode(field, firstField)
- codes = codes.Add(fieldCodes...)
- }
- if len(codes) == 0 {
- head := &Opcode{
- Op: OpStructHead,
- Idx: opcodeOffset(ctx.ptrIndex),
- Type: c.typ,
- DisplayIdx: ctx.opcodeIndex,
- Indent: ctx.indent,
- }
- ctx.incOpcodeIndex()
- end := &Opcode{
- Op: OpStructEnd,
- Idx: opcodeOffset(ctx.ptrIndex),
- DisplayIdx: ctx.opcodeIndex,
- Indent: ctx.indent,
- }
- head.NextField = end
- head.Next = end
- head.End = end
- codes = codes.Add(head, end)
- ctx.incIndex()
- }
- ctx.decIndent()
- ctx.structTypeToCodes[uintptr(unsafe.Pointer(c.typ))] = codes
- return codes
-}
-
-func (c *StructCode) ToAnonymousOpcode(ctx *compileContext) Opcodes {
- // header => code => structField => code => end
- // ^ |
- // |__________|
- if c.isRecursive {
- recursive := newRecursiveCode(ctx, c.typ, &CompiledCode{})
- recursive.Type = c.typ
- ctx.incIndex()
- *ctx.recursiveCodes = append(*ctx.recursiveCodes, recursive)
- return Opcodes{recursive}
- }
- codes := Opcodes{}
- var prevField *Opcode
- for idx, field := range c.fields {
- isFirstField := idx == 0
- isEndField := idx == len(c.fields)-1
- fieldCodes := field.ToAnonymousOpcode(ctx, isFirstField, isEndField)
- for _, code := range fieldCodes {
- if c.isIndirect {
- code.Flags |= IndirectFlags
- }
- }
- firstField := fieldCodes.First()
- if len(codes) > 0 {
- codes.Last().Next = firstField
- firstField.Idx = codes.First().Idx
- }
- if prevField != nil {
- prevField.NextField = firstField
- }
- if isEndField {
- lastField := fieldCodes.Last()
- if len(codes) > 0 {
- codes.First().End = lastField
- } else {
- firstField.End = lastField
- }
- }
- prevField = firstField
- codes = codes.Add(fieldCodes...)
- }
- return codes
-}
-
-func (c *StructCode) removeFieldsByTags(tags runtime.StructTags) {
- fields := make([]*StructFieldCode, 0, len(c.fields))
- for _, field := range c.fields {
- if field.isAnonymous {
- structCode := field.getAnonymousStruct()
- if structCode != nil && !structCode.isRecursive {
- structCode.removeFieldsByTags(tags)
- if len(structCode.fields) > 0 {
- fields = append(fields, field)
- }
- continue
- }
- }
- if tags.ExistsKey(field.key) {
- continue
- }
- fields = append(fields, field)
- }
- c.fields = fields
-}
-
-func (c *StructCode) enableIndirect() {
- if c.isIndirect {
- return
- }
- c.isIndirect = true
- if len(c.fields) == 0 {
- return
- }
- structCode := c.fields[0].getStruct()
- if structCode == nil {
- return
- }
- structCode.enableIndirect()
-}
-
-func (c *StructCode) Filter(query *FieldQuery) Code {
- fieldMap := map[string]*FieldQuery{}
- for _, field := range query.Fields {
- fieldMap[field.Name] = field
- }
- fields := make([]*StructFieldCode, 0, len(c.fields))
- for _, field := range c.fields {
- query, exists := fieldMap[field.key]
- if !exists {
- continue
- }
- fieldCode := &StructFieldCode{
- typ: field.typ,
- key: field.key,
- tag: field.tag,
- value: field.value,
- offset: field.offset,
- isAnonymous: field.isAnonymous,
- isTaggedKey: field.isTaggedKey,
- isNilableType: field.isNilableType,
- isNilCheck: field.isNilCheck,
- isAddrForMarshaler: field.isAddrForMarshaler,
- isNextOpPtrType: field.isNextOpPtrType,
- }
- if len(query.Fields) > 0 {
- fieldCode.value = fieldCode.value.Filter(query)
- }
- fields = append(fields, fieldCode)
- }
- return &StructCode{
- typ: c.typ,
- fields: fields,
- isPtr: c.isPtr,
- disableIndirectConversion: c.disableIndirectConversion,
- isIndirect: c.isIndirect,
- isRecursive: c.isRecursive,
- }
-}
-
-type StructFieldCode struct {
- typ *runtime.Type
- key string
- tag *runtime.StructTag
- value Code
- offset uintptr
- isAnonymous bool
- isTaggedKey bool
- isNilableType bool
- isNilCheck bool
- isAddrForMarshaler bool
- isNextOpPtrType bool
- isMarshalerContext bool
-}
-
-func (c *StructFieldCode) getStruct() *StructCode {
- value := c.value
- ptr, ok := value.(*PtrCode)
- if ok {
- value = ptr.value
- }
- structCode, ok := value.(*StructCode)
- if ok {
- return structCode
- }
- return nil
-}
-
-func (c *StructFieldCode) getAnonymousStruct() *StructCode {
- if !c.isAnonymous {
- return nil
- }
- return c.getStruct()
-}
-
-func optimizeStructHeader(code *Opcode, tag *runtime.StructTag) OpType {
- headType := code.ToHeaderType(tag.IsString)
- if tag.IsOmitEmpty {
- headType = headType.HeadToOmitEmptyHead()
- }
- return headType
-}
-
-func optimizeStructField(code *Opcode, tag *runtime.StructTag) OpType {
- fieldType := code.ToFieldType(tag.IsString)
- if tag.IsOmitEmpty {
- fieldType = fieldType.FieldToOmitEmptyField()
- }
- return fieldType
-}
-
-func (c *StructFieldCode) headerOpcodes(ctx *compileContext, field *Opcode, valueCodes Opcodes) Opcodes {
- value := valueCodes.First()
- op := optimizeStructHeader(value, c.tag)
- field.Op = op
- if value.Flags&MarshalerContextFlags != 0 {
- field.Flags |= MarshalerContextFlags
- }
- field.NumBitSize = value.NumBitSize
- field.PtrNum = value.PtrNum
- field.FieldQuery = value.FieldQuery
- fieldCodes := Opcodes{field}
- if op.IsMultipleOpHead() {
- field.Next = value
- fieldCodes = fieldCodes.Add(valueCodes...)
- } else {
- ctx.decIndex()
- }
- return fieldCodes
-}
-
-func (c *StructFieldCode) fieldOpcodes(ctx *compileContext, field *Opcode, valueCodes Opcodes) Opcodes {
- value := valueCodes.First()
- op := optimizeStructField(value, c.tag)
- field.Op = op
- if value.Flags&MarshalerContextFlags != 0 {
- field.Flags |= MarshalerContextFlags
- }
- field.NumBitSize = value.NumBitSize
- field.PtrNum = value.PtrNum
- field.FieldQuery = value.FieldQuery
-
- fieldCodes := Opcodes{field}
- if op.IsMultipleOpField() {
- field.Next = value
- fieldCodes = fieldCodes.Add(valueCodes...)
- } else {
- ctx.decIndex()
- }
- return fieldCodes
-}
-
-func (c *StructFieldCode) addStructEndCode(ctx *compileContext, codes Opcodes) Opcodes {
- end := &Opcode{
- Op: OpStructEnd,
- Idx: opcodeOffset(ctx.ptrIndex),
- DisplayIdx: ctx.opcodeIndex,
- Indent: ctx.indent,
- }
- codes.Last().Next = end
- code := codes.First()
- for code.Op == OpStructField || code.Op == OpStructHead {
- code = code.Next
- }
- for code.NextField != nil {
- code = code.NextField
- }
- code.NextField = end
-
- codes = codes.Add(end)
- ctx.incOpcodeIndex()
- return codes
-}
-
-func (c *StructFieldCode) structKey(ctx *compileContext) string {
- if ctx.escapeKey {
- rctx := &RuntimeContext{Option: &Option{Flag: HTMLEscapeOption}}
- return fmt.Sprintf(`%s:`, string(AppendString(rctx, []byte{}, c.key)))
- }
- return fmt.Sprintf(`"%s":`, c.key)
-}
-
-func (c *StructFieldCode) flags() OpFlags {
- var flags OpFlags
- if c.isTaggedKey {
- flags |= IsTaggedKeyFlags
- }
- if c.isNilableType {
- flags |= IsNilableTypeFlags
- }
- if c.isNilCheck {
- flags |= NilCheckFlags
- }
- if c.isAddrForMarshaler {
- flags |= AddrForMarshalerFlags
- }
- if c.isNextOpPtrType {
- flags |= IsNextOpPtrTypeFlags
- }
- if c.isAnonymous {
- flags |= AnonymousKeyFlags
- }
- if c.isMarshalerContext {
- flags |= MarshalerContextFlags
- }
- return flags
-}
-
-func (c *StructFieldCode) toValueOpcodes(ctx *compileContext) Opcodes {
- if c.isAnonymous {
- anonymCode, ok := c.value.(AnonymousCode)
- if ok {
- return anonymCode.ToAnonymousOpcode(ctx)
- }
- }
- return c.value.ToOpcode(ctx)
-}
-
-func (c *StructFieldCode) ToOpcode(ctx *compileContext, isFirstField, isEndField bool) Opcodes {
- field := &Opcode{
- Idx: opcodeOffset(ctx.ptrIndex),
- Flags: c.flags(),
- Key: c.structKey(ctx),
- Offset: uint32(c.offset),
- Type: c.typ,
- DisplayIdx: ctx.opcodeIndex,
- Indent: ctx.indent,
- DisplayKey: c.key,
- }
- ctx.incIndex()
- valueCodes := c.toValueOpcodes(ctx)
- if isFirstField {
- codes := c.headerOpcodes(ctx, field, valueCodes)
- if isEndField {
- codes = c.addStructEndCode(ctx, codes)
- }
- return codes
- }
- codes := c.fieldOpcodes(ctx, field, valueCodes)
- if isEndField {
- if isEnableStructEndOptimization(c.value) {
- field.Op = field.Op.FieldToEnd()
- } else {
- codes = c.addStructEndCode(ctx, codes)
- }
- }
- return codes
-}
-
-func (c *StructFieldCode) ToAnonymousOpcode(ctx *compileContext, isFirstField, isEndField bool) Opcodes {
- field := &Opcode{
- Idx: opcodeOffset(ctx.ptrIndex),
- Flags: c.flags() | AnonymousHeadFlags,
- Key: c.structKey(ctx),
- Offset: uint32(c.offset),
- Type: c.typ,
- DisplayIdx: ctx.opcodeIndex,
- Indent: ctx.indent,
- DisplayKey: c.key,
- }
- ctx.incIndex()
- valueCodes := c.toValueOpcodes(ctx)
- if isFirstField {
- return c.headerOpcodes(ctx, field, valueCodes)
- }
- return c.fieldOpcodes(ctx, field, valueCodes)
-}
-
-func isEnableStructEndOptimization(value Code) bool {
- switch value.Kind() {
- case CodeKindInt,
- CodeKindUint,
- CodeKindFloat,
- CodeKindString,
- CodeKindBool,
- CodeKindBytes:
- return true
- case CodeKindPtr:
- return isEnableStructEndOptimization(value.(*PtrCode).value)
- default:
- return false
- }
-}
-
-type InterfaceCode struct {
- typ *runtime.Type
- fieldQuery *FieldQuery
- isPtr bool
-}
-
-func (c *InterfaceCode) Kind() CodeKind {
- return CodeKindInterface
-}
-
-func (c *InterfaceCode) ToOpcode(ctx *compileContext) Opcodes {
- var code *Opcode
- switch {
- case c.isPtr:
- code = newOpCode(ctx, c.typ, OpInterfacePtr)
- default:
- code = newOpCode(ctx, c.typ, OpInterface)
- }
- code.FieldQuery = c.fieldQuery
- if c.typ.NumMethod() > 0 {
- code.Flags |= NonEmptyInterfaceFlags
- }
- ctx.incIndex()
- return Opcodes{code}
-}
-
-func (c *InterfaceCode) Filter(query *FieldQuery) Code {
- return &InterfaceCode{
- typ: c.typ,
- fieldQuery: query,
- isPtr: c.isPtr,
- }
-}
-
-type MarshalJSONCode struct {
- typ *runtime.Type
- fieldQuery *FieldQuery
- isAddrForMarshaler bool
- isNilableType bool
- isMarshalerContext bool
-}
-
-func (c *MarshalJSONCode) Kind() CodeKind {
- return CodeKindMarshalJSON
-}
-
-func (c *MarshalJSONCode) ToOpcode(ctx *compileContext) Opcodes {
- code := newOpCode(ctx, c.typ, OpMarshalJSON)
- code.FieldQuery = c.fieldQuery
- if c.isAddrForMarshaler {
- code.Flags |= AddrForMarshalerFlags
- }
- if c.isMarshalerContext {
- code.Flags |= MarshalerContextFlags
- }
- if c.isNilableType {
- code.Flags |= IsNilableTypeFlags
- } else {
- code.Flags &= ^IsNilableTypeFlags
- }
- ctx.incIndex()
- return Opcodes{code}
-}
-
-func (c *MarshalJSONCode) Filter(query *FieldQuery) Code {
- return &MarshalJSONCode{
- typ: c.typ,
- fieldQuery: query,
- isAddrForMarshaler: c.isAddrForMarshaler,
- isNilableType: c.isNilableType,
- isMarshalerContext: c.isMarshalerContext,
- }
-}
-
-type MarshalTextCode struct {
- typ *runtime.Type
- fieldQuery *FieldQuery
- isAddrForMarshaler bool
- isNilableType bool
-}
-
-func (c *MarshalTextCode) Kind() CodeKind {
- return CodeKindMarshalText
-}
-
-func (c *MarshalTextCode) ToOpcode(ctx *compileContext) Opcodes {
- code := newOpCode(ctx, c.typ, OpMarshalText)
- code.FieldQuery = c.fieldQuery
- if c.isAddrForMarshaler {
- code.Flags |= AddrForMarshalerFlags
- }
- if c.isNilableType {
- code.Flags |= IsNilableTypeFlags
- } else {
- code.Flags &= ^IsNilableTypeFlags
- }
- ctx.incIndex()
- return Opcodes{code}
-}
-
-func (c *MarshalTextCode) Filter(query *FieldQuery) Code {
- return &MarshalTextCode{
- typ: c.typ,
- fieldQuery: query,
- isAddrForMarshaler: c.isAddrForMarshaler,
- isNilableType: c.isNilableType,
- }
-}
-
-type PtrCode struct {
- typ *runtime.Type
- value Code
- ptrNum uint8
-}
-
-func (c *PtrCode) Kind() CodeKind {
- return CodeKindPtr
-}
-
-func (c *PtrCode) ToOpcode(ctx *compileContext) Opcodes {
- codes := c.value.ToOpcode(ctx)
- codes.First().Op = convertPtrOp(codes.First())
- codes.First().PtrNum = c.ptrNum
- return codes
-}
-
-func (c *PtrCode) ToAnonymousOpcode(ctx *compileContext) Opcodes {
- var codes Opcodes
- anonymCode, ok := c.value.(AnonymousCode)
- if ok {
- codes = anonymCode.ToAnonymousOpcode(ctx)
- } else {
- codes = c.value.ToOpcode(ctx)
- }
- codes.First().Op = convertPtrOp(codes.First())
- codes.First().PtrNum = c.ptrNum
- return codes
-}
-
-func (c *PtrCode) Filter(query *FieldQuery) Code {
- return &PtrCode{
- typ: c.typ,
- value: c.value.Filter(query),
- ptrNum: c.ptrNum,
- }
-}
-
-func convertPtrOp(code *Opcode) OpType {
- ptrHeadOp := code.Op.HeadToPtrHead()
- if code.Op != ptrHeadOp {
- if code.PtrNum > 0 {
- // ptr field and ptr head
- code.PtrNum--
- }
- return ptrHeadOp
- }
- switch code.Op {
- case OpInt:
- return OpIntPtr
- case OpUint:
- return OpUintPtr
- case OpFloat32:
- return OpFloat32Ptr
- case OpFloat64:
- return OpFloat64Ptr
- case OpString:
- return OpStringPtr
- case OpBool:
- return OpBoolPtr
- case OpBytes:
- return OpBytesPtr
- case OpNumber:
- return OpNumberPtr
- case OpArray:
- return OpArrayPtr
- case OpSlice:
- return OpSlicePtr
- case OpMap:
- return OpMapPtr
- case OpMarshalJSON:
- return OpMarshalJSONPtr
- case OpMarshalText:
- return OpMarshalTextPtr
- case OpInterface:
- return OpInterfacePtr
- case OpRecursive:
- return OpRecursivePtr
- }
- return code.Op
-}
-
-func isEmbeddedStruct(field *StructFieldCode) bool {
- if !field.isAnonymous {
- return false
- }
- t := field.typ
- if t.Kind() == reflect.Ptr {
- t = t.Elem()
- }
- return t.Kind() == reflect.Struct
-}
diff --git a/vendor/github.com/goccy/go-json/internal/encoder/compact.go b/vendor/github.com/goccy/go-json/internal/encoder/compact.go
deleted file mode 100644
index e287a6c0..00000000
--- a/vendor/github.com/goccy/go-json/internal/encoder/compact.go
+++ /dev/null
@@ -1,286 +0,0 @@
-package encoder
-
-import (
- "bytes"
- "fmt"
- "strconv"
- "unsafe"
-
- "github.com/goccy/go-json/internal/errors"
-)
-
-var (
- isWhiteSpace = [256]bool{
- ' ': true,
- '\n': true,
- '\t': true,
- '\r': true,
- }
- isHTMLEscapeChar = [256]bool{
- '<': true,
- '>': true,
- '&': true,
- }
- nul = byte('\000')
-)
-
-func Compact(buf *bytes.Buffer, src []byte, escape bool) error {
- if len(src) == 0 {
- return errors.ErrUnexpectedEndOfJSON("", 0)
- }
- buf.Grow(len(src))
- dst := buf.Bytes()
-
- ctx := TakeRuntimeContext()
- ctxBuf := ctx.Buf[:0]
- ctxBuf = append(append(ctxBuf, src...), nul)
- ctx.Buf = ctxBuf
-
- if err := compactAndWrite(buf, dst, ctxBuf, escape); err != nil {
- ReleaseRuntimeContext(ctx)
- return err
- }
- ReleaseRuntimeContext(ctx)
- return nil
-}
-
-func compactAndWrite(buf *bytes.Buffer, dst []byte, src []byte, escape bool) error {
- dst, err := compact(dst, src, escape)
- if err != nil {
- return err
- }
- if _, err := buf.Write(dst); err != nil {
- return err
- }
- return nil
-}
-
-func compact(dst, src []byte, escape bool) ([]byte, error) {
- buf, cursor, err := compactValue(dst, src, 0, escape)
- if err != nil {
- return nil, err
- }
- if err := validateEndBuf(src, cursor); err != nil {
- return nil, err
- }
- return buf, nil
-}
-
-func validateEndBuf(src []byte, cursor int64) error {
- for {
- switch src[cursor] {
- case ' ', '\t', '\n', '\r':
- cursor++
- continue
- case nul:
- return nil
- }
- return errors.ErrSyntax(
- fmt.Sprintf("invalid character '%c' after top-level value", src[cursor]),
- cursor+1,
- )
- }
-}
-
-func skipWhiteSpace(buf []byte, cursor int64) int64 {
-LOOP:
- if isWhiteSpace[buf[cursor]] {
- cursor++
- goto LOOP
- }
- return cursor
-}
-
-func compactValue(dst, src []byte, cursor int64, escape bool) ([]byte, int64, error) {
- for {
- switch src[cursor] {
- case ' ', '\t', '\n', '\r':
- cursor++
- continue
- case '{':
- return compactObject(dst, src, cursor, escape)
- case '}':
- return nil, 0, errors.ErrSyntax("unexpected character '}'", cursor)
- case '[':
- return compactArray(dst, src, cursor, escape)
- case ']':
- return nil, 0, errors.ErrSyntax("unexpected character ']'", cursor)
- case '"':
- return compactString(dst, src, cursor, escape)
- case '-', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
- return compactNumber(dst, src, cursor)
- case 't':
- return compactTrue(dst, src, cursor)
- case 'f':
- return compactFalse(dst, src, cursor)
- case 'n':
- return compactNull(dst, src, cursor)
- default:
- return nil, 0, errors.ErrSyntax(fmt.Sprintf("unexpected character '%c'", src[cursor]), cursor)
- }
- }
-}
-
-func compactObject(dst, src []byte, cursor int64, escape bool) ([]byte, int64, error) {
- if src[cursor] == '{' {
- dst = append(dst, '{')
- } else {
- return nil, 0, errors.ErrExpected("expected { character for object value", cursor)
- }
- cursor = skipWhiteSpace(src, cursor+1)
- if src[cursor] == '}' {
- dst = append(dst, '}')
- return dst, cursor + 1, nil
- }
- var err error
- for {
- cursor = skipWhiteSpace(src, cursor)
- dst, cursor, err = compactString(dst, src, cursor, escape)
- if err != nil {
- return nil, 0, err
- }
- cursor = skipWhiteSpace(src, cursor)
- if src[cursor] != ':' {
- return nil, 0, errors.ErrExpected("colon after object key", cursor)
- }
- dst = append(dst, ':')
- dst, cursor, err = compactValue(dst, src, cursor+1, escape)
- if err != nil {
- return nil, 0, err
- }
- cursor = skipWhiteSpace(src, cursor)
- switch src[cursor] {
- case '}':
- dst = append(dst, '}')
- cursor++
- return dst, cursor, nil
- case ',':
- dst = append(dst, ',')
- default:
- return nil, 0, errors.ErrExpected("comma after object value", cursor)
- }
- cursor++
- }
-}
-
-func compactArray(dst, src []byte, cursor int64, escape bool) ([]byte, int64, error) {
- if src[cursor] == '[' {
- dst = append(dst, '[')
- } else {
- return nil, 0, errors.ErrExpected("expected [ character for array value", cursor)
- }
- cursor = skipWhiteSpace(src, cursor+1)
- if src[cursor] == ']' {
- dst = append(dst, ']')
- return dst, cursor + 1, nil
- }
- var err error
- for {
- dst, cursor, err = compactValue(dst, src, cursor, escape)
- if err != nil {
- return nil, 0, err
- }
- cursor = skipWhiteSpace(src, cursor)
- switch src[cursor] {
- case ']':
- dst = append(dst, ']')
- cursor++
- return dst, cursor, nil
- case ',':
- dst = append(dst, ',')
- default:
- return nil, 0, errors.ErrExpected("comma after array value", cursor)
- }
- cursor++
- }
-}
-
-func compactString(dst, src []byte, cursor int64, escape bool) ([]byte, int64, error) {
- if src[cursor] != '"' {
- return nil, 0, errors.ErrInvalidCharacter(src[cursor], "string", cursor)
- }
- start := cursor
- for {
- cursor++
- c := src[cursor]
- if escape {
- if isHTMLEscapeChar[c] {
- dst = append(dst, src[start:cursor]...)
- dst = append(dst, `\u00`...)
- dst = append(dst, hex[c>>4], hex[c&0xF])
- start = cursor + 1
- } else if c == 0xE2 && cursor+2 < int64(len(src)) && src[cursor+1] == 0x80 && src[cursor+2]&^1 == 0xA8 {
- dst = append(dst, src[start:cursor]...)
- dst = append(dst, `\u202`...)
- dst = append(dst, hex[src[cursor+2]&0xF])
- start = cursor + 3
- cursor += 2
- }
- }
- switch c {
- case '\\':
- cursor++
- if src[cursor] == nul {
- return nil, 0, errors.ErrUnexpectedEndOfJSON("string", int64(len(src)))
- }
- case '"':
- cursor++
- return append(dst, src[start:cursor]...), cursor, nil
- case nul:
- return nil, 0, errors.ErrUnexpectedEndOfJSON("string", int64(len(src)))
- }
- }
-}
-
-func compactNumber(dst, src []byte, cursor int64) ([]byte, int64, error) {
- start := cursor
- for {
- cursor++
- if floatTable[src[cursor]] {
- continue
- }
- break
- }
- num := src[start:cursor]
- if _, err := strconv.ParseFloat(*(*string)(unsafe.Pointer(&num)), 64); err != nil {
- return nil, 0, err
- }
- dst = append(dst, num...)
- return dst, cursor, nil
-}
-
-func compactTrue(dst, src []byte, cursor int64) ([]byte, int64, error) {
- if cursor+3 >= int64(len(src)) {
- return nil, 0, errors.ErrUnexpectedEndOfJSON("true", cursor)
- }
- if !bytes.Equal(src[cursor:cursor+4], []byte(`true`)) {
- return nil, 0, errors.ErrInvalidCharacter(src[cursor], "true", cursor)
- }
- dst = append(dst, "true"...)
- cursor += 4
- return dst, cursor, nil
-}
-
-func compactFalse(dst, src []byte, cursor int64) ([]byte, int64, error) {
- if cursor+4 >= int64(len(src)) {
- return nil, 0, errors.ErrUnexpectedEndOfJSON("false", cursor)
- }
- if !bytes.Equal(src[cursor:cursor+5], []byte(`false`)) {
- return nil, 0, errors.ErrInvalidCharacter(src[cursor], "false", cursor)
- }
- dst = append(dst, "false"...)
- cursor += 5
- return dst, cursor, nil
-}
-
-func compactNull(dst, src []byte, cursor int64) ([]byte, int64, error) {
- if cursor+3 >= int64(len(src)) {
- return nil, 0, errors.ErrUnexpectedEndOfJSON("null", cursor)
- }
- if !bytes.Equal(src[cursor:cursor+4], []byte(`null`)) {
- return nil, 0, errors.ErrInvalidCharacter(src[cursor], "null", cursor)
- }
- dst = append(dst, "null"...)
- cursor += 4
- return dst, cursor, nil
-}
diff --git a/vendor/github.com/goccy/go-json/internal/encoder/compiler.go b/vendor/github.com/goccy/go-json/internal/encoder/compiler.go
deleted file mode 100644
index b1076368..00000000
--- a/vendor/github.com/goccy/go-json/internal/encoder/compiler.go
+++ /dev/null
@@ -1,939 +0,0 @@
-package encoder
-
-import (
- "context"
- "encoding"
- "encoding/json"
- "reflect"
- "sync"
- "sync/atomic"
- "unsafe"
-
- "github.com/goccy/go-json/internal/errors"
- "github.com/goccy/go-json/internal/runtime"
-)
-
-type marshalerContext interface {
- MarshalJSON(context.Context) ([]byte, error)
-}
-
-var (
- marshalJSONType = reflect.TypeOf((*json.Marshaler)(nil)).Elem()
- marshalJSONContextType = reflect.TypeOf((*marshalerContext)(nil)).Elem()
- marshalTextType = reflect.TypeOf((*encoding.TextMarshaler)(nil)).Elem()
- jsonNumberType = reflect.TypeOf(json.Number(""))
- cachedOpcodeSets []*OpcodeSet
- cachedOpcodeMap unsafe.Pointer // map[uintptr]*OpcodeSet
- typeAddr *runtime.TypeAddr
- initEncoderOnce sync.Once
-)
-
-func initEncoder() {
- initEncoderOnce.Do(func() {
- typeAddr = runtime.AnalyzeTypeAddr()
- if typeAddr == nil {
- typeAddr = &runtime.TypeAddr{}
- }
- cachedOpcodeSets = make([]*OpcodeSet, typeAddr.AddrRange>>typeAddr.AddrShift+1)
- })
-}
-
-func loadOpcodeMap() map[uintptr]*OpcodeSet {
- p := atomic.LoadPointer(&cachedOpcodeMap)
- return *(*map[uintptr]*OpcodeSet)(unsafe.Pointer(&p))
-}
-
-func storeOpcodeSet(typ uintptr, set *OpcodeSet, m map[uintptr]*OpcodeSet) {
- newOpcodeMap := make(map[uintptr]*OpcodeSet, len(m)+1)
- newOpcodeMap[typ] = set
-
- for k, v := range m {
- newOpcodeMap[k] = v
- }
-
- atomic.StorePointer(&cachedOpcodeMap, *(*unsafe.Pointer)(unsafe.Pointer(&newOpcodeMap)))
-}
-
-func compileToGetCodeSetSlowPath(typeptr uintptr) (*OpcodeSet, error) {
- opcodeMap := loadOpcodeMap()
- if codeSet, exists := opcodeMap[typeptr]; exists {
- return codeSet, nil
- }
- codeSet, err := newCompiler().compile(typeptr)
- if err != nil {
- return nil, err
- }
- storeOpcodeSet(typeptr, codeSet, opcodeMap)
- return codeSet, nil
-}
-
-func getFilteredCodeSetIfNeeded(ctx *RuntimeContext, codeSet *OpcodeSet) (*OpcodeSet, error) {
- if (ctx.Option.Flag & ContextOption) == 0 {
- return codeSet, nil
- }
- query := FieldQueryFromContext(ctx.Option.Context)
- if query == nil {
- return codeSet, nil
- }
- ctx.Option.Flag |= FieldQueryOption
- cacheCodeSet := codeSet.getQueryCache(query.Hash())
- if cacheCodeSet != nil {
- return cacheCodeSet, nil
- }
- queryCodeSet, err := newCompiler().codeToOpcodeSet(codeSet.Type, codeSet.Code.Filter(query))
- if err != nil {
- return nil, err
- }
- codeSet.setQueryCache(query.Hash(), queryCodeSet)
- return queryCodeSet, nil
-}
-
-type Compiler struct {
- structTypeToCode map[uintptr]*StructCode
-}
-
-func newCompiler() *Compiler {
- return &Compiler{
- structTypeToCode: map[uintptr]*StructCode{},
- }
-}
-
-func (c *Compiler) compile(typeptr uintptr) (*OpcodeSet, error) {
- // noescape trick for header.typ ( reflect.*rtype )
- typ := *(**runtime.Type)(unsafe.Pointer(&typeptr))
- code, err := c.typeToCode(typ)
- if err != nil {
- return nil, err
- }
- return c.codeToOpcodeSet(typ, code)
-}
-
-func (c *Compiler) codeToOpcodeSet(typ *runtime.Type, code Code) (*OpcodeSet, error) {
- noescapeKeyCode := c.codeToOpcode(&compileContext{
- structTypeToCodes: map[uintptr]Opcodes{},
- recursiveCodes: &Opcodes{},
- }, typ, code)
- if err := noescapeKeyCode.Validate(); err != nil {
- return nil, err
- }
- escapeKeyCode := c.codeToOpcode(&compileContext{
- structTypeToCodes: map[uintptr]Opcodes{},
- recursiveCodes: &Opcodes{},
- escapeKey: true,
- }, typ, code)
- noescapeKeyCode = copyOpcode(noescapeKeyCode)
- escapeKeyCode = copyOpcode(escapeKeyCode)
- setTotalLengthToInterfaceOp(noescapeKeyCode)
- setTotalLengthToInterfaceOp(escapeKeyCode)
- interfaceNoescapeKeyCode := copyToInterfaceOpcode(noescapeKeyCode)
- interfaceEscapeKeyCode := copyToInterfaceOpcode(escapeKeyCode)
- codeLength := noescapeKeyCode.TotalLength()
- return &OpcodeSet{
- Type: typ,
- NoescapeKeyCode: noescapeKeyCode,
- EscapeKeyCode: escapeKeyCode,
- InterfaceNoescapeKeyCode: interfaceNoescapeKeyCode,
- InterfaceEscapeKeyCode: interfaceEscapeKeyCode,
- CodeLength: codeLength,
- EndCode: ToEndCode(interfaceNoescapeKeyCode),
- Code: code,
- QueryCache: map[string]*OpcodeSet{},
- }, nil
-}
-
-func (c *Compiler) typeToCode(typ *runtime.Type) (Code, error) {
- switch {
- case c.implementsMarshalJSON(typ):
- return c.marshalJSONCode(typ)
- case c.implementsMarshalText(typ):
- return c.marshalTextCode(typ)
- }
-
- isPtr := false
- orgType := typ
- if typ.Kind() == reflect.Ptr {
- typ = typ.Elem()
- isPtr = true
- }
- switch {
- case c.implementsMarshalJSON(typ):
- return c.marshalJSONCode(orgType)
- case c.implementsMarshalText(typ):
- return c.marshalTextCode(orgType)
- }
- switch typ.Kind() {
- case reflect.Slice:
- elem := typ.Elem()
- if elem.Kind() == reflect.Uint8 {
- p := runtime.PtrTo(elem)
- if !c.implementsMarshalJSONType(p) && !p.Implements(marshalTextType) {
- return c.bytesCode(typ, isPtr)
- }
- }
- return c.sliceCode(typ)
- case reflect.Map:
- if isPtr {
- return c.ptrCode(runtime.PtrTo(typ))
- }
- return c.mapCode(typ)
- case reflect.Struct:
- return c.structCode(typ, isPtr)
- case reflect.Int:
- return c.intCode(typ, isPtr)
- case reflect.Int8:
- return c.int8Code(typ, isPtr)
- case reflect.Int16:
- return c.int16Code(typ, isPtr)
- case reflect.Int32:
- return c.int32Code(typ, isPtr)
- case reflect.Int64:
- return c.int64Code(typ, isPtr)
- case reflect.Uint, reflect.Uintptr:
- return c.uintCode(typ, isPtr)
- case reflect.Uint8:
- return c.uint8Code(typ, isPtr)
- case reflect.Uint16:
- return c.uint16Code(typ, isPtr)
- case reflect.Uint32:
- return c.uint32Code(typ, isPtr)
- case reflect.Uint64:
- return c.uint64Code(typ, isPtr)
- case reflect.Float32:
- return c.float32Code(typ, isPtr)
- case reflect.Float64:
- return c.float64Code(typ, isPtr)
- case reflect.String:
- return c.stringCode(typ, isPtr)
- case reflect.Bool:
- return c.boolCode(typ, isPtr)
- case reflect.Interface:
- return c.interfaceCode(typ, isPtr)
- default:
- if isPtr && typ.Implements(marshalTextType) {
- typ = orgType
- }
- return c.typeToCodeWithPtr(typ, isPtr)
- }
-}
-
-func (c *Compiler) typeToCodeWithPtr(typ *runtime.Type, isPtr bool) (Code, error) {
- switch {
- case c.implementsMarshalJSON(typ):
- return c.marshalJSONCode(typ)
- case c.implementsMarshalText(typ):
- return c.marshalTextCode(typ)
- }
- switch typ.Kind() {
- case reflect.Ptr:
- return c.ptrCode(typ)
- case reflect.Slice:
- elem := typ.Elem()
- if elem.Kind() == reflect.Uint8 {
- p := runtime.PtrTo(elem)
- if !c.implementsMarshalJSONType(p) && !p.Implements(marshalTextType) {
- return c.bytesCode(typ, false)
- }
- }
- return c.sliceCode(typ)
- case reflect.Array:
- return c.arrayCode(typ)
- case reflect.Map:
- return c.mapCode(typ)
- case reflect.Struct:
- return c.structCode(typ, isPtr)
- case reflect.Interface:
- return c.interfaceCode(typ, false)
- case reflect.Int:
- return c.intCode(typ, false)
- case reflect.Int8:
- return c.int8Code(typ, false)
- case reflect.Int16:
- return c.int16Code(typ, false)
- case reflect.Int32:
- return c.int32Code(typ, false)
- case reflect.Int64:
- return c.int64Code(typ, false)
- case reflect.Uint:
- return c.uintCode(typ, false)
- case reflect.Uint8:
- return c.uint8Code(typ, false)
- case reflect.Uint16:
- return c.uint16Code(typ, false)
- case reflect.Uint32:
- return c.uint32Code(typ, false)
- case reflect.Uint64:
- return c.uint64Code(typ, false)
- case reflect.Uintptr:
- return c.uintCode(typ, false)
- case reflect.Float32:
- return c.float32Code(typ, false)
- case reflect.Float64:
- return c.float64Code(typ, false)
- case reflect.String:
- return c.stringCode(typ, false)
- case reflect.Bool:
- return c.boolCode(typ, false)
- }
- return nil, &errors.UnsupportedTypeError{Type: runtime.RType2Type(typ)}
-}
-
-const intSize = 32 << (^uint(0) >> 63)
-
-//nolint:unparam
-func (c *Compiler) intCode(typ *runtime.Type, isPtr bool) (*IntCode, error) {
- return &IntCode{typ: typ, bitSize: intSize, isPtr: isPtr}, nil
-}
-
-//nolint:unparam
-func (c *Compiler) int8Code(typ *runtime.Type, isPtr bool) (*IntCode, error) {
- return &IntCode{typ: typ, bitSize: 8, isPtr: isPtr}, nil
-}
-
-//nolint:unparam
-func (c *Compiler) int16Code(typ *runtime.Type, isPtr bool) (*IntCode, error) {
- return &IntCode{typ: typ, bitSize: 16, isPtr: isPtr}, nil
-}
-
-//nolint:unparam
-func (c *Compiler) int32Code(typ *runtime.Type, isPtr bool) (*IntCode, error) {
- return &IntCode{typ: typ, bitSize: 32, isPtr: isPtr}, nil
-}
-
-//nolint:unparam
-func (c *Compiler) int64Code(typ *runtime.Type, isPtr bool) (*IntCode, error) {
- return &IntCode{typ: typ, bitSize: 64, isPtr: isPtr}, nil
-}
-
-//nolint:unparam
-func (c *Compiler) uintCode(typ *runtime.Type, isPtr bool) (*UintCode, error) {
- return &UintCode{typ: typ, bitSize: intSize, isPtr: isPtr}, nil
-}
-
-//nolint:unparam
-func (c *Compiler) uint8Code(typ *runtime.Type, isPtr bool) (*UintCode, error) {
- return &UintCode{typ: typ, bitSize: 8, isPtr: isPtr}, nil
-}
-
-//nolint:unparam
-func (c *Compiler) uint16Code(typ *runtime.Type, isPtr bool) (*UintCode, error) {
- return &UintCode{typ: typ, bitSize: 16, isPtr: isPtr}, nil
-}
-
-//nolint:unparam
-func (c *Compiler) uint32Code(typ *runtime.Type, isPtr bool) (*UintCode, error) {
- return &UintCode{typ: typ, bitSize: 32, isPtr: isPtr}, nil
-}
-
-//nolint:unparam
-func (c *Compiler) uint64Code(typ *runtime.Type, isPtr bool) (*UintCode, error) {
- return &UintCode{typ: typ, bitSize: 64, isPtr: isPtr}, nil
-}
-
-//nolint:unparam
-func (c *Compiler) float32Code(typ *runtime.Type, isPtr bool) (*FloatCode, error) {
- return &FloatCode{typ: typ, bitSize: 32, isPtr: isPtr}, nil
-}
-
-//nolint:unparam
-func (c *Compiler) float64Code(typ *runtime.Type, isPtr bool) (*FloatCode, error) {
- return &FloatCode{typ: typ, bitSize: 64, isPtr: isPtr}, nil
-}
-
-//nolint:unparam
-func (c *Compiler) stringCode(typ *runtime.Type, isPtr bool) (*StringCode, error) {
- return &StringCode{typ: typ, isPtr: isPtr}, nil
-}
-
-//nolint:unparam
-func (c *Compiler) boolCode(typ *runtime.Type, isPtr bool) (*BoolCode, error) {
- return &BoolCode{typ: typ, isPtr: isPtr}, nil
-}
-
-//nolint:unparam
-func (c *Compiler) intStringCode(typ *runtime.Type) (*IntCode, error) {
- return &IntCode{typ: typ, bitSize: intSize, isString: true}, nil
-}
-
-//nolint:unparam
-func (c *Compiler) int8StringCode(typ *runtime.Type) (*IntCode, error) {
- return &IntCode{typ: typ, bitSize: 8, isString: true}, nil
-}
-
-//nolint:unparam
-func (c *Compiler) int16StringCode(typ *runtime.Type) (*IntCode, error) {
- return &IntCode{typ: typ, bitSize: 16, isString: true}, nil
-}
-
-//nolint:unparam
-func (c *Compiler) int32StringCode(typ *runtime.Type) (*IntCode, error) {
- return &IntCode{typ: typ, bitSize: 32, isString: true}, nil
-}
-
-//nolint:unparam
-func (c *Compiler) int64StringCode(typ *runtime.Type) (*IntCode, error) {
- return &IntCode{typ: typ, bitSize: 64, isString: true}, nil
-}
-
-//nolint:unparam
-func (c *Compiler) uintStringCode(typ *runtime.Type) (*UintCode, error) {
- return &UintCode{typ: typ, bitSize: intSize, isString: true}, nil
-}
-
-//nolint:unparam
-func (c *Compiler) uint8StringCode(typ *runtime.Type) (*UintCode, error) {
- return &UintCode{typ: typ, bitSize: 8, isString: true}, nil
-}
-
-//nolint:unparam
-func (c *Compiler) uint16StringCode(typ *runtime.Type) (*UintCode, error) {
- return &UintCode{typ: typ, bitSize: 16, isString: true}, nil
-}
-
-//nolint:unparam
-func (c *Compiler) uint32StringCode(typ *runtime.Type) (*UintCode, error) {
- return &UintCode{typ: typ, bitSize: 32, isString: true}, nil
-}
-
-//nolint:unparam
-func (c *Compiler) uint64StringCode(typ *runtime.Type) (*UintCode, error) {
- return &UintCode{typ: typ, bitSize: 64, isString: true}, nil
-}
-
-//nolint:unparam
-func (c *Compiler) bytesCode(typ *runtime.Type, isPtr bool) (*BytesCode, error) {
- return &BytesCode{typ: typ, isPtr: isPtr}, nil
-}
-
-//nolint:unparam
-func (c *Compiler) interfaceCode(typ *runtime.Type, isPtr bool) (*InterfaceCode, error) {
- return &InterfaceCode{typ: typ, isPtr: isPtr}, nil
-}
-
-//nolint:unparam
-func (c *Compiler) marshalJSONCode(typ *runtime.Type) (*MarshalJSONCode, error) {
- return &MarshalJSONCode{
- typ: typ,
- isAddrForMarshaler: c.isPtrMarshalJSONType(typ),
- isNilableType: c.isNilableType(typ),
- isMarshalerContext: typ.Implements(marshalJSONContextType) || runtime.PtrTo(typ).Implements(marshalJSONContextType),
- }, nil
-}
-
-//nolint:unparam
-func (c *Compiler) marshalTextCode(typ *runtime.Type) (*MarshalTextCode, error) {
- return &MarshalTextCode{
- typ: typ,
- isAddrForMarshaler: c.isPtrMarshalTextType(typ),
- isNilableType: c.isNilableType(typ),
- }, nil
-}
-
-func (c *Compiler) ptrCode(typ *runtime.Type) (*PtrCode, error) {
- code, err := c.typeToCodeWithPtr(typ.Elem(), true)
- if err != nil {
- return nil, err
- }
- ptr, ok := code.(*PtrCode)
- if ok {
- return &PtrCode{typ: typ, value: ptr.value, ptrNum: ptr.ptrNum + 1}, nil
- }
- return &PtrCode{typ: typ, value: code, ptrNum: 1}, nil
-}
-
-func (c *Compiler) sliceCode(typ *runtime.Type) (*SliceCode, error) {
- elem := typ.Elem()
- code, err := c.listElemCode(elem)
- if err != nil {
- return nil, err
- }
- if code.Kind() == CodeKindStruct {
- structCode := code.(*StructCode)
- structCode.enableIndirect()
- }
- return &SliceCode{typ: typ, value: code}, nil
-}
-
-func (c *Compiler) arrayCode(typ *runtime.Type) (*ArrayCode, error) {
- elem := typ.Elem()
- code, err := c.listElemCode(elem)
- if err != nil {
- return nil, err
- }
- if code.Kind() == CodeKindStruct {
- structCode := code.(*StructCode)
- structCode.enableIndirect()
- }
- return &ArrayCode{typ: typ, value: code}, nil
-}
-
-func (c *Compiler) mapCode(typ *runtime.Type) (*MapCode, error) {
- keyCode, err := c.mapKeyCode(typ.Key())
- if err != nil {
- return nil, err
- }
- valueCode, err := c.mapValueCode(typ.Elem())
- if err != nil {
- return nil, err
- }
- if valueCode.Kind() == CodeKindStruct {
- structCode := valueCode.(*StructCode)
- structCode.enableIndirect()
- }
- return &MapCode{typ: typ, key: keyCode, value: valueCode}, nil
-}
-
-func (c *Compiler) listElemCode(typ *runtime.Type) (Code, error) {
- switch {
- case c.implementsMarshalJSONType(typ) || c.implementsMarshalJSONType(runtime.PtrTo(typ)):
- return c.marshalJSONCode(typ)
- case !typ.Implements(marshalTextType) && runtime.PtrTo(typ).Implements(marshalTextType):
- return c.marshalTextCode(typ)
- case typ.Kind() == reflect.Map:
- return c.ptrCode(runtime.PtrTo(typ))
- default:
- // isPtr was originally used to indicate whether the type of top level is pointer.
- // However, since the slice/array element is a specification that can get the pointer address, explicitly set isPtr to true.
- // See here for related issues: https://github.com/goccy/go-json/issues/370
- code, err := c.typeToCodeWithPtr(typ, true)
- if err != nil {
- return nil, err
- }
- ptr, ok := code.(*PtrCode)
- if ok {
- if ptr.value.Kind() == CodeKindMap {
- ptr.ptrNum++
- }
- }
- return code, nil
- }
-}
-
-func (c *Compiler) mapKeyCode(typ *runtime.Type) (Code, error) {
- switch {
- case c.implementsMarshalText(typ):
- return c.marshalTextCode(typ)
- }
- switch typ.Kind() {
- case reflect.Ptr:
- return c.ptrCode(typ)
- case reflect.String:
- return c.stringCode(typ, false)
- case reflect.Int:
- return c.intStringCode(typ)
- case reflect.Int8:
- return c.int8StringCode(typ)
- case reflect.Int16:
- return c.int16StringCode(typ)
- case reflect.Int32:
- return c.int32StringCode(typ)
- case reflect.Int64:
- return c.int64StringCode(typ)
- case reflect.Uint:
- return c.uintStringCode(typ)
- case reflect.Uint8:
- return c.uint8StringCode(typ)
- case reflect.Uint16:
- return c.uint16StringCode(typ)
- case reflect.Uint32:
- return c.uint32StringCode(typ)
- case reflect.Uint64:
- return c.uint64StringCode(typ)
- case reflect.Uintptr:
- return c.uintStringCode(typ)
- }
- return nil, &errors.UnsupportedTypeError{Type: runtime.RType2Type(typ)}
-}
-
-func (c *Compiler) mapValueCode(typ *runtime.Type) (Code, error) {
- switch typ.Kind() {
- case reflect.Map:
- return c.ptrCode(runtime.PtrTo(typ))
- default:
- code, err := c.typeToCodeWithPtr(typ, false)
- if err != nil {
- return nil, err
- }
- ptr, ok := code.(*PtrCode)
- if ok {
- if ptr.value.Kind() == CodeKindMap {
- ptr.ptrNum++
- }
- }
- return code, nil
- }
-}
-
-func (c *Compiler) structCode(typ *runtime.Type, isPtr bool) (*StructCode, error) {
- typeptr := uintptr(unsafe.Pointer(typ))
- if code, exists := c.structTypeToCode[typeptr]; exists {
- derefCode := *code
- derefCode.isRecursive = true
- return &derefCode, nil
- }
- indirect := runtime.IfaceIndir(typ)
- code := &StructCode{typ: typ, isPtr: isPtr, isIndirect: indirect}
- c.structTypeToCode[typeptr] = code
-
- fieldNum := typ.NumField()
- tags := c.typeToStructTags(typ)
- fields := []*StructFieldCode{}
- for i, tag := range tags {
- isOnlyOneFirstField := i == 0 && fieldNum == 1
- field, err := c.structFieldCode(code, tag, isPtr, isOnlyOneFirstField)
- if err != nil {
- return nil, err
- }
- if field.isAnonymous {
- structCode := field.getAnonymousStruct()
- if structCode != nil {
- structCode.removeFieldsByTags(tags)
- if c.isAssignableIndirect(field, isPtr) {
- if indirect {
- structCode.isIndirect = true
- } else {
- structCode.isIndirect = false
- }
- }
- }
- } else {
- structCode := field.getStruct()
- if structCode != nil {
- if indirect {
- // if parent is indirect type, set child indirect property to true
- structCode.isIndirect = true
- } else {
- // if parent is not indirect type, set child indirect property to false.
- // but if parent's indirect is false and isPtr is true, then indirect must be true.
- // Do this only if indirectConversion is enabled at the end of compileStruct.
- structCode.isIndirect = false
- }
- }
- }
- fields = append(fields, field)
- }
- fieldMap := c.getFieldMap(fields)
- duplicatedFieldMap := c.getDuplicatedFieldMap(fieldMap)
- code.fields = c.filteredDuplicatedFields(fields, duplicatedFieldMap)
- if !code.disableIndirectConversion && !indirect && isPtr {
- code.enableIndirect()
- }
- delete(c.structTypeToCode, typeptr)
- return code, nil
-}
-
-func toElemType(t *runtime.Type) *runtime.Type {
- for t.Kind() == reflect.Ptr {
- t = t.Elem()
- }
- return t
-}
-
-func (c *Compiler) structFieldCode(structCode *StructCode, tag *runtime.StructTag, isPtr, isOnlyOneFirstField bool) (*StructFieldCode, error) {
- field := tag.Field
- fieldType := runtime.Type2RType(field.Type)
- isIndirectSpecialCase := isPtr && isOnlyOneFirstField
- fieldCode := &StructFieldCode{
- typ: fieldType,
- key: tag.Key,
- tag: tag,
- offset: field.Offset,
- isAnonymous: field.Anonymous && !tag.IsTaggedKey && toElemType(fieldType).Kind() == reflect.Struct,
- isTaggedKey: tag.IsTaggedKey,
- isNilableType: c.isNilableType(fieldType),
- isNilCheck: true,
- }
- switch {
- case c.isMovePointerPositionFromHeadToFirstMarshalJSONFieldCase(fieldType, isIndirectSpecialCase):
- code, err := c.marshalJSONCode(fieldType)
- if err != nil {
- return nil, err
- }
- fieldCode.value = code
- fieldCode.isAddrForMarshaler = true
- fieldCode.isNilCheck = false
- structCode.isIndirect = false
- structCode.disableIndirectConversion = true
- case c.isMovePointerPositionFromHeadToFirstMarshalTextFieldCase(fieldType, isIndirectSpecialCase):
- code, err := c.marshalTextCode(fieldType)
- if err != nil {
- return nil, err
- }
- fieldCode.value = code
- fieldCode.isAddrForMarshaler = true
- fieldCode.isNilCheck = false
- structCode.isIndirect = false
- structCode.disableIndirectConversion = true
- case isPtr && c.isPtrMarshalJSONType(fieldType):
- // *struct{ field T }
- // func (*T) MarshalJSON() ([]byte, error)
- code, err := c.marshalJSONCode(fieldType)
- if err != nil {
- return nil, err
- }
- fieldCode.value = code
- fieldCode.isAddrForMarshaler = true
- fieldCode.isNilCheck = false
- case isPtr && c.isPtrMarshalTextType(fieldType):
- // *struct{ field T }
- // func (*T) MarshalText() ([]byte, error)
- code, err := c.marshalTextCode(fieldType)
- if err != nil {
- return nil, err
- }
- fieldCode.value = code
- fieldCode.isAddrForMarshaler = true
- fieldCode.isNilCheck = false
- default:
- code, err := c.typeToCodeWithPtr(fieldType, isPtr)
- if err != nil {
- return nil, err
- }
- switch code.Kind() {
- case CodeKindPtr, CodeKindInterface:
- fieldCode.isNextOpPtrType = true
- }
- fieldCode.value = code
- }
- return fieldCode, nil
-}
-
-func (c *Compiler) isAssignableIndirect(fieldCode *StructFieldCode, isPtr bool) bool {
- if isPtr {
- return false
- }
- codeType := fieldCode.value.Kind()
- if codeType == CodeKindMarshalJSON {
- return false
- }
- if codeType == CodeKindMarshalText {
- return false
- }
- return true
-}
-
-func (c *Compiler) getFieldMap(fields []*StructFieldCode) map[string][]*StructFieldCode {
- fieldMap := map[string][]*StructFieldCode{}
- for _, field := range fields {
- if field.isAnonymous {
- for k, v := range c.getAnonymousFieldMap(field) {
- fieldMap[k] = append(fieldMap[k], v...)
- }
- continue
- }
- fieldMap[field.key] = append(fieldMap[field.key], field)
- }
- return fieldMap
-}
-
-func (c *Compiler) getAnonymousFieldMap(field *StructFieldCode) map[string][]*StructFieldCode {
- fieldMap := map[string][]*StructFieldCode{}
- structCode := field.getAnonymousStruct()
- if structCode == nil || structCode.isRecursive {
- fieldMap[field.key] = append(fieldMap[field.key], field)
- return fieldMap
- }
- for k, v := range c.getFieldMapFromAnonymousParent(structCode.fields) {
- fieldMap[k] = append(fieldMap[k], v...)
- }
- return fieldMap
-}
-
-func (c *Compiler) getFieldMapFromAnonymousParent(fields []*StructFieldCode) map[string][]*StructFieldCode {
- fieldMap := map[string][]*StructFieldCode{}
- for _, field := range fields {
- if field.isAnonymous {
- for k, v := range c.getAnonymousFieldMap(field) {
- // Do not handle tagged key when embedding more than once
- for _, vv := range v {
- vv.isTaggedKey = false
- }
- fieldMap[k] = append(fieldMap[k], v...)
- }
- continue
- }
- fieldMap[field.key] = append(fieldMap[field.key], field)
- }
- return fieldMap
-}
-
-func (c *Compiler) getDuplicatedFieldMap(fieldMap map[string][]*StructFieldCode) map[*StructFieldCode]struct{} {
- duplicatedFieldMap := map[*StructFieldCode]struct{}{}
- for _, fields := range fieldMap {
- if len(fields) == 1 {
- continue
- }
- if c.isTaggedKeyOnly(fields) {
- for _, field := range fields {
- if field.isTaggedKey {
- continue
- }
- duplicatedFieldMap[field] = struct{}{}
- }
- } else {
- for _, field := range fields {
- duplicatedFieldMap[field] = struct{}{}
- }
- }
- }
- return duplicatedFieldMap
-}
-
-func (c *Compiler) filteredDuplicatedFields(fields []*StructFieldCode, duplicatedFieldMap map[*StructFieldCode]struct{}) []*StructFieldCode {
- filteredFields := make([]*StructFieldCode, 0, len(fields))
- for _, field := range fields {
- if field.isAnonymous {
- structCode := field.getAnonymousStruct()
- if structCode != nil && !structCode.isRecursive {
- structCode.fields = c.filteredDuplicatedFields(structCode.fields, duplicatedFieldMap)
- if len(structCode.fields) > 0 {
- filteredFields = append(filteredFields, field)
- }
- continue
- }
- }
- if _, exists := duplicatedFieldMap[field]; exists {
- continue
- }
- filteredFields = append(filteredFields, field)
- }
- return filteredFields
-}
-
-func (c *Compiler) isTaggedKeyOnly(fields []*StructFieldCode) bool {
- var taggedKeyFieldCount int
- for _, field := range fields {
- if field.isTaggedKey {
- taggedKeyFieldCount++
- }
- }
- return taggedKeyFieldCount == 1
-}
-
-func (c *Compiler) typeToStructTags(typ *runtime.Type) runtime.StructTags {
- tags := runtime.StructTags{}
- fieldNum := typ.NumField()
- for i := 0; i < fieldNum; i++ {
- field := typ.Field(i)
- if runtime.IsIgnoredStructField(field) {
- continue
- }
- tags = append(tags, runtime.StructTagFromField(field))
- }
- return tags
-}
-
-// *struct{ field T } => struct { field *T }
-// func (*T) MarshalJSON() ([]byte, error)
-func (c *Compiler) isMovePointerPositionFromHeadToFirstMarshalJSONFieldCase(typ *runtime.Type, isIndirectSpecialCase bool) bool {
- return isIndirectSpecialCase && !c.isNilableType(typ) && c.isPtrMarshalJSONType(typ)
-}
-
-// *struct{ field T } => struct { field *T }
-// func (*T) MarshalText() ([]byte, error)
-func (c *Compiler) isMovePointerPositionFromHeadToFirstMarshalTextFieldCase(typ *runtime.Type, isIndirectSpecialCase bool) bool {
- return isIndirectSpecialCase && !c.isNilableType(typ) && c.isPtrMarshalTextType(typ)
-}
-
-func (c *Compiler) implementsMarshalJSON(typ *runtime.Type) bool {
- if !c.implementsMarshalJSONType(typ) {
- return false
- }
- if typ.Kind() != reflect.Ptr {
- return true
- }
- // type kind is reflect.Ptr
- if !c.implementsMarshalJSONType(typ.Elem()) {
- return true
- }
- // needs to dereference
- return false
-}
-
-func (c *Compiler) implementsMarshalText(typ *runtime.Type) bool {
- if !typ.Implements(marshalTextType) {
- return false
- }
- if typ.Kind() != reflect.Ptr {
- return true
- }
- // type kind is reflect.Ptr
- if !typ.Elem().Implements(marshalTextType) {
- return true
- }
- // needs to dereference
- return false
-}
-
-func (c *Compiler) isNilableType(typ *runtime.Type) bool {
- if !runtime.IfaceIndir(typ) {
- return true
- }
- switch typ.Kind() {
- case reflect.Ptr:
- return true
- case reflect.Map:
- return true
- case reflect.Func:
- return true
- default:
- return false
- }
-}
-
-func (c *Compiler) implementsMarshalJSONType(typ *runtime.Type) bool {
- return typ.Implements(marshalJSONType) || typ.Implements(marshalJSONContextType)
-}
-
-func (c *Compiler) isPtrMarshalJSONType(typ *runtime.Type) bool {
- return !c.implementsMarshalJSONType(typ) && c.implementsMarshalJSONType(runtime.PtrTo(typ))
-}
-
-func (c *Compiler) isPtrMarshalTextType(typ *runtime.Type) bool {
- return !typ.Implements(marshalTextType) && runtime.PtrTo(typ).Implements(marshalTextType)
-}
-
-func (c *Compiler) codeToOpcode(ctx *compileContext, typ *runtime.Type, code Code) *Opcode {
- codes := code.ToOpcode(ctx)
- codes.Last().Next = newEndOp(ctx, typ)
- c.linkRecursiveCode(ctx)
- return codes.First()
-}
-
-func (c *Compiler) linkRecursiveCode(ctx *compileContext) {
- recursiveCodes := map[uintptr]*CompiledCode{}
- for _, recursive := range *ctx.recursiveCodes {
- typeptr := uintptr(unsafe.Pointer(recursive.Type))
- codes := ctx.structTypeToCodes[typeptr]
- if recursiveCode, ok := recursiveCodes[typeptr]; ok {
- *recursive.Jmp = *recursiveCode
- continue
- }
-
- code := copyOpcode(codes.First())
- code.Op = code.Op.PtrHeadToHead()
- lastCode := newEndOp(&compileContext{}, recursive.Type)
- lastCode.Op = OpRecursiveEnd
-
- // OpRecursiveEnd must set before call TotalLength
- code.End.Next = lastCode
-
- totalLength := code.TotalLength()
-
- // Idx, ElemIdx, Length must set after call TotalLength
- lastCode.Idx = uint32((totalLength + 1) * uintptrSize)
- lastCode.ElemIdx = lastCode.Idx + uintptrSize
- lastCode.Length = lastCode.Idx + 2*uintptrSize
-
- // extend length to alloc slot for elemIdx + length
- curTotalLength := uintptr(recursive.TotalLength()) + 3
- nextTotalLength := uintptr(totalLength) + 3
-
- compiled := recursive.Jmp
- compiled.Code = code
- compiled.CurLen = curTotalLength
- compiled.NextLen = nextTotalLength
- compiled.Linked = true
-
- recursiveCodes[typeptr] = compiled
- }
-}
diff --git a/vendor/github.com/goccy/go-json/internal/encoder/compiler_norace.go b/vendor/github.com/goccy/go-json/internal/encoder/compiler_norace.go
deleted file mode 100644
index b6f45a49..00000000
--- a/vendor/github.com/goccy/go-json/internal/encoder/compiler_norace.go
+++ /dev/null
@@ -1,33 +0,0 @@
-//go:build !race
-// +build !race
-
-package encoder
-
-func CompileToGetCodeSet(ctx *RuntimeContext, typeptr uintptr) (*OpcodeSet, error) {
- initEncoder()
- if typeptr > typeAddr.MaxTypeAddr || typeptr < typeAddr.BaseTypeAddr {
- codeSet, err := compileToGetCodeSetSlowPath(typeptr)
- if err != nil {
- return nil, err
- }
- return getFilteredCodeSetIfNeeded(ctx, codeSet)
- }
- index := (typeptr - typeAddr.BaseTypeAddr) >> typeAddr.AddrShift
- if codeSet := cachedOpcodeSets[index]; codeSet != nil {
- filtered, err := getFilteredCodeSetIfNeeded(ctx, codeSet)
- if err != nil {
- return nil, err
- }
- return filtered, nil
- }
- codeSet, err := newCompiler().compile(typeptr)
- if err != nil {
- return nil, err
- }
- filtered, err := getFilteredCodeSetIfNeeded(ctx, codeSet)
- if err != nil {
- return nil, err
- }
- cachedOpcodeSets[index] = codeSet
- return filtered, nil
-}
diff --git a/vendor/github.com/goccy/go-json/internal/encoder/compiler_race.go b/vendor/github.com/goccy/go-json/internal/encoder/compiler_race.go
deleted file mode 100644
index 47b482f7..00000000
--- a/vendor/github.com/goccy/go-json/internal/encoder/compiler_race.go
+++ /dev/null
@@ -1,46 +0,0 @@
-//go:build race
-// +build race
-
-package encoder
-
-import (
- "sync"
-)
-
-var setsMu sync.RWMutex
-
-func CompileToGetCodeSet(ctx *RuntimeContext, typeptr uintptr) (*OpcodeSet, error) {
- initEncoder()
- if typeptr > typeAddr.MaxTypeAddr || typeptr < typeAddr.BaseTypeAddr {
- codeSet, err := compileToGetCodeSetSlowPath(typeptr)
- if err != nil {
- return nil, err
- }
- return getFilteredCodeSetIfNeeded(ctx, codeSet)
- }
- index := (typeptr - typeAddr.BaseTypeAddr) >> typeAddr.AddrShift
- setsMu.RLock()
- if codeSet := cachedOpcodeSets[index]; codeSet != nil {
- filtered, err := getFilteredCodeSetIfNeeded(ctx, codeSet)
- if err != nil {
- setsMu.RUnlock()
- return nil, err
- }
- setsMu.RUnlock()
- return filtered, nil
- }
- setsMu.RUnlock()
-
- codeSet, err := newCompiler().compile(typeptr)
- if err != nil {
- return nil, err
- }
- filtered, err := getFilteredCodeSetIfNeeded(ctx, codeSet)
- if err != nil {
- return nil, err
- }
- setsMu.Lock()
- cachedOpcodeSets[index] = codeSet
- setsMu.Unlock()
- return filtered, nil
-}
diff --git a/vendor/github.com/goccy/go-json/internal/encoder/context.go b/vendor/github.com/goccy/go-json/internal/encoder/context.go
deleted file mode 100644
index 3833d0c8..00000000
--- a/vendor/github.com/goccy/go-json/internal/encoder/context.go
+++ /dev/null
@@ -1,105 +0,0 @@
-package encoder
-
-import (
- "context"
- "sync"
- "unsafe"
-
- "github.com/goccy/go-json/internal/runtime"
-)
-
-type compileContext struct {
- opcodeIndex uint32
- ptrIndex int
- indent uint32
- escapeKey bool
- structTypeToCodes map[uintptr]Opcodes
- recursiveCodes *Opcodes
-}
-
-func (c *compileContext) incIndent() {
- c.indent++
-}
-
-func (c *compileContext) decIndent() {
- c.indent--
-}
-
-func (c *compileContext) incIndex() {
- c.incOpcodeIndex()
- c.incPtrIndex()
-}
-
-func (c *compileContext) decIndex() {
- c.decOpcodeIndex()
- c.decPtrIndex()
-}
-
-func (c *compileContext) incOpcodeIndex() {
- c.opcodeIndex++
-}
-
-func (c *compileContext) decOpcodeIndex() {
- c.opcodeIndex--
-}
-
-func (c *compileContext) incPtrIndex() {
- c.ptrIndex++
-}
-
-func (c *compileContext) decPtrIndex() {
- c.ptrIndex--
-}
-
-const (
- bufSize = 1024
-)
-
-var (
- runtimeContextPool = sync.Pool{
- New: func() interface{} {
- return &RuntimeContext{
- Buf: make([]byte, 0, bufSize),
- Ptrs: make([]uintptr, 128),
- KeepRefs: make([]unsafe.Pointer, 0, 8),
- Option: &Option{},
- }
- },
- }
-)
-
-type RuntimeContext struct {
- Context context.Context
- Buf []byte
- MarshalBuf []byte
- Ptrs []uintptr
- KeepRefs []unsafe.Pointer
- SeenPtr []uintptr
- BaseIndent uint32
- Prefix []byte
- IndentStr []byte
- Option *Option
-}
-
-func (c *RuntimeContext) Init(p uintptr, codelen int) {
- if len(c.Ptrs) < codelen {
- c.Ptrs = make([]uintptr, codelen)
- }
- c.Ptrs[0] = p
- c.KeepRefs = c.KeepRefs[:0]
- c.SeenPtr = c.SeenPtr[:0]
- c.BaseIndent = 0
-}
-
-func (c *RuntimeContext) Ptr() uintptr {
- header := (*runtime.SliceHeader)(unsafe.Pointer(&c.Ptrs))
- return uintptr(header.Data)
-}
-
-func TakeRuntimeContext() *RuntimeContext {
- return runtimeContextPool.Get().(*RuntimeContext)
-}
-
-func ReleaseRuntimeContext(ctx *RuntimeContext) {
- runtimeContextPool.Put(ctx)
-}
diff --git a/vendor/github.com/goccy/go-json/internal/encoder/decode_rune.go b/vendor/github.com/goccy/go-json/internal/encoder/decode_rune.go
deleted file mode 100644
index 35c959d4..00000000
--- a/vendor/github.com/goccy/go-json/internal/encoder/decode_rune.go
+++ /dev/null
@@ -1,126 +0,0 @@
-package encoder
-
-import "unicode/utf8"
-
-const (
- // The default lowest and highest continuation byte.
- locb = 128 //0b10000000
- hicb = 191 //0b10111111
-
- // These names of these constants are chosen to give nice alignment in the
- // table below. The first nibble is an index into acceptRanges or F for
- // special one-byte cases. The second nibble is the Rune length or the
- // Status for the special one-byte case.
- xx = 0xF1 // invalid: size 1
- as = 0xF0 // ASCII: size 1
- s1 = 0x02 // accept 0, size 2
- s2 = 0x13 // accept 1, size 3
- s3 = 0x03 // accept 0, size 3
- s4 = 0x23 // accept 2, size 3
- s5 = 0x34 // accept 3, size 4
- s6 = 0x04 // accept 0, size 4
- s7 = 0x44 // accept 4, size 4
-)
-
-// first is information about the first byte in a UTF-8 sequence.
-var first = [256]uint8{
- // 1 2 3 4 5 6 7 8 9 A B C D E F
- as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, // 0x00-0x0F
- as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, // 0x10-0x1F
- as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, // 0x20-0x2F
- as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, // 0x30-0x3F
- as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, // 0x40-0x4F
- as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, // 0x50-0x5F
- as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, // 0x60-0x6F
- as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, // 0x70-0x7F
- // 1 2 3 4 5 6 7 8 9 A B C D E F
- xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, // 0x80-0x8F
- xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, // 0x90-0x9F
- xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, // 0xA0-0xAF
- xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, // 0xB0-0xBF
- xx, xx, s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, // 0xC0-0xCF
- s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, // 0xD0-0xDF
- s2, s3, s3, s3, s3, s3, s3, s3, s3, s3, s3, s3, s3, s4, s3, s3, // 0xE0-0xEF
- s5, s6, s6, s6, s7, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, // 0xF0-0xFF
-}
-
-const (
- lineSep = byte(168) //'\u2028'
- paragraphSep = byte(169) //'\u2029'
-)
-
-type decodeRuneState int
-
-const (
- validUTF8State decodeRuneState = iota
- runeErrorState
- lineSepState
- paragraphSepState
-)
-
-func decodeRuneInString(s string) (decodeRuneState, int) {
- n := len(s)
- s0 := s[0]
- x := first[s0]
- if x >= as {
- // The following code simulates an additional check for x == xx and
- // handling the ASCII and invalid cases accordingly. This mask-and-or
- // approach prevents an additional branch.
- mask := rune(x) << 31 >> 31 // Create 0x0000 or 0xFFFF.
- if rune(s[0])&^mask|utf8.RuneError&mask == utf8.RuneError {
- return runeErrorState, 1
- }
- return validUTF8State, 1
- }
- sz := int(x & 7)
- if n < sz {
- return runeErrorState, 1
- }
- s1 := s[1]
- switch x >> 4 {
- case 0:
- if s1 < locb || hicb < s1 {
- return runeErrorState, 1
- }
- case 1:
- if s1 < 0xA0 || hicb < s1 {
- return runeErrorState, 1
- }
- case 2:
- if s1 < locb || 0x9F < s1 {
- return runeErrorState, 1
- }
- case 3:
- if s1 < 0x90 || hicb < s1 {
- return runeErrorState, 1
- }
- case 4:
- if s1 < locb || 0x8F < s1 {
- return runeErrorState, 1
- }
- }
- if sz <= 2 {
- return validUTF8State, 2
- }
- s2 := s[2]
- if s2 < locb || hicb < s2 {
- return runeErrorState, 1
- }
- if sz <= 3 {
- // separator character prefixes: [2]byte{226, 128}
- if s0 == 226 && s1 == 128 {
- switch s2 {
- case lineSep:
- return lineSepState, 3
- case paragraphSep:
- return paragraphSepState, 3
- }
- }
- return validUTF8State, 3
- }
- s3 := s[3]
- if s3 < locb || hicb < s3 {
- return runeErrorState, 1
- }
- return validUTF8State, 4
-}
diff --git a/vendor/github.com/goccy/go-json/internal/encoder/encoder.go b/vendor/github.com/goccy/go-json/internal/encoder/encoder.go
deleted file mode 100644
index b436f5b2..00000000
--- a/vendor/github.com/goccy/go-json/internal/encoder/encoder.go
+++ /dev/null
@@ -1,601 +0,0 @@
-package encoder
-
-import (
- "bytes"
- "encoding"
- "encoding/base64"
- "encoding/json"
- "fmt"
- "math"
- "reflect"
- "strconv"
- "strings"
- "sync"
- "unsafe"
-
- "github.com/goccy/go-json/internal/errors"
- "github.com/goccy/go-json/internal/runtime"
-)
-
-func (t OpType) IsMultipleOpHead() bool {
- switch t {
- case OpStructHead:
- return true
- case OpStructHeadSlice:
- return true
- case OpStructHeadArray:
- return true
- case OpStructHeadMap:
- return true
- case OpStructHeadStruct:
- return true
- case OpStructHeadOmitEmpty:
- return true
- case OpStructHeadOmitEmptySlice:
- return true
- case OpStructHeadOmitEmptyArray:
- return true
- case OpStructHeadOmitEmptyMap:
- return true
- case OpStructHeadOmitEmptyStruct:
- return true
- case OpStructHeadSlicePtr:
- return true
- case OpStructHeadOmitEmptySlicePtr:
- return true
- case OpStructHeadArrayPtr:
- return true
- case OpStructHeadOmitEmptyArrayPtr:
- return true
- case OpStructHeadMapPtr:
- return true
- case OpStructHeadOmitEmptyMapPtr:
- return true
- }
- return false
-}
-
-func (t OpType) IsMultipleOpField() bool {
- switch t {
- case OpStructField:
- return true
- case OpStructFieldSlice:
- return true
- case OpStructFieldArray:
- return true
- case OpStructFieldMap:
- return true
- case OpStructFieldStruct:
- return true
- case OpStructFieldOmitEmpty:
- return true
- case OpStructFieldOmitEmptySlice:
- return true
- case OpStructFieldOmitEmptyArray:
- return true
- case OpStructFieldOmitEmptyMap:
- return true
- case OpStructFieldOmitEmptyStruct:
- return true
- case OpStructFieldSlicePtr:
- return true
- case OpStructFieldOmitEmptySlicePtr:
- return true
- case OpStructFieldArrayPtr:
- return true
- case OpStructFieldOmitEmptyArrayPtr:
- return true
- case OpStructFieldMapPtr:
- return true
- case OpStructFieldOmitEmptyMapPtr:
- return true
- }
- return false
-}
-
-type OpcodeSet struct {
- Type *runtime.Type
- NoescapeKeyCode *Opcode
- EscapeKeyCode *Opcode
- InterfaceNoescapeKeyCode *Opcode
- InterfaceEscapeKeyCode *Opcode
- CodeLength int
- EndCode *Opcode
- Code Code
- QueryCache map[string]*OpcodeSet
- cacheMu sync.RWMutex
-}
-
-func (s *OpcodeSet) getQueryCache(hash string) *OpcodeSet {
- s.cacheMu.RLock()
- codeSet := s.QueryCache[hash]
- s.cacheMu.RUnlock()
- return codeSet
-}
-
-func (s *OpcodeSet) setQueryCache(hash string, codeSet *OpcodeSet) {
- s.cacheMu.Lock()
- s.QueryCache[hash] = codeSet
- s.cacheMu.Unlock()
-}
-
-type CompiledCode struct {
- Code *Opcode
- Linked bool // whether recursive code already have linked
- CurLen uintptr
- NextLen uintptr
-}
-
-const StartDetectingCyclesAfter = 1000
-
-func Load(base uintptr, idx uintptr) uintptr {
- addr := base + idx
- return **(**uintptr)(unsafe.Pointer(&addr))
-}
-
-func Store(base uintptr, idx uintptr, p uintptr) {
- addr := base + idx
- **(**uintptr)(unsafe.Pointer(&addr)) = p
-}
-
-func LoadNPtr(base uintptr, idx uintptr, ptrNum int) uintptr {
- addr := base + idx
- p := **(**uintptr)(unsafe.Pointer(&addr))
- if p == 0 {
- return 0
- }
- return PtrToPtr(p)
- /*
- for i := 0; i < ptrNum; i++ {
- if p == 0 {
- return p
- }
- p = PtrToPtr(p)
- }
- return p
- */
-}
-
-func PtrToUint64(p uintptr) uint64 { return **(**uint64)(unsafe.Pointer(&p)) }
-func PtrToFloat32(p uintptr) float32 { return **(**float32)(unsafe.Pointer(&p)) }
-func PtrToFloat64(p uintptr) float64 { return **(**float64)(unsafe.Pointer(&p)) }
-func PtrToBool(p uintptr) bool { return **(**bool)(unsafe.Pointer(&p)) }
-func PtrToBytes(p uintptr) []byte { return **(**[]byte)(unsafe.Pointer(&p)) }
-func PtrToNumber(p uintptr) json.Number { return **(**json.Number)(unsafe.Pointer(&p)) }
-func PtrToString(p uintptr) string { return **(**string)(unsafe.Pointer(&p)) }
-func PtrToSlice(p uintptr) *runtime.SliceHeader { return *(**runtime.SliceHeader)(unsafe.Pointer(&p)) }
-func PtrToPtr(p uintptr) uintptr {
- return uintptr(**(**unsafe.Pointer)(unsafe.Pointer(&p)))
-}
-func PtrToNPtr(p uintptr, ptrNum int) uintptr {
- for i := 0; i < ptrNum; i++ {
- if p == 0 {
- return 0
- }
- p = PtrToPtr(p)
- }
- return p
-}
-
-func PtrToUnsafePtr(p uintptr) unsafe.Pointer {
- return *(*unsafe.Pointer)(unsafe.Pointer(&p))
-}
-func PtrToInterface(code *Opcode, p uintptr) interface{} {
- return *(*interface{})(unsafe.Pointer(&emptyInterface{
- typ: code.Type,
- ptr: *(*unsafe.Pointer)(unsafe.Pointer(&p)),
- }))
-}
-
-func ErrUnsupportedValue(code *Opcode, ptr uintptr) *errors.UnsupportedValueError {
- v := *(*interface{})(unsafe.Pointer(&emptyInterface{
- typ: code.Type,
- ptr: *(*unsafe.Pointer)(unsafe.Pointer(&ptr)),
- }))
- return &errors.UnsupportedValueError{
- Value: reflect.ValueOf(v),
- Str: fmt.Sprintf("encountered a cycle via %s", code.Type),
- }
-}
-
-func ErrUnsupportedFloat(v float64) *errors.UnsupportedValueError {
- return &errors.UnsupportedValueError{
- Value: reflect.ValueOf(v),
- Str: strconv.FormatFloat(v, 'g', -1, 64),
- }
-}
-
-func ErrMarshalerWithCode(code *Opcode, err error) *errors.MarshalerError {
- return &errors.MarshalerError{
- Type: runtime.RType2Type(code.Type),
- Err: err,
- }
-}
-
-type emptyInterface struct {
- typ *runtime.Type
- ptr unsafe.Pointer
-}
-
-type MapItem struct {
- Key []byte
- Value []byte
-}
-
-type Mapslice struct {
- Items []MapItem
-}
-
-func (m *Mapslice) Len() int {
- return len(m.Items)
-}
-
-func (m *Mapslice) Less(i, j int) bool {
- return bytes.Compare(m.Items[i].Key, m.Items[j].Key) < 0
-}
-
-func (m *Mapslice) Swap(i, j int) {
- m.Items[i], m.Items[j] = m.Items[j], m.Items[i]
-}
-
-//nolint:structcheck,unused
-type mapIter struct {
- key unsafe.Pointer
- elem unsafe.Pointer
- t unsafe.Pointer
- h unsafe.Pointer
- buckets unsafe.Pointer
- bptr unsafe.Pointer
- overflow unsafe.Pointer
- oldoverflow unsafe.Pointer
- startBucket uintptr
- offset uint8
- wrapped bool
- B uint8
- i uint8
- bucket uintptr
- checkBucket uintptr
-}
-
-type MapContext struct {
- Start int
- First int
- Idx int
- Slice *Mapslice
- Buf []byte
- Len int
- Iter mapIter
-}
-
-var mapContextPool = sync.Pool{
- New: func() interface{} {
- return &MapContext{
- Slice: &Mapslice{},
- }
- },
-}
-
-func NewMapContext(mapLen int, unorderedMap bool) *MapContext {
- ctx := mapContextPool.Get().(*MapContext)
- if !unorderedMap {
- if len(ctx.Slice.Items) < mapLen {
- ctx.Slice.Items = make([]MapItem, mapLen)
- } else {
- ctx.Slice.Items = ctx.Slice.Items[:mapLen]
- }
- }
- ctx.Buf = ctx.Buf[:0]
- ctx.Iter = mapIter{}
- ctx.Idx = 0
- ctx.Len = mapLen
- return ctx
-}
-
-func ReleaseMapContext(c *MapContext) {
- mapContextPool.Put(c)
-}
-
-//go:linkname MapIterInit runtime.mapiterinit
-//go:noescape
-func MapIterInit(mapType *runtime.Type, m unsafe.Pointer, it *mapIter)
-
-//go:linkname MapIterKey reflect.mapiterkey
-//go:noescape
-func MapIterKey(it *mapIter) unsafe.Pointer
-
-//go:linkname MapIterNext reflect.mapiternext
-//go:noescape
-func MapIterNext(it *mapIter)
-
-//go:linkname MapLen reflect.maplen
-//go:noescape
-func MapLen(m unsafe.Pointer) int
-
-func AppendByteSlice(_ *RuntimeContext, b []byte, src []byte) []byte {
- if src == nil {
- return append(b, `null`...)
- }
- encodedLen := base64.StdEncoding.EncodedLen(len(src))
- b = append(b, '"')
- pos := len(b)
- remainLen := cap(b[pos:])
- var buf []byte
- if remainLen > encodedLen {
- buf = b[pos : pos+encodedLen]
- } else {
- buf = make([]byte, encodedLen)
- }
- base64.StdEncoding.Encode(buf, src)
- return append(append(b, buf...), '"')
-}
-
-func AppendFloat32(_ *RuntimeContext, b []byte, v float32) []byte {
- f64 := float64(v)
- abs := math.Abs(f64)
- fmt := byte('f')
- // Note: Must use float32 comparisons for underlying float32 value to get precise cutoffs right.
- if abs != 0 {
- f32 := float32(abs)
- if f32 < 1e-6 || f32 >= 1e21 {
- fmt = 'e'
- }
- }
- return strconv.AppendFloat(b, f64, fmt, -1, 32)
-}
-
-func AppendFloat64(_ *RuntimeContext, b []byte, v float64) []byte {
- abs := math.Abs(v)
- fmt := byte('f')
- // Note: Must use float32 comparisons for underlying float32 value to get precise cutoffs right.
- if abs != 0 {
- if abs < 1e-6 || abs >= 1e21 {
- fmt = 'e'
- }
- }
- return strconv.AppendFloat(b, v, fmt, -1, 64)
-}
-
-func AppendBool(_ *RuntimeContext, b []byte, v bool) []byte {
- if v {
- return append(b, "true"...)
- }
- return append(b, "false"...)
-}
-
-var (
- floatTable = [256]bool{
- '0': true,
- '1': true,
- '2': true,
- '3': true,
- '4': true,
- '5': true,
- '6': true,
- '7': true,
- '8': true,
- '9': true,
- '.': true,
- 'e': true,
- 'E': true,
- '+': true,
- '-': true,
- }
-)
-
-func AppendNumber(_ *RuntimeContext, b []byte, n json.Number) ([]byte, error) {
- if len(n) == 0 {
- return append(b, '0'), nil
- }
- for i := 0; i < len(n); i++ {
- if !floatTable[n[i]] {
- return nil, fmt.Errorf("json: invalid number literal %q", n)
- }
- }
- b = append(b, n...)
- return b, nil
-}
-
-func AppendMarshalJSON(ctx *RuntimeContext, code *Opcode, b []byte, v interface{}) ([]byte, error) {
- rv := reflect.ValueOf(v) // convert by dynamic interface type
- if (code.Flags & AddrForMarshalerFlags) != 0 {
- if rv.CanAddr() {
- rv = rv.Addr()
- } else {
- newV := reflect.New(rv.Type())
- newV.Elem().Set(rv)
- rv = newV
- }
- }
-
- if rv.Kind() == reflect.Ptr && rv.IsNil() {
- return AppendNull(ctx, b), nil
- }
-
- v = rv.Interface()
- var bb []byte
- if (code.Flags & MarshalerContextFlags) != 0 {
- marshaler, ok := v.(marshalerContext)
- if !ok {
- return AppendNull(ctx, b), nil
- }
- stdctx := ctx.Option.Context
- if ctx.Option.Flag&FieldQueryOption != 0 {
- stdctx = SetFieldQueryToContext(stdctx, code.FieldQuery)
- }
- b, err := marshaler.MarshalJSON(stdctx)
- if err != nil {
- return nil, &errors.MarshalerError{Type: reflect.TypeOf(v), Err: err}
- }
- bb = b
- } else {
- marshaler, ok := v.(json.Marshaler)
- if !ok {
- return AppendNull(ctx, b), nil
- }
- b, err := marshaler.MarshalJSON()
- if err != nil {
- return nil, &errors.MarshalerError{Type: reflect.TypeOf(v), Err: err}
- }
- bb = b
- }
- marshalBuf := ctx.MarshalBuf[:0]
- marshalBuf = append(append(marshalBuf, bb...), nul)
- compactedBuf, err := compact(b, marshalBuf, (ctx.Option.Flag&HTMLEscapeOption) != 0)
- if err != nil {
- return nil, &errors.MarshalerError{Type: reflect.TypeOf(v), Err: err}
- }
- ctx.MarshalBuf = marshalBuf
- return compactedBuf, nil
-}
-
-func AppendMarshalJSONIndent(ctx *RuntimeContext, code *Opcode, b []byte, v interface{}) ([]byte, error) {
- rv := reflect.ValueOf(v) // convert by dynamic interface type
- if (code.Flags & AddrForMarshalerFlags) != 0 {
- if rv.CanAddr() {
- rv = rv.Addr()
- } else {
- newV := reflect.New(rv.Type())
- newV.Elem().Set(rv)
- rv = newV
- }
- }
- v = rv.Interface()
- var bb []byte
- if (code.Flags & MarshalerContextFlags) != 0 {
- marshaler, ok := v.(marshalerContext)
- if !ok {
- return AppendNull(ctx, b), nil
- }
- b, err := marshaler.MarshalJSON(ctx.Option.Context)
- if err != nil {
- return nil, &errors.MarshalerError{Type: reflect.TypeOf(v), Err: err}
- }
- bb = b
- } else {
- marshaler, ok := v.(json.Marshaler)
- if !ok {
- return AppendNull(ctx, b), nil
- }
- b, err := marshaler.MarshalJSON()
- if err != nil {
- return nil, &errors.MarshalerError{Type: reflect.TypeOf(v), Err: err}
- }
- bb = b
- }
- marshalBuf := ctx.MarshalBuf[:0]
- marshalBuf = append(append(marshalBuf, bb...), nul)
- indentedBuf, err := doIndent(
- b,
- marshalBuf,
- string(ctx.Prefix)+strings.Repeat(string(ctx.IndentStr), int(ctx.BaseIndent+code.Indent)),
- string(ctx.IndentStr),
- (ctx.Option.Flag&HTMLEscapeOption) != 0,
- )
- if err != nil {
- return nil, &errors.MarshalerError{Type: reflect.TypeOf(v), Err: err}
- }
- ctx.MarshalBuf = marshalBuf
- return indentedBuf, nil
-}
-
-func AppendMarshalText(ctx *RuntimeContext, code *Opcode, b []byte, v interface{}) ([]byte, error) {
- rv := reflect.ValueOf(v) // convert by dynamic interface type
- if (code.Flags & AddrForMarshalerFlags) != 0 {
- if rv.CanAddr() {
- rv = rv.Addr()
- } else {
- newV := reflect.New(rv.Type())
- newV.Elem().Set(rv)
- rv = newV
- }
- }
- v = rv.Interface()
- marshaler, ok := v.(encoding.TextMarshaler)
- if !ok {
- return AppendNull(ctx, b), nil
- }
- bytes, err := marshaler.MarshalText()
- if err != nil {
- return nil, &errors.MarshalerError{Type: reflect.TypeOf(v), Err: err}
- }
- return AppendString(ctx, b, *(*string)(unsafe.Pointer(&bytes))), nil
-}
-
-func AppendMarshalTextIndent(ctx *RuntimeContext, code *Opcode, b []byte, v interface{}) ([]byte, error) {
- rv := reflect.ValueOf(v) // convert by dynamic interface type
- if (code.Flags & AddrForMarshalerFlags) != 0 {
- if rv.CanAddr() {
- rv = rv.Addr()
- } else {
- newV := reflect.New(rv.Type())
- newV.Elem().Set(rv)
- rv = newV
- }
- }
- v = rv.Interface()
- marshaler, ok := v.(encoding.TextMarshaler)
- if !ok {
- return AppendNull(ctx, b), nil
- }
- bytes, err := marshaler.MarshalText()
- if err != nil {
- return nil, &errors.MarshalerError{Type: reflect.TypeOf(v), Err: err}
- }
- return AppendString(ctx, b, *(*string)(unsafe.Pointer(&bytes))), nil
-}
-
-func AppendNull(_ *RuntimeContext, b []byte) []byte {
- return append(b, "null"...)
-}
-
-func AppendComma(_ *RuntimeContext, b []byte) []byte {
- return append(b, ',')
-}
-
-func AppendCommaIndent(_ *RuntimeContext, b []byte) []byte {
- return append(b, ',', '\n')
-}
-
-func AppendStructEnd(_ *RuntimeContext, b []byte) []byte {
- return append(b, '}', ',')
-}
-
-func AppendStructEndIndent(ctx *RuntimeContext, code *Opcode, b []byte) []byte {
- b = append(b, '\n')
- b = append(b, ctx.Prefix...)
- indentNum := ctx.BaseIndent + code.Indent - 1
- for i := uint32(0); i < indentNum; i++ {
- b = append(b, ctx.IndentStr...)
- }
- return append(b, '}', ',', '\n')
-}
-
-func AppendIndent(ctx *RuntimeContext, b []byte, indent uint32) []byte {
- b = append(b, ctx.Prefix...)
- indentNum := ctx.BaseIndent + indent
- for i := uint32(0); i < indentNum; i++ {
- b = append(b, ctx.IndentStr...)
- }
- return b
-}
-
-func IsNilForMarshaler(v interface{}) bool {
- rv := reflect.ValueOf(v)
- switch rv.Kind() {
- case reflect.Bool:
- return !rv.Bool()
- case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
- return rv.Int() == 0
- case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
- return rv.Uint() == 0
- case reflect.Float32, reflect.Float64:
- return math.Float64bits(rv.Float()) == 0
- case reflect.Interface, reflect.Map, reflect.Ptr, reflect.Func:
- return rv.IsNil()
- case reflect.Slice:
- return rv.IsNil() || rv.Len() == 0
- case reflect.String:
- return rv.Len() == 0
- }
- return false
-}
diff --git a/vendor/github.com/goccy/go-json/internal/encoder/indent.go b/vendor/github.com/goccy/go-json/internal/encoder/indent.go
deleted file mode 100644
index dfe04b5e..00000000
--- a/vendor/github.com/goccy/go-json/internal/encoder/indent.go
+++ /dev/null
@@ -1,211 +0,0 @@
-package encoder
-
-import (
- "bytes"
- "fmt"
-
- "github.com/goccy/go-json/internal/errors"
-)
-
-func takeIndentSrcRuntimeContext(src []byte) (*RuntimeContext, []byte) {
- ctx := TakeRuntimeContext()
- buf := ctx.Buf[:0]
- buf = append(append(buf, src...), nul)
- ctx.Buf = buf
- return ctx, buf
-}
-
-func Indent(buf *bytes.Buffer, src []byte, prefix, indentStr string) error {
- if len(src) == 0 {
- return errors.ErrUnexpectedEndOfJSON("", 0)
- }
-
- srcCtx, srcBuf := takeIndentSrcRuntimeContext(src)
- dstCtx := TakeRuntimeContext()
- dst := dstCtx.Buf[:0]
-
- dst, err := indentAndWrite(buf, dst, srcBuf, prefix, indentStr)
- if err != nil {
- ReleaseRuntimeContext(srcCtx)
- ReleaseRuntimeContext(dstCtx)
- return err
- }
- dstCtx.Buf = dst
- ReleaseRuntimeContext(srcCtx)
- ReleaseRuntimeContext(dstCtx)
- return nil
-}
-
-func indentAndWrite(buf *bytes.Buffer, dst []byte, src []byte, prefix, indentStr string) ([]byte, error) {
- dst, err := doIndent(dst, src, prefix, indentStr, false)
- if err != nil {
- return nil, err
- }
- if _, err := buf.Write(dst); err != nil {
- return nil, err
- }
- return dst, nil
-}
-
-func doIndent(dst, src []byte, prefix, indentStr string, escape bool) ([]byte, error) {
- buf, cursor, err := indentValue(dst, src, 0, 0, []byte(prefix), []byte(indentStr), escape)
- if err != nil {
- return nil, err
- }
- if err := validateEndBuf(src, cursor); err != nil {
- return nil, err
- }
- return buf, nil
-}
-
-func indentValue(
- dst []byte,
- src []byte,
- indentNum int,
- cursor int64,
- prefix []byte,
- indentBytes []byte,
- escape bool) ([]byte, int64, error) {
- for {
- switch src[cursor] {
- case ' ', '\t', '\n', '\r':
- cursor++
- continue
- case '{':
- return indentObject(dst, src, indentNum, cursor, prefix, indentBytes, escape)
- case '}':
- return nil, 0, errors.ErrSyntax("unexpected character '}'", cursor)
- case '[':
- return indentArray(dst, src, indentNum, cursor, prefix, indentBytes, escape)
- case ']':
- return nil, 0, errors.ErrSyntax("unexpected character ']'", cursor)
- case '"':
- return compactString(dst, src, cursor, escape)
- case '-', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
- return compactNumber(dst, src, cursor)
- case 't':
- return compactTrue(dst, src, cursor)
- case 'f':
- return compactFalse(dst, src, cursor)
- case 'n':
- return compactNull(dst, src, cursor)
- default:
- return nil, 0, errors.ErrSyntax(fmt.Sprintf("unexpected character '%c'", src[cursor]), cursor)
- }
- }
-}
-
-func indentObject(
- dst []byte,
- src []byte,
- indentNum int,
- cursor int64,
- prefix []byte,
- indentBytes []byte,
- escape bool) ([]byte, int64, error) {
- if src[cursor] == '{' {
- dst = append(dst, '{')
- } else {
- return nil, 0, errors.ErrExpected("expected { character for object value", cursor)
- }
- cursor = skipWhiteSpace(src, cursor+1)
- if src[cursor] == '}' {
- dst = append(dst, '}')
- return dst, cursor + 1, nil
- }
- indentNum++
- var err error
- for {
- dst = append(append(dst, '\n'), prefix...)
- for i := 0; i < indentNum; i++ {
- dst = append(dst, indentBytes...)
- }
- cursor = skipWhiteSpace(src, cursor)
- dst, cursor, err = compactString(dst, src, cursor, escape)
- if err != nil {
- return nil, 0, err
- }
- cursor = skipWhiteSpace(src, cursor)
- if src[cursor] != ':' {
- return nil, 0, errors.ErrSyntax(
- fmt.Sprintf("invalid character '%c' after object key", src[cursor]),
- cursor+1,
- )
- }
- dst = append(dst, ':', ' ')
- dst, cursor, err = indentValue(dst, src, indentNum, cursor+1, prefix, indentBytes, escape)
- if err != nil {
- return nil, 0, err
- }
- cursor = skipWhiteSpace(src, cursor)
- switch src[cursor] {
- case '}':
- dst = append(append(dst, '\n'), prefix...)
- for i := 0; i < indentNum-1; i++ {
- dst = append(dst, indentBytes...)
- }
- dst = append(dst, '}')
- cursor++
- return dst, cursor, nil
- case ',':
- dst = append(dst, ',')
- default:
- return nil, 0, errors.ErrSyntax(
- fmt.Sprintf("invalid character '%c' after object key:value pair", src[cursor]),
- cursor+1,
- )
- }
- cursor++
- }
-}
-
-func indentArray(
- dst []byte,
- src []byte,
- indentNum int,
- cursor int64,
- prefix []byte,
- indentBytes []byte,
- escape bool) ([]byte, int64, error) {
- if src[cursor] == '[' {
- dst = append(dst, '[')
- } else {
- return nil, 0, errors.ErrExpected("expected [ character for array value", cursor)
- }
- cursor = skipWhiteSpace(src, cursor+1)
- if src[cursor] == ']' {
- dst = append(dst, ']')
- return dst, cursor + 1, nil
- }
- indentNum++
- var err error
- for {
- dst = append(append(dst, '\n'), prefix...)
- for i := 0; i < indentNum; i++ {
- dst = append(dst, indentBytes...)
- }
- dst, cursor, err = indentValue(dst, src, indentNum, cursor, prefix, indentBytes, escape)
- if err != nil {
- return nil, 0, err
- }
- cursor = skipWhiteSpace(src, cursor)
- switch src[cursor] {
- case ']':
- dst = append(append(dst, '\n'), prefix...)
- for i := 0; i < indentNum-1; i++ {
- dst = append(dst, indentBytes...)
- }
- dst = append(dst, ']')
- cursor++
- return dst, cursor, nil
- case ',':
- dst = append(dst, ',')
- default:
- return nil, 0, errors.ErrSyntax(
- fmt.Sprintf("invalid character '%c' after array value", src[cursor]),
- cursor+1,
- )
- }
- cursor++
- }
-}
diff --git a/vendor/github.com/goccy/go-json/internal/encoder/int.go b/vendor/github.com/goccy/go-json/internal/encoder/int.go
deleted file mode 100644
index 8b5febea..00000000
--- a/vendor/github.com/goccy/go-json/internal/encoder/int.go
+++ /dev/null
@@ -1,176 +0,0 @@
-// This files's processing codes are inspired by https://github.com/segmentio/encoding.
-// The license notation is as follows.
-//
-// # MIT License
-//
-// Copyright (c) 2019 Segment.io, Inc.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-package encoder
-
-import (
- "unsafe"
-)
-
-var endianness int
-
-func init() {
- var b [2]byte
- *(*uint16)(unsafe.Pointer(&b)) = uint16(0xABCD)
-
- switch b[0] {
- case 0xCD:
- endianness = 0 // LE
- case 0xAB:
- endianness = 1 // BE
- default:
- panic("could not determine endianness")
- }
-}
-
-// "00010203...96979899" cast to []uint16
-var intLELookup = [100]uint16{
- 0x3030, 0x3130, 0x3230, 0x3330, 0x3430, 0x3530, 0x3630, 0x3730, 0x3830, 0x3930,
- 0x3031, 0x3131, 0x3231, 0x3331, 0x3431, 0x3531, 0x3631, 0x3731, 0x3831, 0x3931,
- 0x3032, 0x3132, 0x3232, 0x3332, 0x3432, 0x3532, 0x3632, 0x3732, 0x3832, 0x3932,
- 0x3033, 0x3133, 0x3233, 0x3333, 0x3433, 0x3533, 0x3633, 0x3733, 0x3833, 0x3933,
- 0x3034, 0x3134, 0x3234, 0x3334, 0x3434, 0x3534, 0x3634, 0x3734, 0x3834, 0x3934,
- 0x3035, 0x3135, 0x3235, 0x3335, 0x3435, 0x3535, 0x3635, 0x3735, 0x3835, 0x3935,
- 0x3036, 0x3136, 0x3236, 0x3336, 0x3436, 0x3536, 0x3636, 0x3736, 0x3836, 0x3936,
- 0x3037, 0x3137, 0x3237, 0x3337, 0x3437, 0x3537, 0x3637, 0x3737, 0x3837, 0x3937,
- 0x3038, 0x3138, 0x3238, 0x3338, 0x3438, 0x3538, 0x3638, 0x3738, 0x3838, 0x3938,
- 0x3039, 0x3139, 0x3239, 0x3339, 0x3439, 0x3539, 0x3639, 0x3739, 0x3839, 0x3939,
-}
-
-var intBELookup = [100]uint16{
- 0x3030, 0x3031, 0x3032, 0x3033, 0x3034, 0x3035, 0x3036, 0x3037, 0x3038, 0x3039,
- 0x3130, 0x3131, 0x3132, 0x3133, 0x3134, 0x3135, 0x3136, 0x3137, 0x3138, 0x3139,
- 0x3230, 0x3231, 0x3232, 0x3233, 0x3234, 0x3235, 0x3236, 0x3237, 0x3238, 0x3239,
- 0x3330, 0x3331, 0x3332, 0x3333, 0x3334, 0x3335, 0x3336, 0x3337, 0x3338, 0x3339,
- 0x3430, 0x3431, 0x3432, 0x3433, 0x3434, 0x3435, 0x3436, 0x3437, 0x3438, 0x3439,
- 0x3530, 0x3531, 0x3532, 0x3533, 0x3534, 0x3535, 0x3536, 0x3537, 0x3538, 0x3539,
- 0x3630, 0x3631, 0x3632, 0x3633, 0x3634, 0x3635, 0x3636, 0x3637, 0x3638, 0x3639,
- 0x3730, 0x3731, 0x3732, 0x3733, 0x3734, 0x3735, 0x3736, 0x3737, 0x3738, 0x3739,
- 0x3830, 0x3831, 0x3832, 0x3833, 0x3834, 0x3835, 0x3836, 0x3837, 0x3838, 0x3839,
- 0x3930, 0x3931, 0x3932, 0x3933, 0x3934, 0x3935, 0x3936, 0x3937, 0x3938, 0x3939,
-}
-
-var intLookup = [2]*[100]uint16{&intLELookup, &intBELookup}
-
-func numMask(numBitSize uint8) uint64 {
- return 1<>(code.NumBitSize-1))&1 == 1
- if !negative {
- if n < 10 {
- return append(out, byte(n+'0'))
- } else if n < 100 {
- u := intLELookup[n]
- return append(out, byte(u), byte(u>>8))
- }
- } else {
- n = -n & mask
- }
-
- lookup := intLookup[endianness]
-
- var b [22]byte
- u := (*[11]uint16)(unsafe.Pointer(&b))
- i := 11
-
- for n >= 100 {
- j := n % 100
- n /= 100
- i--
- u[i] = lookup[j]
- }
-
- i--
- u[i] = lookup[n]
-
- i *= 2 // convert to byte index
- if n < 10 {
- i++ // remove leading zero
- }
- if negative {
- i--
- b[i] = '-'
- }
-
- return append(out, b[i:]...)
-}
-
-func AppendUint(_ *RuntimeContext, out []byte, p uintptr, code *Opcode) []byte {
- var u64 uint64
- switch code.NumBitSize {
- case 8:
- u64 = (uint64)(**(**uint8)(unsafe.Pointer(&p)))
- case 16:
- u64 = (uint64)(**(**uint16)(unsafe.Pointer(&p)))
- case 32:
- u64 = (uint64)(**(**uint32)(unsafe.Pointer(&p)))
- case 64:
- u64 = **(**uint64)(unsafe.Pointer(&p))
- }
- mask := numMask(code.NumBitSize)
- n := u64 & mask
- if n < 10 {
- return append(out, byte(n+'0'))
- } else if n < 100 {
- u := intLELookup[n]
- return append(out, byte(u), byte(u>>8))
- }
-
- lookup := intLookup[endianness]
-
- var b [22]byte
- u := (*[11]uint16)(unsafe.Pointer(&b))
- i := 11
-
- for n >= 100 {
- j := n % 100
- n /= 100
- i--
- u[i] = lookup[j]
- }
-
- i--
- u[i] = lookup[n]
-
- i *= 2 // convert to byte index
- if n < 10 {
- i++ // remove leading zero
- }
- return append(out, b[i:]...)
-}
diff --git a/vendor/github.com/goccy/go-json/internal/encoder/map112.go b/vendor/github.com/goccy/go-json/internal/encoder/map112.go
deleted file mode 100644
index e96ffadf..00000000
--- a/vendor/github.com/goccy/go-json/internal/encoder/map112.go
+++ /dev/null
@@ -1,9 +0,0 @@
-//go:build !go1.13
-// +build !go1.13
-
-package encoder
-
-import "unsafe"
-
-//go:linkname MapIterValue reflect.mapitervalue
-func MapIterValue(it *mapIter) unsafe.Pointer
diff --git a/vendor/github.com/goccy/go-json/internal/encoder/map113.go b/vendor/github.com/goccy/go-json/internal/encoder/map113.go
deleted file mode 100644
index 9b69dcc3..00000000
--- a/vendor/github.com/goccy/go-json/internal/encoder/map113.go
+++ /dev/null
@@ -1,9 +0,0 @@
-//go:build go1.13
-// +build go1.13
-
-package encoder
-
-import "unsafe"
-
-//go:linkname MapIterValue reflect.mapiterelem
-func MapIterValue(it *mapIter) unsafe.Pointer
diff --git a/vendor/github.com/goccy/go-json/internal/encoder/opcode.go b/vendor/github.com/goccy/go-json/internal/encoder/opcode.go
deleted file mode 100644
index df22f554..00000000
--- a/vendor/github.com/goccy/go-json/internal/encoder/opcode.go
+++ /dev/null
@@ -1,752 +0,0 @@
-package encoder
-
-import (
- "bytes"
- "fmt"
- "sort"
- "strings"
- "unsafe"
-
- "github.com/goccy/go-json/internal/runtime"
-)
-
-const uintptrSize = 4 << (^uintptr(0) >> 63)
-
-type OpFlags uint16
-
-const (
- AnonymousHeadFlags OpFlags = 1 << 0
- AnonymousKeyFlags OpFlags = 1 << 1
- IndirectFlags OpFlags = 1 << 2
- IsTaggedKeyFlags OpFlags = 1 << 3
- NilCheckFlags OpFlags = 1 << 4
- AddrForMarshalerFlags OpFlags = 1 << 5
- IsNextOpPtrTypeFlags OpFlags = 1 << 6
- IsNilableTypeFlags OpFlags = 1 << 7
- MarshalerContextFlags OpFlags = 1 << 8
- NonEmptyInterfaceFlags OpFlags = 1 << 9
-)
-
-type Opcode struct {
- Op OpType // operation type
- Idx uint32 // offset to access ptr
- Next *Opcode // next opcode
- End *Opcode // array/slice/struct/map end
- NextField *Opcode // next struct field
- Key string // struct field key
- Offset uint32 // offset size from struct header
- PtrNum uint8 // pointer number: e.g. double pointer is 2.
- NumBitSize uint8
- Flags OpFlags
-
- Type *runtime.Type // go type
- Jmp *CompiledCode // for recursive call
- FieldQuery *FieldQuery // field query for Interface / MarshalJSON / MarshalText
- ElemIdx uint32 // offset to access array/slice elem
- Length uint32 // offset to access slice length or array length
- Indent uint32 // indent number
- Size uint32 // array/slice elem size
- DisplayIdx uint32 // opcode index
- DisplayKey string // key text to display
-}
-
-func (c *Opcode) Validate() error {
- var prevIdx uint32
- for code := c; !code.IsEnd(); {
- if prevIdx != 0 {
- if code.DisplayIdx != prevIdx+1 {
- return fmt.Errorf(
- "invalid index. previous display index is %d but next is %d. dump = %s",
- prevIdx, code.DisplayIdx, c.Dump(),
- )
- }
- }
- prevIdx = code.DisplayIdx
- code = code.IterNext()
- }
- return nil
-}
-
-func (c *Opcode) IterNext() *Opcode {
- if c == nil {
- return nil
- }
- switch c.Op.CodeType() {
- case CodeArrayElem, CodeSliceElem, CodeMapKey:
- return c.End
- default:
- return c.Next
- }
-}
-
-func (c *Opcode) IsEnd() bool {
- if c == nil {
- return true
- }
- return c.Op == OpEnd || c.Op == OpInterfaceEnd || c.Op == OpRecursiveEnd
-}
-
-func (c *Opcode) MaxIdx() uint32 {
- max := uint32(0)
- for _, value := range []uint32{
- c.Idx,
- c.ElemIdx,
- c.Length,
- c.Size,
- } {
- if max < value {
- max = value
- }
- }
- return max
-}
-
-func (c *Opcode) ToHeaderType(isString bool) OpType {
- switch c.Op {
- case OpInt:
- if isString {
- return OpStructHeadIntString
- }
- return OpStructHeadInt
- case OpIntPtr:
- if isString {
- return OpStructHeadIntPtrString
- }
- return OpStructHeadIntPtr
- case OpUint:
- if isString {
- return OpStructHeadUintString
- }
- return OpStructHeadUint
- case OpUintPtr:
- if isString {
- return OpStructHeadUintPtrString
- }
- return OpStructHeadUintPtr
- case OpFloat32:
- if isString {
- return OpStructHeadFloat32String
- }
- return OpStructHeadFloat32
- case OpFloat32Ptr:
- if isString {
- return OpStructHeadFloat32PtrString
- }
- return OpStructHeadFloat32Ptr
- case OpFloat64:
- if isString {
- return OpStructHeadFloat64String
- }
- return OpStructHeadFloat64
- case OpFloat64Ptr:
- if isString {
- return OpStructHeadFloat64PtrString
- }
- return OpStructHeadFloat64Ptr
- case OpString:
- if isString {
- return OpStructHeadStringString
- }
- return OpStructHeadString
- case OpStringPtr:
- if isString {
- return OpStructHeadStringPtrString
- }
- return OpStructHeadStringPtr
- case OpNumber:
- if isString {
- return OpStructHeadNumberString
- }
- return OpStructHeadNumber
- case OpNumberPtr:
- if isString {
- return OpStructHeadNumberPtrString
- }
- return OpStructHeadNumberPtr
- case OpBool:
- if isString {
- return OpStructHeadBoolString
- }
- return OpStructHeadBool
- case OpBoolPtr:
- if isString {
- return OpStructHeadBoolPtrString
- }
- return OpStructHeadBoolPtr
- case OpBytes:
- return OpStructHeadBytes
- case OpBytesPtr:
- return OpStructHeadBytesPtr
- case OpMap:
- return OpStructHeadMap
- case OpMapPtr:
- c.Op = OpMap
- return OpStructHeadMapPtr
- case OpArray:
- return OpStructHeadArray
- case OpArrayPtr:
- c.Op = OpArray
- return OpStructHeadArrayPtr
- case OpSlice:
- return OpStructHeadSlice
- case OpSlicePtr:
- c.Op = OpSlice
- return OpStructHeadSlicePtr
- case OpMarshalJSON:
- return OpStructHeadMarshalJSON
- case OpMarshalJSONPtr:
- return OpStructHeadMarshalJSONPtr
- case OpMarshalText:
- return OpStructHeadMarshalText
- case OpMarshalTextPtr:
- return OpStructHeadMarshalTextPtr
- }
- return OpStructHead
-}
-
-func (c *Opcode) ToFieldType(isString bool) OpType {
- switch c.Op {
- case OpInt:
- if isString {
- return OpStructFieldIntString
- }
- return OpStructFieldInt
- case OpIntPtr:
- if isString {
- return OpStructFieldIntPtrString
- }
- return OpStructFieldIntPtr
- case OpUint:
- if isString {
- return OpStructFieldUintString
- }
- return OpStructFieldUint
- case OpUintPtr:
- if isString {
- return OpStructFieldUintPtrString
- }
- return OpStructFieldUintPtr
- case OpFloat32:
- if isString {
- return OpStructFieldFloat32String
- }
- return OpStructFieldFloat32
- case OpFloat32Ptr:
- if isString {
- return OpStructFieldFloat32PtrString
- }
- return OpStructFieldFloat32Ptr
- case OpFloat64:
- if isString {
- return OpStructFieldFloat64String
- }
- return OpStructFieldFloat64
- case OpFloat64Ptr:
- if isString {
- return OpStructFieldFloat64PtrString
- }
- return OpStructFieldFloat64Ptr
- case OpString:
- if isString {
- return OpStructFieldStringString
- }
- return OpStructFieldString
- case OpStringPtr:
- if isString {
- return OpStructFieldStringPtrString
- }
- return OpStructFieldStringPtr
- case OpNumber:
- if isString {
- return OpStructFieldNumberString
- }
- return OpStructFieldNumber
- case OpNumberPtr:
- if isString {
- return OpStructFieldNumberPtrString
- }
- return OpStructFieldNumberPtr
- case OpBool:
- if isString {
- return OpStructFieldBoolString
- }
- return OpStructFieldBool
- case OpBoolPtr:
- if isString {
- return OpStructFieldBoolPtrString
- }
- return OpStructFieldBoolPtr
- case OpBytes:
- return OpStructFieldBytes
- case OpBytesPtr:
- return OpStructFieldBytesPtr
- case OpMap:
- return OpStructFieldMap
- case OpMapPtr:
- c.Op = OpMap
- return OpStructFieldMapPtr
- case OpArray:
- return OpStructFieldArray
- case OpArrayPtr:
- c.Op = OpArray
- return OpStructFieldArrayPtr
- case OpSlice:
- return OpStructFieldSlice
- case OpSlicePtr:
- c.Op = OpSlice
- return OpStructFieldSlicePtr
- case OpMarshalJSON:
- return OpStructFieldMarshalJSON
- case OpMarshalJSONPtr:
- return OpStructFieldMarshalJSONPtr
- case OpMarshalText:
- return OpStructFieldMarshalText
- case OpMarshalTextPtr:
- return OpStructFieldMarshalTextPtr
- }
- return OpStructField
-}
-
-func newOpCode(ctx *compileContext, typ *runtime.Type, op OpType) *Opcode {
- return newOpCodeWithNext(ctx, typ, op, newEndOp(ctx, typ))
-}
-
-func opcodeOffset(idx int) uint32 {
- return uint32(idx) * uintptrSize
-}
-
-func getCodeAddrByIdx(head *Opcode, idx uint32) *Opcode {
- addr := uintptr(unsafe.Pointer(head)) + uintptr(idx)*unsafe.Sizeof(Opcode{})
- return *(**Opcode)(unsafe.Pointer(&addr))
-}
-
-func copyOpcode(code *Opcode) *Opcode {
- codeNum := ToEndCode(code).DisplayIdx + 1
- codeSlice := make([]Opcode, codeNum)
- head := (*Opcode)((*runtime.SliceHeader)(unsafe.Pointer(&codeSlice)).Data)
- ptr := head
- c := code
- for {
- *ptr = Opcode{
- Op: c.Op,
- Key: c.Key,
- PtrNum: c.PtrNum,
- NumBitSize: c.NumBitSize,
- Flags: c.Flags,
- Idx: c.Idx,
- Offset: c.Offset,
- Type: c.Type,
- FieldQuery: c.FieldQuery,
- DisplayIdx: c.DisplayIdx,
- DisplayKey: c.DisplayKey,
- ElemIdx: c.ElemIdx,
- Length: c.Length,
- Size: c.Size,
- Indent: c.Indent,
- Jmp: c.Jmp,
- }
- if c.End != nil {
- ptr.End = getCodeAddrByIdx(head, c.End.DisplayIdx)
- }
- if c.NextField != nil {
- ptr.NextField = getCodeAddrByIdx(head, c.NextField.DisplayIdx)
- }
- if c.Next != nil {
- ptr.Next = getCodeAddrByIdx(head, c.Next.DisplayIdx)
- }
- if c.IsEnd() {
- break
- }
- ptr = getCodeAddrByIdx(head, c.DisplayIdx+1)
- c = c.IterNext()
- }
- return head
-}
-
-func setTotalLengthToInterfaceOp(code *Opcode) {
- for c := code; !c.IsEnd(); {
- if c.Op == OpInterface || c.Op == OpInterfacePtr {
- c.Length = uint32(code.TotalLength())
- }
- c = c.IterNext()
- }
-}
-
-func ToEndCode(code *Opcode) *Opcode {
- c := code
- for !c.IsEnd() {
- c = c.IterNext()
- }
- return c
-}
-
-func copyToInterfaceOpcode(code *Opcode) *Opcode {
- copied := copyOpcode(code)
- c := copied
- c = ToEndCode(c)
- c.Idx += uintptrSize
- c.ElemIdx = c.Idx + uintptrSize
- c.Length = c.Idx + 2*uintptrSize
- c.Op = OpInterfaceEnd
- return copied
-}
-
-func newOpCodeWithNext(ctx *compileContext, typ *runtime.Type, op OpType, next *Opcode) *Opcode {
- return &Opcode{
- Op: op,
- Idx: opcodeOffset(ctx.ptrIndex),
- Next: next,
- Type: typ,
- DisplayIdx: ctx.opcodeIndex,
- Indent: ctx.indent,
- }
-}
-
-func newEndOp(ctx *compileContext, typ *runtime.Type) *Opcode {
- return newOpCodeWithNext(ctx, typ, OpEnd, nil)
-}
-
-func (c *Opcode) TotalLength() int {
- var idx int
- code := c
- for !code.IsEnd() {
- maxIdx := int(code.MaxIdx() / uintptrSize)
- if idx < maxIdx {
- idx = maxIdx
- }
- if code.Op == OpRecursiveEnd {
- break
- }
- code = code.IterNext()
- }
- maxIdx := int(code.MaxIdx() / uintptrSize)
- if idx < maxIdx {
- idx = maxIdx
- }
- return idx + 1
-}
-
-func (c *Opcode) dumpHead(code *Opcode) string {
- var length uint32
- if code.Op.CodeType() == CodeArrayHead {
- length = code.Length
- } else {
- length = code.Length / uintptrSize
- }
- return fmt.Sprintf(
- `[%03d]%s%s ([idx:%d][elemIdx:%d][length:%d])`,
- code.DisplayIdx,
- strings.Repeat("-", int(code.Indent)),
- code.Op,
- code.Idx/uintptrSize,
- code.ElemIdx/uintptrSize,
- length,
- )
-}
-
-func (c *Opcode) dumpMapHead(code *Opcode) string {
- return fmt.Sprintf(
- `[%03d]%s%s ([idx:%d])`,
- code.DisplayIdx,
- strings.Repeat("-", int(code.Indent)),
- code.Op,
- code.Idx/uintptrSize,
- )
-}
-
-func (c *Opcode) dumpMapEnd(code *Opcode) string {
- return fmt.Sprintf(
- `[%03d]%s%s ([idx:%d])`,
- code.DisplayIdx,
- strings.Repeat("-", int(code.Indent)),
- code.Op,
- code.Idx/uintptrSize,
- )
-}
-
-func (c *Opcode) dumpElem(code *Opcode) string {
- var length uint32
- if code.Op.CodeType() == CodeArrayElem {
- length = code.Length
- } else {
- length = code.Length / uintptrSize
- }
- return fmt.Sprintf(
- `[%03d]%s%s ([idx:%d][elemIdx:%d][length:%d][size:%d])`,
- code.DisplayIdx,
- strings.Repeat("-", int(code.Indent)),
- code.Op,
- code.Idx/uintptrSize,
- code.ElemIdx/uintptrSize,
- length,
- code.Size,
- )
-}
-
-func (c *Opcode) dumpField(code *Opcode) string {
- return fmt.Sprintf(
- `[%03d]%s%s ([idx:%d][key:%s][offset:%d])`,
- code.DisplayIdx,
- strings.Repeat("-", int(code.Indent)),
- code.Op,
- code.Idx/uintptrSize,
- code.DisplayKey,
- code.Offset,
- )
-}
-
-func (c *Opcode) dumpKey(code *Opcode) string {
- return fmt.Sprintf(
- `[%03d]%s%s ([idx:%d])`,
- code.DisplayIdx,
- strings.Repeat("-", int(code.Indent)),
- code.Op,
- code.Idx/uintptrSize,
- )
-}
-
-func (c *Opcode) dumpValue(code *Opcode) string {
- return fmt.Sprintf(
- `[%03d]%s%s ([idx:%d])`,
- code.DisplayIdx,
- strings.Repeat("-", int(code.Indent)),
- code.Op,
- code.Idx/uintptrSize,
- )
-}
-
-func (c *Opcode) Dump() string {
- codes := []string{}
- for code := c; !code.IsEnd(); {
- switch code.Op.CodeType() {
- case CodeSliceHead:
- codes = append(codes, c.dumpHead(code))
- code = code.Next
- case CodeMapHead:
- codes = append(codes, c.dumpMapHead(code))
- code = code.Next
- case CodeArrayElem, CodeSliceElem:
- codes = append(codes, c.dumpElem(code))
- code = code.End
- case CodeMapKey:
- codes = append(codes, c.dumpKey(code))
- code = code.End
- case CodeMapValue:
- codes = append(codes, c.dumpValue(code))
- code = code.Next
- case CodeMapEnd:
- codes = append(codes, c.dumpMapEnd(code))
- code = code.Next
- case CodeStructField:
- codes = append(codes, c.dumpField(code))
- code = code.Next
- case CodeStructEnd:
- codes = append(codes, c.dumpField(code))
- code = code.Next
- default:
- codes = append(codes, fmt.Sprintf(
- "[%03d]%s%s ([idx:%d])",
- code.DisplayIdx,
- strings.Repeat("-", int(code.Indent)),
- code.Op,
- code.Idx/uintptrSize,
- ))
- code = code.Next
- }
- }
- return strings.Join(codes, "\n")
-}
-
-func (c *Opcode) DumpDOT() string {
- type edge struct {
- from, to *Opcode
- label string
- weight int
- }
- var edges []edge
-
- b := &bytes.Buffer{}
- fmt.Fprintf(b, "digraph \"%p\" {\n", c.Type)
- fmt.Fprintln(b, "mclimit=1.5;\nrankdir=TD;\nordering=out;\nnode[shape=box];")
- for code := c; !code.IsEnd(); {
- label := code.Op.String()
- fmt.Fprintf(b, "\"%p\" [label=%q];\n", code, label)
- if p := code.Next; p != nil {
- edges = append(edges, edge{
- from: code,
- to: p,
- label: "Next",
- weight: 10,
- })
- }
- if p := code.NextField; p != nil {
- edges = append(edges, edge{
- from: code,
- to: p,
- label: "NextField",
- weight: 2,
- })
- }
- if p := code.End; p != nil {
- edges = append(edges, edge{
- from: code,
- to: p,
- label: "End",
- weight: 1,
- })
- }
- if p := code.Jmp; p != nil {
- edges = append(edges, edge{
- from: code,
- to: p.Code,
- label: "Jmp",
- weight: 1,
- })
- }
-
- switch code.Op.CodeType() {
- case CodeSliceHead:
- code = code.Next
- case CodeMapHead:
- code = code.Next
- case CodeArrayElem, CodeSliceElem:
- code = code.End
- case CodeMapKey:
- code = code.End
- case CodeMapValue:
- code = code.Next
- case CodeMapEnd:
- code = code.Next
- case CodeStructField:
- code = code.Next
- case CodeStructEnd:
- code = code.Next
- default:
- code = code.Next
- }
- if code.IsEnd() {
- fmt.Fprintf(b, "\"%p\" [label=%q];\n", code, code.Op.String())
- }
- }
- sort.Slice(edges, func(i, j int) bool {
- return edges[i].to.DisplayIdx < edges[j].to.DisplayIdx
- })
- for _, e := range edges {
- fmt.Fprintf(b, "\"%p\" -> \"%p\" [label=%q][weight=%d];\n", e.from, e.to, e.label, e.weight)
- }
- fmt.Fprint(b, "}")
- return b.String()
-}
-
-func newSliceHeaderCode(ctx *compileContext, typ *runtime.Type) *Opcode {
- idx := opcodeOffset(ctx.ptrIndex)
- ctx.incPtrIndex()
- elemIdx := opcodeOffset(ctx.ptrIndex)
- ctx.incPtrIndex()
- length := opcodeOffset(ctx.ptrIndex)
- return &Opcode{
- Op: OpSlice,
- Type: typ,
- Idx: idx,
- DisplayIdx: ctx.opcodeIndex,
- ElemIdx: elemIdx,
- Length: length,
- Indent: ctx.indent,
- }
-}
-
-func newSliceElemCode(ctx *compileContext, typ *runtime.Type, head *Opcode, size uintptr) *Opcode {
- return &Opcode{
- Op: OpSliceElem,
- Type: typ,
- Idx: head.Idx,
- DisplayIdx: ctx.opcodeIndex,
- ElemIdx: head.ElemIdx,
- Length: head.Length,
- Indent: ctx.indent,
- Size: uint32(size),
- }
-}
-
-func newArrayHeaderCode(ctx *compileContext, typ *runtime.Type, alen int) *Opcode {
- idx := opcodeOffset(ctx.ptrIndex)
- ctx.incPtrIndex()
- elemIdx := opcodeOffset(ctx.ptrIndex)
- return &Opcode{
- Op: OpArray,
- Type: typ,
- Idx: idx,
- DisplayIdx: ctx.opcodeIndex,
- ElemIdx: elemIdx,
- Indent: ctx.indent,
- Length: uint32(alen),
- }
-}
-
-func newArrayElemCode(ctx *compileContext, typ *runtime.Type, head *Opcode, length int, size uintptr) *Opcode {
- return &Opcode{
- Op: OpArrayElem,
- Type: typ,
- Idx: head.Idx,
- DisplayIdx: ctx.opcodeIndex,
- ElemIdx: head.ElemIdx,
- Length: uint32(length),
- Indent: ctx.indent,
- Size: uint32(size),
- }
-}
-
-func newMapHeaderCode(ctx *compileContext, typ *runtime.Type) *Opcode {
- idx := opcodeOffset(ctx.ptrIndex)
- ctx.incPtrIndex()
- return &Opcode{
- Op: OpMap,
- Type: typ,
- Idx: idx,
- DisplayIdx: ctx.opcodeIndex,
- Indent: ctx.indent,
- }
-}
-
-func newMapKeyCode(ctx *compileContext, typ *runtime.Type, head *Opcode) *Opcode {
- return &Opcode{
- Op: OpMapKey,
- Type: typ,
- Idx: head.Idx,
- DisplayIdx: ctx.opcodeIndex,
- Indent: ctx.indent,
- }
-}
-
-func newMapValueCode(ctx *compileContext, typ *runtime.Type, head *Opcode) *Opcode {
- return &Opcode{
- Op: OpMapValue,
- Type: typ,
- Idx: head.Idx,
- DisplayIdx: ctx.opcodeIndex,
- Indent: ctx.indent,
- }
-}
-
-func newMapEndCode(ctx *compileContext, typ *runtime.Type, head *Opcode) *Opcode {
- return &Opcode{
- Op: OpMapEnd,
- Type: typ,
- Idx: head.Idx,
- DisplayIdx: ctx.opcodeIndex,
- Indent: ctx.indent,
- Next: newEndOp(ctx, typ),
- }
-}
-
-func newRecursiveCode(ctx *compileContext, typ *runtime.Type, jmp *CompiledCode) *Opcode {
- return &Opcode{
- Op: OpRecursive,
- Type: typ,
- Idx: opcodeOffset(ctx.ptrIndex),
- Next: newEndOp(ctx, typ),
- DisplayIdx: ctx.opcodeIndex,
- Indent: ctx.indent,
- Jmp: jmp,
- }
-}
diff --git a/vendor/github.com/goccy/go-json/internal/encoder/option.go b/vendor/github.com/goccy/go-json/internal/encoder/option.go
deleted file mode 100644
index 12c58e46..00000000
--- a/vendor/github.com/goccy/go-json/internal/encoder/option.go
+++ /dev/null
@@ -1,48 +0,0 @@
-package encoder
-
-import (
- "context"
- "io"
-)
-
-type OptionFlag uint8
-
-const (
- HTMLEscapeOption OptionFlag = 1 << iota
- IndentOption
- UnorderedMapOption
- DebugOption
- ColorizeOption
- ContextOption
- NormalizeUTF8Option
- FieldQueryOption
-)
-
-type Option struct {
- Flag OptionFlag
- ColorScheme *ColorScheme
- Context context.Context
- DebugOut io.Writer
- DebugDOTOut io.WriteCloser
-}
-
-type EncodeFormat struct {
- Header string
- Footer string
-}
-
-type EncodeFormatScheme struct {
- Int EncodeFormat
- Uint EncodeFormat
- Float EncodeFormat
- Bool EncodeFormat
- String EncodeFormat
- Binary EncodeFormat
- ObjectKey EncodeFormat
- Null EncodeFormat
-}
-
-type (
- ColorScheme = EncodeFormatScheme
- ColorFormat = EncodeFormat
-)
diff --git a/vendor/github.com/goccy/go-json/internal/encoder/optype.go b/vendor/github.com/goccy/go-json/internal/encoder/optype.go
deleted file mode 100644
index 5c1241b4..00000000
--- a/vendor/github.com/goccy/go-json/internal/encoder/optype.go
+++ /dev/null
@@ -1,932 +0,0 @@
-// Code generated by internal/cmd/generator. DO NOT EDIT!
-package encoder
-
-import (
- "strings"
-)
-
-type CodeType int
-
-const (
- CodeOp CodeType = 0
- CodeArrayHead CodeType = 1
- CodeArrayElem CodeType = 2
- CodeSliceHead CodeType = 3
- CodeSliceElem CodeType = 4
- CodeMapHead CodeType = 5
- CodeMapKey CodeType = 6
- CodeMapValue CodeType = 7
- CodeMapEnd CodeType = 8
- CodeRecursive CodeType = 9
- CodeStructField CodeType = 10
- CodeStructEnd CodeType = 11
-)
-
-var opTypeStrings = [400]string{
- "End",
- "Interface",
- "Ptr",
- "SliceElem",
- "SliceEnd",
- "ArrayElem",
- "ArrayEnd",
- "MapKey",
- "MapValue",
- "MapEnd",
- "Recursive",
- "RecursivePtr",
- "RecursiveEnd",
- "InterfaceEnd",
- "Int",
- "Uint",
- "Float32",
- "Float64",
- "Bool",
- "String",
- "Bytes",
- "Number",
- "Array",
- "Map",
- "Slice",
- "Struct",
- "MarshalJSON",
- "MarshalText",
- "IntString",
- "UintString",
- "Float32String",
- "Float64String",
- "BoolString",
- "StringString",
- "NumberString",
- "IntPtr",
- "UintPtr",
- "Float32Ptr",
- "Float64Ptr",
- "BoolPtr",
- "StringPtr",
- "BytesPtr",
- "NumberPtr",
- "ArrayPtr",
- "MapPtr",
- "SlicePtr",
- "MarshalJSONPtr",
- "MarshalTextPtr",
- "InterfacePtr",
- "IntPtrString",
- "UintPtrString",
- "Float32PtrString",
- "Float64PtrString",
- "BoolPtrString",
- "StringPtrString",
- "NumberPtrString",
- "StructHeadInt",
- "StructHeadOmitEmptyInt",
- "StructPtrHeadInt",
- "StructPtrHeadOmitEmptyInt",
- "StructHeadUint",
- "StructHeadOmitEmptyUint",
- "StructPtrHeadUint",
- "StructPtrHeadOmitEmptyUint",
- "StructHeadFloat32",
- "StructHeadOmitEmptyFloat32",
- "StructPtrHeadFloat32",
- "StructPtrHeadOmitEmptyFloat32",
- "StructHeadFloat64",
- "StructHeadOmitEmptyFloat64",
- "StructPtrHeadFloat64",
- "StructPtrHeadOmitEmptyFloat64",
- "StructHeadBool",
- "StructHeadOmitEmptyBool",
- "StructPtrHeadBool",
- "StructPtrHeadOmitEmptyBool",
- "StructHeadString",
- "StructHeadOmitEmptyString",
- "StructPtrHeadString",
- "StructPtrHeadOmitEmptyString",
- "StructHeadBytes",
- "StructHeadOmitEmptyBytes",
- "StructPtrHeadBytes",
- "StructPtrHeadOmitEmptyBytes",
- "StructHeadNumber",
- "StructHeadOmitEmptyNumber",
- "StructPtrHeadNumber",
- "StructPtrHeadOmitEmptyNumber",
- "StructHeadArray",
- "StructHeadOmitEmptyArray",
- "StructPtrHeadArray",
- "StructPtrHeadOmitEmptyArray",
- "StructHeadMap",
- "StructHeadOmitEmptyMap",
- "StructPtrHeadMap",
- "StructPtrHeadOmitEmptyMap",
- "StructHeadSlice",
- "StructHeadOmitEmptySlice",
- "StructPtrHeadSlice",
- "StructPtrHeadOmitEmptySlice",
- "StructHeadStruct",
- "StructHeadOmitEmptyStruct",
- "StructPtrHeadStruct",
- "StructPtrHeadOmitEmptyStruct",
- "StructHeadMarshalJSON",
- "StructHeadOmitEmptyMarshalJSON",
- "StructPtrHeadMarshalJSON",
- "StructPtrHeadOmitEmptyMarshalJSON",
- "StructHeadMarshalText",
- "StructHeadOmitEmptyMarshalText",
- "StructPtrHeadMarshalText",
- "StructPtrHeadOmitEmptyMarshalText",
- "StructHeadIntString",
- "StructHeadOmitEmptyIntString",
- "StructPtrHeadIntString",
- "StructPtrHeadOmitEmptyIntString",
- "StructHeadUintString",
- "StructHeadOmitEmptyUintString",
- "StructPtrHeadUintString",
- "StructPtrHeadOmitEmptyUintString",
- "StructHeadFloat32String",
- "StructHeadOmitEmptyFloat32String",
- "StructPtrHeadFloat32String",
- "StructPtrHeadOmitEmptyFloat32String",
- "StructHeadFloat64String",
- "StructHeadOmitEmptyFloat64String",
- "StructPtrHeadFloat64String",
- "StructPtrHeadOmitEmptyFloat64String",
- "StructHeadBoolString",
- "StructHeadOmitEmptyBoolString",
- "StructPtrHeadBoolString",
- "StructPtrHeadOmitEmptyBoolString",
- "StructHeadStringString",
- "StructHeadOmitEmptyStringString",
- "StructPtrHeadStringString",
- "StructPtrHeadOmitEmptyStringString",
- "StructHeadNumberString",
- "StructHeadOmitEmptyNumberString",
- "StructPtrHeadNumberString",
- "StructPtrHeadOmitEmptyNumberString",
- "StructHeadIntPtr",
- "StructHeadOmitEmptyIntPtr",
- "StructPtrHeadIntPtr",
- "StructPtrHeadOmitEmptyIntPtr",
- "StructHeadUintPtr",
- "StructHeadOmitEmptyUintPtr",
- "StructPtrHeadUintPtr",
- "StructPtrHeadOmitEmptyUintPtr",
- "StructHeadFloat32Ptr",
- "StructHeadOmitEmptyFloat32Ptr",
- "StructPtrHeadFloat32Ptr",
- "StructPtrHeadOmitEmptyFloat32Ptr",
- "StructHeadFloat64Ptr",
- "StructHeadOmitEmptyFloat64Ptr",
- "StructPtrHeadFloat64Ptr",
- "StructPtrHeadOmitEmptyFloat64Ptr",
- "StructHeadBoolPtr",
- "StructHeadOmitEmptyBoolPtr",
- "StructPtrHeadBoolPtr",
- "StructPtrHeadOmitEmptyBoolPtr",
- "StructHeadStringPtr",
- "StructHeadOmitEmptyStringPtr",
- "StructPtrHeadStringPtr",
- "StructPtrHeadOmitEmptyStringPtr",
- "StructHeadBytesPtr",
- "StructHeadOmitEmptyBytesPtr",
- "StructPtrHeadBytesPtr",
- "StructPtrHeadOmitEmptyBytesPtr",
- "StructHeadNumberPtr",
- "StructHeadOmitEmptyNumberPtr",
- "StructPtrHeadNumberPtr",
- "StructPtrHeadOmitEmptyNumberPtr",
- "StructHeadArrayPtr",
- "StructHeadOmitEmptyArrayPtr",
- "StructPtrHeadArrayPtr",
- "StructPtrHeadOmitEmptyArrayPtr",
- "StructHeadMapPtr",
- "StructHeadOmitEmptyMapPtr",
- "StructPtrHeadMapPtr",
- "StructPtrHeadOmitEmptyMapPtr",
- "StructHeadSlicePtr",
- "StructHeadOmitEmptySlicePtr",
- "StructPtrHeadSlicePtr",
- "StructPtrHeadOmitEmptySlicePtr",
- "StructHeadMarshalJSONPtr",
- "StructHeadOmitEmptyMarshalJSONPtr",
- "StructPtrHeadMarshalJSONPtr",
- "StructPtrHeadOmitEmptyMarshalJSONPtr",
- "StructHeadMarshalTextPtr",
- "StructHeadOmitEmptyMarshalTextPtr",
- "StructPtrHeadMarshalTextPtr",
- "StructPtrHeadOmitEmptyMarshalTextPtr",
- "StructHeadInterfacePtr",
- "StructHeadOmitEmptyInterfacePtr",
- "StructPtrHeadInterfacePtr",
- "StructPtrHeadOmitEmptyInterfacePtr",
- "StructHeadIntPtrString",
- "StructHeadOmitEmptyIntPtrString",
- "StructPtrHeadIntPtrString",
- "StructPtrHeadOmitEmptyIntPtrString",
- "StructHeadUintPtrString",
- "StructHeadOmitEmptyUintPtrString",
- "StructPtrHeadUintPtrString",
- "StructPtrHeadOmitEmptyUintPtrString",
- "StructHeadFloat32PtrString",
- "StructHeadOmitEmptyFloat32PtrString",
- "StructPtrHeadFloat32PtrString",
- "StructPtrHeadOmitEmptyFloat32PtrString",
- "StructHeadFloat64PtrString",
- "StructHeadOmitEmptyFloat64PtrString",
- "StructPtrHeadFloat64PtrString",
- "StructPtrHeadOmitEmptyFloat64PtrString",
- "StructHeadBoolPtrString",
- "StructHeadOmitEmptyBoolPtrString",
- "StructPtrHeadBoolPtrString",
- "StructPtrHeadOmitEmptyBoolPtrString",
- "StructHeadStringPtrString",
- "StructHeadOmitEmptyStringPtrString",
- "StructPtrHeadStringPtrString",
- "StructPtrHeadOmitEmptyStringPtrString",
- "StructHeadNumberPtrString",
- "StructHeadOmitEmptyNumberPtrString",
- "StructPtrHeadNumberPtrString",
- "StructPtrHeadOmitEmptyNumberPtrString",
- "StructHead",
- "StructHeadOmitEmpty",
- "StructPtrHead",
- "StructPtrHeadOmitEmpty",
- "StructFieldInt",
- "StructFieldOmitEmptyInt",
- "StructEndInt",
- "StructEndOmitEmptyInt",
- "StructFieldUint",
- "StructFieldOmitEmptyUint",
- "StructEndUint",
- "StructEndOmitEmptyUint",
- "StructFieldFloat32",
- "StructFieldOmitEmptyFloat32",
- "StructEndFloat32",
- "StructEndOmitEmptyFloat32",
- "StructFieldFloat64",
- "StructFieldOmitEmptyFloat64",
- "StructEndFloat64",
- "StructEndOmitEmptyFloat64",
- "StructFieldBool",
- "StructFieldOmitEmptyBool",
- "StructEndBool",
- "StructEndOmitEmptyBool",
- "StructFieldString",
- "StructFieldOmitEmptyString",
- "StructEndString",
- "StructEndOmitEmptyString",
- "StructFieldBytes",
- "StructFieldOmitEmptyBytes",
- "StructEndBytes",
- "StructEndOmitEmptyBytes",
- "StructFieldNumber",
- "StructFieldOmitEmptyNumber",
- "StructEndNumber",
- "StructEndOmitEmptyNumber",
- "StructFieldArray",
- "StructFieldOmitEmptyArray",
- "StructEndArray",
- "StructEndOmitEmptyArray",
- "StructFieldMap",
- "StructFieldOmitEmptyMap",
- "StructEndMap",
- "StructEndOmitEmptyMap",
- "StructFieldSlice",
- "StructFieldOmitEmptySlice",
- "StructEndSlice",
- "StructEndOmitEmptySlice",
- "StructFieldStruct",
- "StructFieldOmitEmptyStruct",
- "StructEndStruct",
- "StructEndOmitEmptyStruct",
- "StructFieldMarshalJSON",
- "StructFieldOmitEmptyMarshalJSON",
- "StructEndMarshalJSON",
- "StructEndOmitEmptyMarshalJSON",
- "StructFieldMarshalText",
- "StructFieldOmitEmptyMarshalText",
- "StructEndMarshalText",
- "StructEndOmitEmptyMarshalText",
- "StructFieldIntString",
- "StructFieldOmitEmptyIntString",
- "StructEndIntString",
- "StructEndOmitEmptyIntString",
- "StructFieldUintString",
- "StructFieldOmitEmptyUintString",
- "StructEndUintString",
- "StructEndOmitEmptyUintString",
- "StructFieldFloat32String",
- "StructFieldOmitEmptyFloat32String",
- "StructEndFloat32String",
- "StructEndOmitEmptyFloat32String",
- "StructFieldFloat64String",
- "StructFieldOmitEmptyFloat64String",
- "StructEndFloat64String",
- "StructEndOmitEmptyFloat64String",
- "StructFieldBoolString",
- "StructFieldOmitEmptyBoolString",
- "StructEndBoolString",
- "StructEndOmitEmptyBoolString",
- "StructFieldStringString",
- "StructFieldOmitEmptyStringString",
- "StructEndStringString",
- "StructEndOmitEmptyStringString",
- "StructFieldNumberString",
- "StructFieldOmitEmptyNumberString",
- "StructEndNumberString",
- "StructEndOmitEmptyNumberString",
- "StructFieldIntPtr",
- "StructFieldOmitEmptyIntPtr",
- "StructEndIntPtr",
- "StructEndOmitEmptyIntPtr",
- "StructFieldUintPtr",
- "StructFieldOmitEmptyUintPtr",
- "StructEndUintPtr",
- "StructEndOmitEmptyUintPtr",
- "StructFieldFloat32Ptr",
- "StructFieldOmitEmptyFloat32Ptr",
- "StructEndFloat32Ptr",
- "StructEndOmitEmptyFloat32Ptr",
- "StructFieldFloat64Ptr",
- "StructFieldOmitEmptyFloat64Ptr",
- "StructEndFloat64Ptr",
- "StructEndOmitEmptyFloat64Ptr",
- "StructFieldBoolPtr",
- "StructFieldOmitEmptyBoolPtr",
- "StructEndBoolPtr",
- "StructEndOmitEmptyBoolPtr",
- "StructFieldStringPtr",
- "StructFieldOmitEmptyStringPtr",
- "StructEndStringPtr",
- "StructEndOmitEmptyStringPtr",
- "StructFieldBytesPtr",
- "StructFieldOmitEmptyBytesPtr",
- "StructEndBytesPtr",
- "StructEndOmitEmptyBytesPtr",
- "StructFieldNumberPtr",
- "StructFieldOmitEmptyNumberPtr",
- "StructEndNumberPtr",
- "StructEndOmitEmptyNumberPtr",
- "StructFieldArrayPtr",
- "StructFieldOmitEmptyArrayPtr",
- "StructEndArrayPtr",
- "StructEndOmitEmptyArrayPtr",
- "StructFieldMapPtr",
- "StructFieldOmitEmptyMapPtr",
- "StructEndMapPtr",
- "StructEndOmitEmptyMapPtr",
- "StructFieldSlicePtr",
- "StructFieldOmitEmptySlicePtr",
- "StructEndSlicePtr",
- "StructEndOmitEmptySlicePtr",
- "StructFieldMarshalJSONPtr",
- "StructFieldOmitEmptyMarshalJSONPtr",
- "StructEndMarshalJSONPtr",
- "StructEndOmitEmptyMarshalJSONPtr",
- "StructFieldMarshalTextPtr",
- "StructFieldOmitEmptyMarshalTextPtr",
- "StructEndMarshalTextPtr",
- "StructEndOmitEmptyMarshalTextPtr",
- "StructFieldInterfacePtr",
- "StructFieldOmitEmptyInterfacePtr",
- "StructEndInterfacePtr",
- "StructEndOmitEmptyInterfacePtr",
- "StructFieldIntPtrString",
- "StructFieldOmitEmptyIntPtrString",
- "StructEndIntPtrString",
- "StructEndOmitEmptyIntPtrString",
- "StructFieldUintPtrString",
- "StructFieldOmitEmptyUintPtrString",
- "StructEndUintPtrString",
- "StructEndOmitEmptyUintPtrString",
- "StructFieldFloat32PtrString",
- "StructFieldOmitEmptyFloat32PtrString",
- "StructEndFloat32PtrString",
- "StructEndOmitEmptyFloat32PtrString",
- "StructFieldFloat64PtrString",
- "StructFieldOmitEmptyFloat64PtrString",
- "StructEndFloat64PtrString",
- "StructEndOmitEmptyFloat64PtrString",
- "StructFieldBoolPtrString",
- "StructFieldOmitEmptyBoolPtrString",
- "StructEndBoolPtrString",
- "StructEndOmitEmptyBoolPtrString",
- "StructFieldStringPtrString",
- "StructFieldOmitEmptyStringPtrString",
- "StructEndStringPtrString",
- "StructEndOmitEmptyStringPtrString",
- "StructFieldNumberPtrString",
- "StructFieldOmitEmptyNumberPtrString",
- "StructEndNumberPtrString",
- "StructEndOmitEmptyNumberPtrString",
- "StructField",
- "StructFieldOmitEmpty",
- "StructEnd",
- "StructEndOmitEmpty",
-}
-
-type OpType uint16
-
-const (
- OpEnd OpType = 0
- OpInterface OpType = 1
- OpPtr OpType = 2
- OpSliceElem OpType = 3
- OpSliceEnd OpType = 4
- OpArrayElem OpType = 5
- OpArrayEnd OpType = 6
- OpMapKey OpType = 7
- OpMapValue OpType = 8
- OpMapEnd OpType = 9
- OpRecursive OpType = 10
- OpRecursivePtr OpType = 11
- OpRecursiveEnd OpType = 12
- OpInterfaceEnd OpType = 13
- OpInt OpType = 14
- OpUint OpType = 15
- OpFloat32 OpType = 16
- OpFloat64 OpType = 17
- OpBool OpType = 18
- OpString OpType = 19
- OpBytes OpType = 20
- OpNumber OpType = 21
- OpArray OpType = 22
- OpMap OpType = 23
- OpSlice OpType = 24
- OpStruct OpType = 25
- OpMarshalJSON OpType = 26
- OpMarshalText OpType = 27
- OpIntString OpType = 28
- OpUintString OpType = 29
- OpFloat32String OpType = 30
- OpFloat64String OpType = 31
- OpBoolString OpType = 32
- OpStringString OpType = 33
- OpNumberString OpType = 34
- OpIntPtr OpType = 35
- OpUintPtr OpType = 36
- OpFloat32Ptr OpType = 37
- OpFloat64Ptr OpType = 38
- OpBoolPtr OpType = 39
- OpStringPtr OpType = 40
- OpBytesPtr OpType = 41
- OpNumberPtr OpType = 42
- OpArrayPtr OpType = 43
- OpMapPtr OpType = 44
- OpSlicePtr OpType = 45
- OpMarshalJSONPtr OpType = 46
- OpMarshalTextPtr OpType = 47
- OpInterfacePtr OpType = 48
- OpIntPtrString OpType = 49
- OpUintPtrString OpType = 50
- OpFloat32PtrString OpType = 51
- OpFloat64PtrString OpType = 52
- OpBoolPtrString OpType = 53
- OpStringPtrString OpType = 54
- OpNumberPtrString OpType = 55
- OpStructHeadInt OpType = 56
- OpStructHeadOmitEmptyInt OpType = 57
- OpStructPtrHeadInt OpType = 58
- OpStructPtrHeadOmitEmptyInt OpType = 59
- OpStructHeadUint OpType = 60
- OpStructHeadOmitEmptyUint OpType = 61
- OpStructPtrHeadUint OpType = 62
- OpStructPtrHeadOmitEmptyUint OpType = 63
- OpStructHeadFloat32 OpType = 64
- OpStructHeadOmitEmptyFloat32 OpType = 65
- OpStructPtrHeadFloat32 OpType = 66
- OpStructPtrHeadOmitEmptyFloat32 OpType = 67
- OpStructHeadFloat64 OpType = 68
- OpStructHeadOmitEmptyFloat64 OpType = 69
- OpStructPtrHeadFloat64 OpType = 70
- OpStructPtrHeadOmitEmptyFloat64 OpType = 71
- OpStructHeadBool OpType = 72
- OpStructHeadOmitEmptyBool OpType = 73
- OpStructPtrHeadBool OpType = 74
- OpStructPtrHeadOmitEmptyBool OpType = 75
- OpStructHeadString OpType = 76
- OpStructHeadOmitEmptyString OpType = 77
- OpStructPtrHeadString OpType = 78
- OpStructPtrHeadOmitEmptyString OpType = 79
- OpStructHeadBytes OpType = 80
- OpStructHeadOmitEmptyBytes OpType = 81
- OpStructPtrHeadBytes OpType = 82
- OpStructPtrHeadOmitEmptyBytes OpType = 83
- OpStructHeadNumber OpType = 84
- OpStructHeadOmitEmptyNumber OpType = 85
- OpStructPtrHeadNumber OpType = 86
- OpStructPtrHeadOmitEmptyNumber OpType = 87
- OpStructHeadArray OpType = 88
- OpStructHeadOmitEmptyArray OpType = 89
- OpStructPtrHeadArray OpType = 90
- OpStructPtrHeadOmitEmptyArray OpType = 91
- OpStructHeadMap OpType = 92
- OpStructHeadOmitEmptyMap OpType = 93
- OpStructPtrHeadMap OpType = 94
- OpStructPtrHeadOmitEmptyMap OpType = 95
- OpStructHeadSlice OpType = 96
- OpStructHeadOmitEmptySlice OpType = 97
- OpStructPtrHeadSlice OpType = 98
- OpStructPtrHeadOmitEmptySlice OpType = 99
- OpStructHeadStruct OpType = 100
- OpStructHeadOmitEmptyStruct OpType = 101
- OpStructPtrHeadStruct OpType = 102
- OpStructPtrHeadOmitEmptyStruct OpType = 103
- OpStructHeadMarshalJSON OpType = 104
- OpStructHeadOmitEmptyMarshalJSON OpType = 105
- OpStructPtrHeadMarshalJSON OpType = 106
- OpStructPtrHeadOmitEmptyMarshalJSON OpType = 107
- OpStructHeadMarshalText OpType = 108
- OpStructHeadOmitEmptyMarshalText OpType = 109
- OpStructPtrHeadMarshalText OpType = 110
- OpStructPtrHeadOmitEmptyMarshalText OpType = 111
- OpStructHeadIntString OpType = 112
- OpStructHeadOmitEmptyIntString OpType = 113
- OpStructPtrHeadIntString OpType = 114
- OpStructPtrHeadOmitEmptyIntString OpType = 115
- OpStructHeadUintString OpType = 116
- OpStructHeadOmitEmptyUintString OpType = 117
- OpStructPtrHeadUintString OpType = 118
- OpStructPtrHeadOmitEmptyUintString OpType = 119
- OpStructHeadFloat32String OpType = 120
- OpStructHeadOmitEmptyFloat32String OpType = 121
- OpStructPtrHeadFloat32String OpType = 122
- OpStructPtrHeadOmitEmptyFloat32String OpType = 123
- OpStructHeadFloat64String OpType = 124
- OpStructHeadOmitEmptyFloat64String OpType = 125
- OpStructPtrHeadFloat64String OpType = 126
- OpStructPtrHeadOmitEmptyFloat64String OpType = 127
- OpStructHeadBoolString OpType = 128
- OpStructHeadOmitEmptyBoolString OpType = 129
- OpStructPtrHeadBoolString OpType = 130
- OpStructPtrHeadOmitEmptyBoolString OpType = 131
- OpStructHeadStringString OpType = 132
- OpStructHeadOmitEmptyStringString OpType = 133
- OpStructPtrHeadStringString OpType = 134
- OpStructPtrHeadOmitEmptyStringString OpType = 135
- OpStructHeadNumberString OpType = 136
- OpStructHeadOmitEmptyNumberString OpType = 137
- OpStructPtrHeadNumberString OpType = 138
- OpStructPtrHeadOmitEmptyNumberString OpType = 139
- OpStructHeadIntPtr OpType = 140
- OpStructHeadOmitEmptyIntPtr OpType = 141
- OpStructPtrHeadIntPtr OpType = 142
- OpStructPtrHeadOmitEmptyIntPtr OpType = 143
- OpStructHeadUintPtr OpType = 144
- OpStructHeadOmitEmptyUintPtr OpType = 145
- OpStructPtrHeadUintPtr OpType = 146
- OpStructPtrHeadOmitEmptyUintPtr OpType = 147
- OpStructHeadFloat32Ptr OpType = 148
- OpStructHeadOmitEmptyFloat32Ptr OpType = 149
- OpStructPtrHeadFloat32Ptr OpType = 150
- OpStructPtrHeadOmitEmptyFloat32Ptr OpType = 151
- OpStructHeadFloat64Ptr OpType = 152
- OpStructHeadOmitEmptyFloat64Ptr OpType = 153
- OpStructPtrHeadFloat64Ptr OpType = 154
- OpStructPtrHeadOmitEmptyFloat64Ptr OpType = 155
- OpStructHeadBoolPtr OpType = 156
- OpStructHeadOmitEmptyBoolPtr OpType = 157
- OpStructPtrHeadBoolPtr OpType = 158
- OpStructPtrHeadOmitEmptyBoolPtr OpType = 159
- OpStructHeadStringPtr OpType = 160
- OpStructHeadOmitEmptyStringPtr OpType = 161
- OpStructPtrHeadStringPtr OpType = 162
- OpStructPtrHeadOmitEmptyStringPtr OpType = 163
- OpStructHeadBytesPtr OpType = 164
- OpStructHeadOmitEmptyBytesPtr OpType = 165
- OpStructPtrHeadBytesPtr OpType = 166
- OpStructPtrHeadOmitEmptyBytesPtr OpType = 167
- OpStructHeadNumberPtr OpType = 168
- OpStructHeadOmitEmptyNumberPtr OpType = 169
- OpStructPtrHeadNumberPtr OpType = 170
- OpStructPtrHeadOmitEmptyNumberPtr OpType = 171
- OpStructHeadArrayPtr OpType = 172
- OpStructHeadOmitEmptyArrayPtr OpType = 173
- OpStructPtrHeadArrayPtr OpType = 174
- OpStructPtrHeadOmitEmptyArrayPtr OpType = 175
- OpStructHeadMapPtr OpType = 176
- OpStructHeadOmitEmptyMapPtr OpType = 177
- OpStructPtrHeadMapPtr OpType = 178
- OpStructPtrHeadOmitEmptyMapPtr OpType = 179
- OpStructHeadSlicePtr OpType = 180
- OpStructHeadOmitEmptySlicePtr OpType = 181
- OpStructPtrHeadSlicePtr OpType = 182
- OpStructPtrHeadOmitEmptySlicePtr OpType = 183
- OpStructHeadMarshalJSONPtr OpType = 184
- OpStructHeadOmitEmptyMarshalJSONPtr OpType = 185
- OpStructPtrHeadMarshalJSONPtr OpType = 186
- OpStructPtrHeadOmitEmptyMarshalJSONPtr OpType = 187
- OpStructHeadMarshalTextPtr OpType = 188
- OpStructHeadOmitEmptyMarshalTextPtr OpType = 189
- OpStructPtrHeadMarshalTextPtr OpType = 190
- OpStructPtrHeadOmitEmptyMarshalTextPtr OpType = 191
- OpStructHeadInterfacePtr OpType = 192
- OpStructHeadOmitEmptyInterfacePtr OpType = 193
- OpStructPtrHeadInterfacePtr OpType = 194
- OpStructPtrHeadOmitEmptyInterfacePtr OpType = 195
- OpStructHeadIntPtrString OpType = 196
- OpStructHeadOmitEmptyIntPtrString OpType = 197
- OpStructPtrHeadIntPtrString OpType = 198
- OpStructPtrHeadOmitEmptyIntPtrString OpType = 199
- OpStructHeadUintPtrString OpType = 200
- OpStructHeadOmitEmptyUintPtrString OpType = 201
- OpStructPtrHeadUintPtrString OpType = 202
- OpStructPtrHeadOmitEmptyUintPtrString OpType = 203
- OpStructHeadFloat32PtrString OpType = 204
- OpStructHeadOmitEmptyFloat32PtrString OpType = 205
- OpStructPtrHeadFloat32PtrString OpType = 206
- OpStructPtrHeadOmitEmptyFloat32PtrString OpType = 207
- OpStructHeadFloat64PtrString OpType = 208
- OpStructHeadOmitEmptyFloat64PtrString OpType = 209
- OpStructPtrHeadFloat64PtrString OpType = 210
- OpStructPtrHeadOmitEmptyFloat64PtrString OpType = 211
- OpStructHeadBoolPtrString OpType = 212
- OpStructHeadOmitEmptyBoolPtrString OpType = 213
- OpStructPtrHeadBoolPtrString OpType = 214
- OpStructPtrHeadOmitEmptyBoolPtrString OpType = 215
- OpStructHeadStringPtrString OpType = 216
- OpStructHeadOmitEmptyStringPtrString OpType = 217
- OpStructPtrHeadStringPtrString OpType = 218
- OpStructPtrHeadOmitEmptyStringPtrString OpType = 219
- OpStructHeadNumberPtrString OpType = 220
- OpStructHeadOmitEmptyNumberPtrString OpType = 221
- OpStructPtrHeadNumberPtrString OpType = 222
- OpStructPtrHeadOmitEmptyNumberPtrString OpType = 223
- OpStructHead OpType = 224
- OpStructHeadOmitEmpty OpType = 225
- OpStructPtrHead OpType = 226
- OpStructPtrHeadOmitEmpty OpType = 227
- OpStructFieldInt OpType = 228
- OpStructFieldOmitEmptyInt OpType = 229
- OpStructEndInt OpType = 230
- OpStructEndOmitEmptyInt OpType = 231
- OpStructFieldUint OpType = 232
- OpStructFieldOmitEmptyUint OpType = 233
- OpStructEndUint OpType = 234
- OpStructEndOmitEmptyUint OpType = 235
- OpStructFieldFloat32 OpType = 236
- OpStructFieldOmitEmptyFloat32 OpType = 237
- OpStructEndFloat32 OpType = 238
- OpStructEndOmitEmptyFloat32 OpType = 239
- OpStructFieldFloat64 OpType = 240
- OpStructFieldOmitEmptyFloat64 OpType = 241
- OpStructEndFloat64 OpType = 242
- OpStructEndOmitEmptyFloat64 OpType = 243
- OpStructFieldBool OpType = 244
- OpStructFieldOmitEmptyBool OpType = 245
- OpStructEndBool OpType = 246
- OpStructEndOmitEmptyBool OpType = 247
- OpStructFieldString OpType = 248
- OpStructFieldOmitEmptyString OpType = 249
- OpStructEndString OpType = 250
- OpStructEndOmitEmptyString OpType = 251
- OpStructFieldBytes OpType = 252
- OpStructFieldOmitEmptyBytes OpType = 253
- OpStructEndBytes OpType = 254
- OpStructEndOmitEmptyBytes OpType = 255
- OpStructFieldNumber OpType = 256
- OpStructFieldOmitEmptyNumber OpType = 257
- OpStructEndNumber OpType = 258
- OpStructEndOmitEmptyNumber OpType = 259
- OpStructFieldArray OpType = 260
- OpStructFieldOmitEmptyArray OpType = 261
- OpStructEndArray OpType = 262
- OpStructEndOmitEmptyArray OpType = 263
- OpStructFieldMap OpType = 264
- OpStructFieldOmitEmptyMap OpType = 265
- OpStructEndMap OpType = 266
- OpStructEndOmitEmptyMap OpType = 267
- OpStructFieldSlice OpType = 268
- OpStructFieldOmitEmptySlice OpType = 269
- OpStructEndSlice OpType = 270
- OpStructEndOmitEmptySlice OpType = 271
- OpStructFieldStruct OpType = 272
- OpStructFieldOmitEmptyStruct OpType = 273
- OpStructEndStruct OpType = 274
- OpStructEndOmitEmptyStruct OpType = 275
- OpStructFieldMarshalJSON OpType = 276
- OpStructFieldOmitEmptyMarshalJSON OpType = 277
- OpStructEndMarshalJSON OpType = 278
- OpStructEndOmitEmptyMarshalJSON OpType = 279
- OpStructFieldMarshalText OpType = 280
- OpStructFieldOmitEmptyMarshalText OpType = 281
- OpStructEndMarshalText OpType = 282
- OpStructEndOmitEmptyMarshalText OpType = 283
- OpStructFieldIntString OpType = 284
- OpStructFieldOmitEmptyIntString OpType = 285
- OpStructEndIntString OpType = 286
- OpStructEndOmitEmptyIntString OpType = 287
- OpStructFieldUintString OpType = 288
- OpStructFieldOmitEmptyUintString OpType = 289
- OpStructEndUintString OpType = 290
- OpStructEndOmitEmptyUintString OpType = 291
- OpStructFieldFloat32String OpType = 292
- OpStructFieldOmitEmptyFloat32String OpType = 293
- OpStructEndFloat32String OpType = 294
- OpStructEndOmitEmptyFloat32String OpType = 295
- OpStructFieldFloat64String OpType = 296
- OpStructFieldOmitEmptyFloat64String OpType = 297
- OpStructEndFloat64String OpType = 298
- OpStructEndOmitEmptyFloat64String OpType = 299
- OpStructFieldBoolString OpType = 300
- OpStructFieldOmitEmptyBoolString OpType = 301
- OpStructEndBoolString OpType = 302
- OpStructEndOmitEmptyBoolString OpType = 303
- OpStructFieldStringString OpType = 304
- OpStructFieldOmitEmptyStringString OpType = 305
- OpStructEndStringString OpType = 306
- OpStructEndOmitEmptyStringString OpType = 307
- OpStructFieldNumberString OpType = 308
- OpStructFieldOmitEmptyNumberString OpType = 309
- OpStructEndNumberString OpType = 310
- OpStructEndOmitEmptyNumberString OpType = 311
- OpStructFieldIntPtr OpType = 312
- OpStructFieldOmitEmptyIntPtr OpType = 313
- OpStructEndIntPtr OpType = 314
- OpStructEndOmitEmptyIntPtr OpType = 315
- OpStructFieldUintPtr OpType = 316
- OpStructFieldOmitEmptyUintPtr OpType = 317
- OpStructEndUintPtr OpType = 318
- OpStructEndOmitEmptyUintPtr OpType = 319
- OpStructFieldFloat32Ptr OpType = 320
- OpStructFieldOmitEmptyFloat32Ptr OpType = 321
- OpStructEndFloat32Ptr OpType = 322
- OpStructEndOmitEmptyFloat32Ptr OpType = 323
- OpStructFieldFloat64Ptr OpType = 324
- OpStructFieldOmitEmptyFloat64Ptr OpType = 325
- OpStructEndFloat64Ptr OpType = 326
- OpStructEndOmitEmptyFloat64Ptr OpType = 327
- OpStructFieldBoolPtr OpType = 328
- OpStructFieldOmitEmptyBoolPtr OpType = 329
- OpStructEndBoolPtr OpType = 330
- OpStructEndOmitEmptyBoolPtr OpType = 331
- OpStructFieldStringPtr OpType = 332
- OpStructFieldOmitEmptyStringPtr OpType = 333
- OpStructEndStringPtr OpType = 334
- OpStructEndOmitEmptyStringPtr OpType = 335
- OpStructFieldBytesPtr OpType = 336
- OpStructFieldOmitEmptyBytesPtr OpType = 337
- OpStructEndBytesPtr OpType = 338
- OpStructEndOmitEmptyBytesPtr OpType = 339
- OpStructFieldNumberPtr OpType = 340
- OpStructFieldOmitEmptyNumberPtr OpType = 341
- OpStructEndNumberPtr OpType = 342
- OpStructEndOmitEmptyNumberPtr OpType = 343
- OpStructFieldArrayPtr OpType = 344
- OpStructFieldOmitEmptyArrayPtr OpType = 345
- OpStructEndArrayPtr OpType = 346
- OpStructEndOmitEmptyArrayPtr OpType = 347
- OpStructFieldMapPtr OpType = 348
- OpStructFieldOmitEmptyMapPtr OpType = 349
- OpStructEndMapPtr OpType = 350
- OpStructEndOmitEmptyMapPtr OpType = 351
- OpStructFieldSlicePtr OpType = 352
- OpStructFieldOmitEmptySlicePtr OpType = 353
- OpStructEndSlicePtr OpType = 354
- OpStructEndOmitEmptySlicePtr OpType = 355
- OpStructFieldMarshalJSONPtr OpType = 356
- OpStructFieldOmitEmptyMarshalJSONPtr OpType = 357
- OpStructEndMarshalJSONPtr OpType = 358
- OpStructEndOmitEmptyMarshalJSONPtr OpType = 359
- OpStructFieldMarshalTextPtr OpType = 360
- OpStructFieldOmitEmptyMarshalTextPtr OpType = 361
- OpStructEndMarshalTextPtr OpType = 362
- OpStructEndOmitEmptyMarshalTextPtr OpType = 363
- OpStructFieldInterfacePtr OpType = 364
- OpStructFieldOmitEmptyInterfacePtr OpType = 365
- OpStructEndInterfacePtr OpType = 366
- OpStructEndOmitEmptyInterfacePtr OpType = 367
- OpStructFieldIntPtrString OpType = 368
- OpStructFieldOmitEmptyIntPtrString OpType = 369
- OpStructEndIntPtrString OpType = 370
- OpStructEndOmitEmptyIntPtrString OpType = 371
- OpStructFieldUintPtrString OpType = 372
- OpStructFieldOmitEmptyUintPtrString OpType = 373
- OpStructEndUintPtrString OpType = 374
- OpStructEndOmitEmptyUintPtrString OpType = 375
- OpStructFieldFloat32PtrString OpType = 376
- OpStructFieldOmitEmptyFloat32PtrString OpType = 377
- OpStructEndFloat32PtrString OpType = 378
- OpStructEndOmitEmptyFloat32PtrString OpType = 379
- OpStructFieldFloat64PtrString OpType = 380
- OpStructFieldOmitEmptyFloat64PtrString OpType = 381
- OpStructEndFloat64PtrString OpType = 382
- OpStructEndOmitEmptyFloat64PtrString OpType = 383
- OpStructFieldBoolPtrString OpType = 384
- OpStructFieldOmitEmptyBoolPtrString OpType = 385
- OpStructEndBoolPtrString OpType = 386
- OpStructEndOmitEmptyBoolPtrString OpType = 387
- OpStructFieldStringPtrString OpType = 388
- OpStructFieldOmitEmptyStringPtrString OpType = 389
- OpStructEndStringPtrString OpType = 390
- OpStructEndOmitEmptyStringPtrString OpType = 391
- OpStructFieldNumberPtrString OpType = 392
- OpStructFieldOmitEmptyNumberPtrString OpType = 393
- OpStructEndNumberPtrString OpType = 394
- OpStructEndOmitEmptyNumberPtrString OpType = 395
- OpStructField OpType = 396
- OpStructFieldOmitEmpty OpType = 397
- OpStructEnd OpType = 398
- OpStructEndOmitEmpty OpType = 399
-)
-
-func (t OpType) String() string {
- if int(t) >= 400 {
- return ""
- }
- return opTypeStrings[int(t)]
-}
-
-func (t OpType) CodeType() CodeType {
- if strings.Contains(t.String(), "Struct") {
- if strings.Contains(t.String(), "End") {
- return CodeStructEnd
- }
- return CodeStructField
- }
- switch t {
- case OpArray, OpArrayPtr:
- return CodeArrayHead
- case OpArrayElem:
- return CodeArrayElem
- case OpSlice, OpSlicePtr:
- return CodeSliceHead
- case OpSliceElem:
- return CodeSliceElem
- case OpMap, OpMapPtr:
- return CodeMapHead
- case OpMapKey:
- return CodeMapKey
- case OpMapValue:
- return CodeMapValue
- case OpMapEnd:
- return CodeMapEnd
- }
-
- return CodeOp
-}
-
-func (t OpType) HeadToPtrHead() OpType {
- if strings.Index(t.String(), "PtrHead") > 0 {
- return t
- }
-
- idx := strings.Index(t.String(), "Head")
- if idx == -1 {
- return t
- }
- suffix := "PtrHead" + t.String()[idx+len("Head"):]
-
- const toPtrOffset = 2
- if strings.Contains(OpType(int(t)+toPtrOffset).String(), suffix) {
- return OpType(int(t) + toPtrOffset)
- }
- return t
-}
-
-func (t OpType) HeadToOmitEmptyHead() OpType {
- const toOmitEmptyOffset = 1
- if strings.Contains(OpType(int(t)+toOmitEmptyOffset).String(), "OmitEmpty") {
- return OpType(int(t) + toOmitEmptyOffset)
- }
-
- return t
-}
-
-func (t OpType) PtrHeadToHead() OpType {
- idx := strings.Index(t.String(), "PtrHead")
- if idx == -1 {
- return t
- }
- suffix := t.String()[idx+len("Ptr"):]
-
- const toPtrOffset = 2
- if strings.Contains(OpType(int(t)-toPtrOffset).String(), suffix) {
- return OpType(int(t) - toPtrOffset)
- }
- return t
-}
-
-func (t OpType) FieldToEnd() OpType {
- idx := strings.Index(t.String(), "Field")
- if idx == -1 {
- return t
- }
- suffix := t.String()[idx+len("Field"):]
- if suffix == "" || suffix == "OmitEmpty" {
- return t
- }
- const toEndOffset = 2
- if strings.Contains(OpType(int(t)+toEndOffset).String(), "End"+suffix) {
- return OpType(int(t) + toEndOffset)
- }
- return t
-}
-
-func (t OpType) FieldToOmitEmptyField() OpType {
- const toOmitEmptyOffset = 1
- if strings.Contains(OpType(int(t)+toOmitEmptyOffset).String(), "OmitEmpty") {
- return OpType(int(t) + toOmitEmptyOffset)
- }
- return t
-}
diff --git a/vendor/github.com/goccy/go-json/internal/encoder/query.go b/vendor/github.com/goccy/go-json/internal/encoder/query.go
deleted file mode 100644
index 1e1850cc..00000000
--- a/vendor/github.com/goccy/go-json/internal/encoder/query.go
+++ /dev/null
@@ -1,135 +0,0 @@
-package encoder
-
-import (
- "context"
- "fmt"
- "reflect"
-)
-
-var (
- Marshal func(interface{}) ([]byte, error)
- Unmarshal func([]byte, interface{}) error
-)
-
-type FieldQuery struct {
- Name string
- Fields []*FieldQuery
- hash string
-}
-
-func (q *FieldQuery) Hash() string {
- if q.hash != "" {
- return q.hash
- }
- b, _ := Marshal(q)
- q.hash = string(b)
- return q.hash
-}
-
-func (q *FieldQuery) MarshalJSON() ([]byte, error) {
- if q.Name != "" {
- if len(q.Fields) > 0 {
- return Marshal(map[string][]*FieldQuery{q.Name: q.Fields})
- }
- return Marshal(q.Name)
- }
- return Marshal(q.Fields)
-}
-
-func (q *FieldQuery) QueryString() (FieldQueryString, error) {
- b, err := Marshal(q)
- if err != nil {
- return "", err
- }
- return FieldQueryString(b), nil
-}
-
-type FieldQueryString string
-
-func (s FieldQueryString) Build() (*FieldQuery, error) {
- var query interface{}
- if err := Unmarshal([]byte(s), &query); err != nil {
- return nil, err
- }
- return s.build(reflect.ValueOf(query))
-}
-
-func (s FieldQueryString) build(v reflect.Value) (*FieldQuery, error) {
- switch v.Type().Kind() {
- case reflect.String:
- return s.buildString(v)
- case reflect.Map:
- return s.buildMap(v)
- case reflect.Slice:
- return s.buildSlice(v)
- case reflect.Interface:
- return s.build(reflect.ValueOf(v.Interface()))
- }
- return nil, fmt.Errorf("failed to build field query")
-}
-
-func (s FieldQueryString) buildString(v reflect.Value) (*FieldQuery, error) {
- b := []byte(v.String())
- switch b[0] {
- case '[', '{':
- var query interface{}
- if err := Unmarshal(b, &query); err != nil {
- return nil, err
- }
- if str, ok := query.(string); ok {
- return &FieldQuery{Name: str}, nil
- }
- return s.build(reflect.ValueOf(query))
- }
- return &FieldQuery{Name: string(b)}, nil
-}
-
-func (s FieldQueryString) buildSlice(v reflect.Value) (*FieldQuery, error) {
- fields := make([]*FieldQuery, 0, v.Len())
- for i := 0; i < v.Len(); i++ {
- def, err := s.build(v.Index(i))
- if err != nil {
- return nil, err
- }
- fields = append(fields, def)
- }
- return &FieldQuery{Fields: fields}, nil
-}
-
-func (s FieldQueryString) buildMap(v reflect.Value) (*FieldQuery, error) {
- keys := v.MapKeys()
- if len(keys) != 1 {
- return nil, fmt.Errorf("failed to build field query object")
- }
- key := keys[0]
- if key.Type().Kind() != reflect.String {
- return nil, fmt.Errorf("failed to build field query. invalid object key type")
- }
- name := key.String()
- def, err := s.build(v.MapIndex(key))
- if err != nil {
- return nil, err
- }
- return &FieldQuery{
- Name: name,
- Fields: def.Fields,
- }, nil
-}
-
-type queryKey struct{}
-
-func FieldQueryFromContext(ctx context.Context) *FieldQuery {
- query := ctx.Value(queryKey{})
- if query == nil {
- return nil
- }
- q, ok := query.(*FieldQuery)
- if !ok {
- return nil
- }
- return q
-}
-
-func SetFieldQueryToContext(ctx context.Context, query *FieldQuery) context.Context {
- return context.WithValue(ctx, queryKey{}, query)
-}
diff --git a/vendor/github.com/goccy/go-json/internal/encoder/string.go b/vendor/github.com/goccy/go-json/internal/encoder/string.go
deleted file mode 100644
index 4abb8416..00000000
--- a/vendor/github.com/goccy/go-json/internal/encoder/string.go
+++ /dev/null
@@ -1,483 +0,0 @@
-// This files's string processing codes are inspired by https://github.com/segmentio/encoding.
-// The license notation is as follows.
-//
-// # MIT License
-//
-// Copyright (c) 2019 Segment.io, Inc.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-package encoder
-
-import (
- "math/bits"
- "reflect"
- "unsafe"
-)
-
-const (
- lsb = 0x0101010101010101
- msb = 0x8080808080808080
-)
-
-var hex = "0123456789abcdef"
-
-//nolint:govet
-func stringToUint64Slice(s string) []uint64 {
- return *(*[]uint64)(unsafe.Pointer(&reflect.SliceHeader{
- Data: ((*reflect.StringHeader)(unsafe.Pointer(&s))).Data,
- Len: len(s) / 8,
- Cap: len(s) / 8,
- }))
-}
-
-func AppendString(ctx *RuntimeContext, buf []byte, s string) []byte {
- if ctx.Option.Flag&HTMLEscapeOption != 0 {
- if ctx.Option.Flag&NormalizeUTF8Option != 0 {
- return appendNormalizedHTMLString(buf, s)
- }
- return appendHTMLString(buf, s)
- }
- if ctx.Option.Flag&NormalizeUTF8Option != 0 {
- return appendNormalizedString(buf, s)
- }
- return appendString(buf, s)
-}
-
-func appendNormalizedHTMLString(buf []byte, s string) []byte {
- valLen := len(s)
- if valLen == 0 {
- return append(buf, `""`...)
- }
- buf = append(buf, '"')
- var (
- i, j int
- )
- if valLen >= 8 {
- chunks := stringToUint64Slice(s)
- for _, n := range chunks {
- // combine masks before checking for the MSB of each byte. We include
- // `n` in the mask to check whether any of the *input* byte MSBs were
- // set (i.e. the byte was outside the ASCII range).
- mask := n | (n - (lsb * 0x20)) |
- ((n ^ (lsb * '"')) - lsb) |
- ((n ^ (lsb * '\\')) - lsb) |
- ((n ^ (lsb * '<')) - lsb) |
- ((n ^ (lsb * '>')) - lsb) |
- ((n ^ (lsb * '&')) - lsb)
- if (mask & msb) != 0 {
- j = bits.TrailingZeros64(mask&msb) / 8
- goto ESCAPE_END
- }
- }
- for i := len(chunks) * 8; i < valLen; i++ {
- if needEscapeHTMLNormalizeUTF8[s[i]] {
- j = i
- goto ESCAPE_END
- }
- }
- // no found any escape characters.
- return append(append(buf, s...), '"')
- }
-ESCAPE_END:
- for j < valLen {
- c := s[j]
-
- if !needEscapeHTMLNormalizeUTF8[c] {
- // fast path: most of the time, printable ascii characters are used
- j++
- continue
- }
-
- switch c {
- case '\\', '"':
- buf = append(buf, s[i:j]...)
- buf = append(buf, '\\', c)
- i = j + 1
- j = j + 1
- continue
-
- case '\n':
- buf = append(buf, s[i:j]...)
- buf = append(buf, '\\', 'n')
- i = j + 1
- j = j + 1
- continue
-
- case '\r':
- buf = append(buf, s[i:j]...)
- buf = append(buf, '\\', 'r')
- i = j + 1
- j = j + 1
- continue
-
- case '\t':
- buf = append(buf, s[i:j]...)
- buf = append(buf, '\\', 't')
- i = j + 1
- j = j + 1
- continue
-
- case '<', '>', '&':
- buf = append(buf, s[i:j]...)
- buf = append(buf, `\u00`...)
- buf = append(buf, hex[c>>4], hex[c&0xF])
- i = j + 1
- j = j + 1
- continue
-
- case 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x0B, 0x0C, 0x0E, 0x0F, // 0x00-0x0F
- 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F: // 0x10-0x1F
- buf = append(buf, s[i:j]...)
- buf = append(buf, `\u00`...)
- buf = append(buf, hex[c>>4], hex[c&0xF])
- i = j + 1
- j = j + 1
- continue
- }
- state, size := decodeRuneInString(s[j:])
- switch state {
- case runeErrorState:
- buf = append(buf, s[i:j]...)
- buf = append(buf, `\ufffd`...)
- i = j + 1
- j = j + 1
- continue
- // U+2028 is LINE SEPARATOR.
- // U+2029 is PARAGRAPH SEPARATOR.
- // They are both technically valid characters in JSON strings,
- // but don't work in JSONP, which has to be evaluated as JavaScript,
- // and can lead to security holes there. It is valid JSON to
- // escape them, so we do so unconditionally.
- // See http://timelessrepo.com/json-isnt-a-javascript-subset for discussion.
- case lineSepState:
- buf = append(buf, s[i:j]...)
- buf = append(buf, `\u2028`...)
- i = j + 3
- j = j + 3
- continue
- case paragraphSepState:
- buf = append(buf, s[i:j]...)
- buf = append(buf, `\u2029`...)
- i = j + 3
- j = j + 3
- continue
- }
- j += size
- }
-
- return append(append(buf, s[i:]...), '"')
-}
-
-func appendHTMLString(buf []byte, s string) []byte {
- valLen := len(s)
- if valLen == 0 {
- return append(buf, `""`...)
- }
- buf = append(buf, '"')
- var (
- i, j int
- )
- if valLen >= 8 {
- chunks := stringToUint64Slice(s)
- for _, n := range chunks {
- // combine masks before checking for the MSB of each byte. We include
- // `n` in the mask to check whether any of the *input* byte MSBs were
- // set (i.e. the byte was outside the ASCII range).
- mask := n | (n - (lsb * 0x20)) |
- ((n ^ (lsb * '"')) - lsb) |
- ((n ^ (lsb * '\\')) - lsb) |
- ((n ^ (lsb * '<')) - lsb) |
- ((n ^ (lsb * '>')) - lsb) |
- ((n ^ (lsb * '&')) - lsb)
- if (mask & msb) != 0 {
- j = bits.TrailingZeros64(mask&msb) / 8
- goto ESCAPE_END
- }
- }
- for i := len(chunks) * 8; i < valLen; i++ {
- if needEscapeHTML[s[i]] {
- j = i
- goto ESCAPE_END
- }
- }
- // no found any escape characters.
- return append(append(buf, s...), '"')
- }
-ESCAPE_END:
- for j < valLen {
- c := s[j]
-
- if !needEscapeHTML[c] {
- // fast path: most of the time, printable ascii characters are used
- j++
- continue
- }
-
- switch c {
- case '\\', '"':
- buf = append(buf, s[i:j]...)
- buf = append(buf, '\\', c)
- i = j + 1
- j = j + 1
- continue
-
- case '\n':
- buf = append(buf, s[i:j]...)
- buf = append(buf, '\\', 'n')
- i = j + 1
- j = j + 1
- continue
-
- case '\r':
- buf = append(buf, s[i:j]...)
- buf = append(buf, '\\', 'r')
- i = j + 1
- j = j + 1
- continue
-
- case '\t':
- buf = append(buf, s[i:j]...)
- buf = append(buf, '\\', 't')
- i = j + 1
- j = j + 1
- continue
-
- case '<', '>', '&':
- buf = append(buf, s[i:j]...)
- buf = append(buf, `\u00`...)
- buf = append(buf, hex[c>>4], hex[c&0xF])
- i = j + 1
- j = j + 1
- continue
-
- case 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x0B, 0x0C, 0x0E, 0x0F, // 0x00-0x0F
- 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F: // 0x10-0x1F
- buf = append(buf, s[i:j]...)
- buf = append(buf, `\u00`...)
- buf = append(buf, hex[c>>4], hex[c&0xF])
- i = j + 1
- j = j + 1
- continue
- }
- j++
- }
-
- return append(append(buf, s[i:]...), '"')
-}
-
-func appendNormalizedString(buf []byte, s string) []byte {
- valLen := len(s)
- if valLen == 0 {
- return append(buf, `""`...)
- }
- buf = append(buf, '"')
- var (
- i, j int
- )
- if valLen >= 8 {
- chunks := stringToUint64Slice(s)
- for _, n := range chunks {
- // combine masks before checking for the MSB of each byte. We include
- // `n` in the mask to check whether any of the *input* byte MSBs were
- // set (i.e. the byte was outside the ASCII range).
- mask := n | (n - (lsb * 0x20)) |
- ((n ^ (lsb * '"')) - lsb) |
- ((n ^ (lsb * '\\')) - lsb)
- if (mask & msb) != 0 {
- j = bits.TrailingZeros64(mask&msb) / 8
- goto ESCAPE_END
- }
- }
- valLen := len(s)
- for i := len(chunks) * 8; i < valLen; i++ {
- if needEscapeNormalizeUTF8[s[i]] {
- j = i
- goto ESCAPE_END
- }
- }
- return append(append(buf, s...), '"')
- }
-ESCAPE_END:
- for j < valLen {
- c := s[j]
-
- if !needEscapeNormalizeUTF8[c] {
- // fast path: most of the time, printable ascii characters are used
- j++
- continue
- }
-
- switch c {
- case '\\', '"':
- buf = append(buf, s[i:j]...)
- buf = append(buf, '\\', c)
- i = j + 1
- j = j + 1
- continue
-
- case '\n':
- buf = append(buf, s[i:j]...)
- buf = append(buf, '\\', 'n')
- i = j + 1
- j = j + 1
- continue
-
- case '\r':
- buf = append(buf, s[i:j]...)
- buf = append(buf, '\\', 'r')
- i = j + 1
- j = j + 1
- continue
-
- case '\t':
- buf = append(buf, s[i:j]...)
- buf = append(buf, '\\', 't')
- i = j + 1
- j = j + 1
- continue
-
- case 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x0B, 0x0C, 0x0E, 0x0F, // 0x00-0x0F
- 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F: // 0x10-0x1F
- buf = append(buf, s[i:j]...)
- buf = append(buf, `\u00`...)
- buf = append(buf, hex[c>>4], hex[c&0xF])
- i = j + 1
- j = j + 1
- continue
- }
-
- state, size := decodeRuneInString(s[j:])
- switch state {
- case runeErrorState:
- buf = append(buf, s[i:j]...)
- buf = append(buf, `\ufffd`...)
- i = j + 1
- j = j + 1
- continue
- // U+2028 is LINE SEPARATOR.
- // U+2029 is PARAGRAPH SEPARATOR.
- // They are both technically valid characters in JSON strings,
- // but don't work in JSONP, which has to be evaluated as JavaScript,
- // and can lead to security holes there. It is valid JSON to
- // escape them, so we do so unconditionally.
- // See http://timelessrepo.com/json-isnt-a-javascript-subset for discussion.
- case lineSepState:
- buf = append(buf, s[i:j]...)
- buf = append(buf, `\u2028`...)
- i = j + 3
- j = j + 3
- continue
- case paragraphSepState:
- buf = append(buf, s[i:j]...)
- buf = append(buf, `\u2029`...)
- i = j + 3
- j = j + 3
- continue
- }
- j += size
- }
-
- return append(append(buf, s[i:]...), '"')
-}
-
-func appendString(buf []byte, s string) []byte {
- valLen := len(s)
- if valLen == 0 {
- return append(buf, `""`...)
- }
- buf = append(buf, '"')
- var (
- i, j int
- )
- if valLen >= 8 {
- chunks := stringToUint64Slice(s)
- for _, n := range chunks {
- // combine masks before checking for the MSB of each byte. We include
- // `n` in the mask to check whether any of the *input* byte MSBs were
- // set (i.e. the byte was outside the ASCII range).
- mask := n | (n - (lsb * 0x20)) |
- ((n ^ (lsb * '"')) - lsb) |
- ((n ^ (lsb * '\\')) - lsb)
- if (mask & msb) != 0 {
- j = bits.TrailingZeros64(mask&msb) / 8
- goto ESCAPE_END
- }
- }
- valLen := len(s)
- for i := len(chunks) * 8; i < valLen; i++ {
- if needEscape[s[i]] {
- j = i
- goto ESCAPE_END
- }
- }
- return append(append(buf, s...), '"')
- }
-ESCAPE_END:
- for j < valLen {
- c := s[j]
-
- if !needEscape[c] {
- // fast path: most of the time, printable ascii characters are used
- j++
- continue
- }
-
- switch c {
- case '\\', '"':
- buf = append(buf, s[i:j]...)
- buf = append(buf, '\\', c)
- i = j + 1
- j = j + 1
- continue
-
- case '\n':
- buf = append(buf, s[i:j]...)
- buf = append(buf, '\\', 'n')
- i = j + 1
- j = j + 1
- continue
-
- case '\r':
- buf = append(buf, s[i:j]...)
- buf = append(buf, '\\', 'r')
- i = j + 1
- j = j + 1
- continue
-
- case '\t':
- buf = append(buf, s[i:j]...)
- buf = append(buf, '\\', 't')
- i = j + 1
- j = j + 1
- continue
-
- case 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x0B, 0x0C, 0x0E, 0x0F, // 0x00-0x0F
- 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F: // 0x10-0x1F
- buf = append(buf, s[i:j]...)
- buf = append(buf, `\u00`...)
- buf = append(buf, hex[c>>4], hex[c&0xF])
- i = j + 1
- j = j + 1
- continue
- }
- j++
- }
-
- return append(append(buf, s[i:]...), '"')
-}
diff --git a/vendor/github.com/goccy/go-json/internal/encoder/string_table.go b/vendor/github.com/goccy/go-json/internal/encoder/string_table.go
deleted file mode 100644
index ebe42c92..00000000
--- a/vendor/github.com/goccy/go-json/internal/encoder/string_table.go
+++ /dev/null
@@ -1,415 +0,0 @@
-package encoder
-
-var needEscapeHTMLNormalizeUTF8 = [256]bool{
- '"': true,
- '&': true,
- '<': true,
- '>': true,
- '\\': true,
- 0x00: true,
- 0x01: true,
- 0x02: true,
- 0x03: true,
- 0x04: true,
- 0x05: true,
- 0x06: true,
- 0x07: true,
- 0x08: true,
- 0x09: true,
- 0x0a: true,
- 0x0b: true,
- 0x0c: true,
- 0x0d: true,
- 0x0e: true,
- 0x0f: true,
- 0x10: true,
- 0x11: true,
- 0x12: true,
- 0x13: true,
- 0x14: true,
- 0x15: true,
- 0x16: true,
- 0x17: true,
- 0x18: true,
- 0x19: true,
- 0x1a: true,
- 0x1b: true,
- 0x1c: true,
- 0x1d: true,
- 0x1e: true,
- 0x1f: true,
- /* 0x20 - 0x7f */
- 0x80: true,
- 0x81: true,
- 0x82: true,
- 0x83: true,
- 0x84: true,
- 0x85: true,
- 0x86: true,
- 0x87: true,
- 0x88: true,
- 0x89: true,
- 0x8a: true,
- 0x8b: true,
- 0x8c: true,
- 0x8d: true,
- 0x8e: true,
- 0x8f: true,
- 0x90: true,
- 0x91: true,
- 0x92: true,
- 0x93: true,
- 0x94: true,
- 0x95: true,
- 0x96: true,
- 0x97: true,
- 0x98: true,
- 0x99: true,
- 0x9a: true,
- 0x9b: true,
- 0x9c: true,
- 0x9d: true,
- 0x9e: true,
- 0x9f: true,
- 0xa0: true,
- 0xa1: true,
- 0xa2: true,
- 0xa3: true,
- 0xa4: true,
- 0xa5: true,
- 0xa6: true,
- 0xa7: true,
- 0xa8: true,
- 0xa9: true,
- 0xaa: true,
- 0xab: true,
- 0xac: true,
- 0xad: true,
- 0xae: true,
- 0xaf: true,
- 0xb0: true,
- 0xb1: true,
- 0xb2: true,
- 0xb3: true,
- 0xb4: true,
- 0xb5: true,
- 0xb6: true,
- 0xb7: true,
- 0xb8: true,
- 0xb9: true,
- 0xba: true,
- 0xbb: true,
- 0xbc: true,
- 0xbd: true,
- 0xbe: true,
- 0xbf: true,
- 0xc0: true,
- 0xc1: true,
- 0xc2: true,
- 0xc3: true,
- 0xc4: true,
- 0xc5: true,
- 0xc6: true,
- 0xc7: true,
- 0xc8: true,
- 0xc9: true,
- 0xca: true,
- 0xcb: true,
- 0xcc: true,
- 0xcd: true,
- 0xce: true,
- 0xcf: true,
- 0xd0: true,
- 0xd1: true,
- 0xd2: true,
- 0xd3: true,
- 0xd4: true,
- 0xd5: true,
- 0xd6: true,
- 0xd7: true,
- 0xd8: true,
- 0xd9: true,
- 0xda: true,
- 0xdb: true,
- 0xdc: true,
- 0xdd: true,
- 0xde: true,
- 0xdf: true,
- 0xe0: true,
- 0xe1: true,
- 0xe2: true,
- 0xe3: true,
- 0xe4: true,
- 0xe5: true,
- 0xe6: true,
- 0xe7: true,
- 0xe8: true,
- 0xe9: true,
- 0xea: true,
- 0xeb: true,
- 0xec: true,
- 0xed: true,
- 0xee: true,
- 0xef: true,
- 0xf0: true,
- 0xf1: true,
- 0xf2: true,
- 0xf3: true,
- 0xf4: true,
- 0xf5: true,
- 0xf6: true,
- 0xf7: true,
- 0xf8: true,
- 0xf9: true,
- 0xfa: true,
- 0xfb: true,
- 0xfc: true,
- 0xfd: true,
- 0xfe: true,
- 0xff: true,
-}
-
-var needEscapeNormalizeUTF8 = [256]bool{
- '"': true,
- '\\': true,
- 0x00: true,
- 0x01: true,
- 0x02: true,
- 0x03: true,
- 0x04: true,
- 0x05: true,
- 0x06: true,
- 0x07: true,
- 0x08: true,
- 0x09: true,
- 0x0a: true,
- 0x0b: true,
- 0x0c: true,
- 0x0d: true,
- 0x0e: true,
- 0x0f: true,
- 0x10: true,
- 0x11: true,
- 0x12: true,
- 0x13: true,
- 0x14: true,
- 0x15: true,
- 0x16: true,
- 0x17: true,
- 0x18: true,
- 0x19: true,
- 0x1a: true,
- 0x1b: true,
- 0x1c: true,
- 0x1d: true,
- 0x1e: true,
- 0x1f: true,
- /* 0x20 - 0x7f */
- 0x80: true,
- 0x81: true,
- 0x82: true,
- 0x83: true,
- 0x84: true,
- 0x85: true,
- 0x86: true,
- 0x87: true,
- 0x88: true,
- 0x89: true,
- 0x8a: true,
- 0x8b: true,
- 0x8c: true,
- 0x8d: true,
- 0x8e: true,
- 0x8f: true,
- 0x90: true,
- 0x91: true,
- 0x92: true,
- 0x93: true,
- 0x94: true,
- 0x95: true,
- 0x96: true,
- 0x97: true,
- 0x98: true,
- 0x99: true,
- 0x9a: true,
- 0x9b: true,
- 0x9c: true,
- 0x9d: true,
- 0x9e: true,
- 0x9f: true,
- 0xa0: true,
- 0xa1: true,
- 0xa2: true,
- 0xa3: true,
- 0xa4: true,
- 0xa5: true,
- 0xa6: true,
- 0xa7: true,
- 0xa8: true,
- 0xa9: true,
- 0xaa: true,
- 0xab: true,
- 0xac: true,
- 0xad: true,
- 0xae: true,
- 0xaf: true,
- 0xb0: true,
- 0xb1: true,
- 0xb2: true,
- 0xb3: true,
- 0xb4: true,
- 0xb5: true,
- 0xb6: true,
- 0xb7: true,
- 0xb8: true,
- 0xb9: true,
- 0xba: true,
- 0xbb: true,
- 0xbc: true,
- 0xbd: true,
- 0xbe: true,
- 0xbf: true,
- 0xc0: true,
- 0xc1: true,
- 0xc2: true,
- 0xc3: true,
- 0xc4: true,
- 0xc5: true,
- 0xc6: true,
- 0xc7: true,
- 0xc8: true,
- 0xc9: true,
- 0xca: true,
- 0xcb: true,
- 0xcc: true,
- 0xcd: true,
- 0xce: true,
- 0xcf: true,
- 0xd0: true,
- 0xd1: true,
- 0xd2: true,
- 0xd3: true,
- 0xd4: true,
- 0xd5: true,
- 0xd6: true,
- 0xd7: true,
- 0xd8: true,
- 0xd9: true,
- 0xda: true,
- 0xdb: true,
- 0xdc: true,
- 0xdd: true,
- 0xde: true,
- 0xdf: true,
- 0xe0: true,
- 0xe1: true,
- 0xe2: true,
- 0xe3: true,
- 0xe4: true,
- 0xe5: true,
- 0xe6: true,
- 0xe7: true,
- 0xe8: true,
- 0xe9: true,
- 0xea: true,
- 0xeb: true,
- 0xec: true,
- 0xed: true,
- 0xee: true,
- 0xef: true,
- 0xf0: true,
- 0xf1: true,
- 0xf2: true,
- 0xf3: true,
- 0xf4: true,
- 0xf5: true,
- 0xf6: true,
- 0xf7: true,
- 0xf8: true,
- 0xf9: true,
- 0xfa: true,
- 0xfb: true,
- 0xfc: true,
- 0xfd: true,
- 0xfe: true,
- 0xff: true,
-}
-
-var needEscapeHTML = [256]bool{
- '"': true,
- '&': true,
- '<': true,
- '>': true,
- '\\': true,
- 0x00: true,
- 0x01: true,
- 0x02: true,
- 0x03: true,
- 0x04: true,
- 0x05: true,
- 0x06: true,
- 0x07: true,
- 0x08: true,
- 0x09: true,
- 0x0a: true,
- 0x0b: true,
- 0x0c: true,
- 0x0d: true,
- 0x0e: true,
- 0x0f: true,
- 0x10: true,
- 0x11: true,
- 0x12: true,
- 0x13: true,
- 0x14: true,
- 0x15: true,
- 0x16: true,
- 0x17: true,
- 0x18: true,
- 0x19: true,
- 0x1a: true,
- 0x1b: true,
- 0x1c: true,
- 0x1d: true,
- 0x1e: true,
- 0x1f: true,
- /* 0x20 - 0xff */
-}
-
-var needEscape = [256]bool{
- '"': true,
- '\\': true,
- 0x00: true,
- 0x01: true,
- 0x02: true,
- 0x03: true,
- 0x04: true,
- 0x05: true,
- 0x06: true,
- 0x07: true,
- 0x08: true,
- 0x09: true,
- 0x0a: true,
- 0x0b: true,
- 0x0c: true,
- 0x0d: true,
- 0x0e: true,
- 0x0f: true,
- 0x10: true,
- 0x11: true,
- 0x12: true,
- 0x13: true,
- 0x14: true,
- 0x15: true,
- 0x16: true,
- 0x17: true,
- 0x18: true,
- 0x19: true,
- 0x1a: true,
- 0x1b: true,
- 0x1c: true,
- 0x1d: true,
- 0x1e: true,
- 0x1f: true,
- /* 0x20 - 0xff */
-}
diff --git a/vendor/github.com/goccy/go-json/internal/encoder/vm/debug_vm.go b/vendor/github.com/goccy/go-json/internal/encoder/vm/debug_vm.go
deleted file mode 100644
index 82b6dd47..00000000
--- a/vendor/github.com/goccy/go-json/internal/encoder/vm/debug_vm.go
+++ /dev/null
@@ -1,41 +0,0 @@
-package vm
-
-import (
- "fmt"
- "io"
-
- "github.com/goccy/go-json/internal/encoder"
-)
-
-func DebugRun(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet) ([]byte, error) {
- defer func() {
- var code *encoder.Opcode
- if (ctx.Option.Flag & encoder.HTMLEscapeOption) != 0 {
- code = codeSet.EscapeKeyCode
- } else {
- code = codeSet.NoescapeKeyCode
- }
- if wc := ctx.Option.DebugDOTOut; wc != nil {
- _, _ = io.WriteString(wc, code.DumpDOT())
- wc.Close()
- ctx.Option.DebugDOTOut = nil
- }
-
- if err := recover(); err != nil {
- w := ctx.Option.DebugOut
- fmt.Fprintln(w, "=============[DEBUG]===============")
- fmt.Fprintln(w, "* [TYPE]")
- fmt.Fprintln(w, codeSet.Type)
- fmt.Fprintf(w, "\n")
- fmt.Fprintln(w, "* [ALL OPCODE]")
- fmt.Fprintln(w, code.Dump())
- fmt.Fprintf(w, "\n")
- fmt.Fprintln(w, "* [CONTEXT]")
- fmt.Fprintf(w, "%+v\n", ctx)
- fmt.Fprintln(w, "===================================")
- panic(err)
- }
- }()
-
- return Run(ctx, b, codeSet)
-}
diff --git a/vendor/github.com/goccy/go-json/internal/encoder/vm/hack.go b/vendor/github.com/goccy/go-json/internal/encoder/vm/hack.go
deleted file mode 100644
index 65252b4a..00000000
--- a/vendor/github.com/goccy/go-json/internal/encoder/vm/hack.go
+++ /dev/null
@@ -1,9 +0,0 @@
-package vm
-
-import (
- // HACK: compile order
- // `vm`, `vm_indent`, `vm_color`, `vm_color_indent` packages uses a lot of memory to compile,
- // so forcibly make dependencies and avoid compiling in concurrent.
- // dependency order: vm => vm_indent => vm_color => vm_color_indent
- _ "github.com/goccy/go-json/internal/encoder/vm_indent"
-)
diff --git a/vendor/github.com/goccy/go-json/internal/encoder/vm/util.go b/vendor/github.com/goccy/go-json/internal/encoder/vm/util.go
deleted file mode 100644
index 86291d7b..00000000
--- a/vendor/github.com/goccy/go-json/internal/encoder/vm/util.go
+++ /dev/null
@@ -1,207 +0,0 @@
-package vm
-
-import (
- "encoding/json"
- "fmt"
- "unsafe"
-
- "github.com/goccy/go-json/internal/encoder"
- "github.com/goccy/go-json/internal/runtime"
-)
-
-const uintptrSize = 4 << (^uintptr(0) >> 63)
-
-var (
- appendInt = encoder.AppendInt
- appendUint = encoder.AppendUint
- appendFloat32 = encoder.AppendFloat32
- appendFloat64 = encoder.AppendFloat64
- appendString = encoder.AppendString
- appendByteSlice = encoder.AppendByteSlice
- appendNumber = encoder.AppendNumber
- errUnsupportedValue = encoder.ErrUnsupportedValue
- errUnsupportedFloat = encoder.ErrUnsupportedFloat
- mapiterinit = encoder.MapIterInit
- mapiterkey = encoder.MapIterKey
- mapitervalue = encoder.MapIterValue
- mapiternext = encoder.MapIterNext
- maplen = encoder.MapLen
-)
-
-type emptyInterface struct {
- typ *runtime.Type
- ptr unsafe.Pointer
-}
-
-type nonEmptyInterface struct {
- itab *struct {
- ityp *runtime.Type // static interface type
- typ *runtime.Type // dynamic concrete type
- // unused fields...
- }
- ptr unsafe.Pointer
-}
-
-func errUnimplementedOp(op encoder.OpType) error {
- return fmt.Errorf("encoder: opcode %s has not been implemented", op)
-}
-
-func load(base uintptr, idx uint32) uintptr {
- addr := base + uintptr(idx)
- return **(**uintptr)(unsafe.Pointer(&addr))
-}
-
-func store(base uintptr, idx uint32, p uintptr) {
- addr := base + uintptr(idx)
- **(**uintptr)(unsafe.Pointer(&addr)) = p
-}
-
-func loadNPtr(base uintptr, idx uint32, ptrNum uint8) uintptr {
- addr := base + uintptr(idx)
- p := **(**uintptr)(unsafe.Pointer(&addr))
- for i := uint8(0); i < ptrNum; i++ {
- if p == 0 {
- return 0
- }
- p = ptrToPtr(p)
- }
- return p
-}
-
-func ptrToUint64(p uintptr, bitSize uint8) uint64 {
- switch bitSize {
- case 8:
- return (uint64)(**(**uint8)(unsafe.Pointer(&p)))
- case 16:
- return (uint64)(**(**uint16)(unsafe.Pointer(&p)))
- case 32:
- return (uint64)(**(**uint32)(unsafe.Pointer(&p)))
- case 64:
- return **(**uint64)(unsafe.Pointer(&p))
- }
- return 0
-}
-func ptrToFloat32(p uintptr) float32 { return **(**float32)(unsafe.Pointer(&p)) }
-func ptrToFloat64(p uintptr) float64 { return **(**float64)(unsafe.Pointer(&p)) }
-func ptrToBool(p uintptr) bool { return **(**bool)(unsafe.Pointer(&p)) }
-func ptrToBytes(p uintptr) []byte { return **(**[]byte)(unsafe.Pointer(&p)) }
-func ptrToNumber(p uintptr) json.Number { return **(**json.Number)(unsafe.Pointer(&p)) }
-func ptrToString(p uintptr) string { return **(**string)(unsafe.Pointer(&p)) }
-func ptrToSlice(p uintptr) *runtime.SliceHeader { return *(**runtime.SliceHeader)(unsafe.Pointer(&p)) }
-func ptrToPtr(p uintptr) uintptr {
- return uintptr(**(**unsafe.Pointer)(unsafe.Pointer(&p)))
-}
-func ptrToNPtr(p uintptr, ptrNum uint8) uintptr {
- for i := uint8(0); i < ptrNum; i++ {
- if p == 0 {
- return 0
- }
- p = ptrToPtr(p)
- }
- return p
-}
-
-func ptrToUnsafePtr(p uintptr) unsafe.Pointer {
- return *(*unsafe.Pointer)(unsafe.Pointer(&p))
-}
-func ptrToInterface(code *encoder.Opcode, p uintptr) interface{} {
- return *(*interface{})(unsafe.Pointer(&emptyInterface{
- typ: code.Type,
- ptr: *(*unsafe.Pointer)(unsafe.Pointer(&p)),
- }))
-}
-
-func appendBool(_ *encoder.RuntimeContext, b []byte, v bool) []byte {
- if v {
- return append(b, "true"...)
- }
- return append(b, "false"...)
-}
-
-func appendNull(_ *encoder.RuntimeContext, b []byte) []byte {
- return append(b, "null"...)
-}
-
-func appendComma(_ *encoder.RuntimeContext, b []byte) []byte {
- return append(b, ',')
-}
-
-func appendNullComma(_ *encoder.RuntimeContext, b []byte) []byte {
- return append(b, "null,"...)
-}
-
-func appendColon(_ *encoder.RuntimeContext, b []byte) []byte {
- last := len(b) - 1
- b[last] = ':'
- return b
-}
-
-func appendMapKeyValue(_ *encoder.RuntimeContext, _ *encoder.Opcode, b, key, value []byte) []byte {
- b = append(b, key...)
- b[len(b)-1] = ':'
- return append(b, value...)
-}
-
-func appendMapEnd(_ *encoder.RuntimeContext, _ *encoder.Opcode, b []byte) []byte {
- b[len(b)-1] = '}'
- b = append(b, ',')
- return b
-}
-
-func appendMarshalJSON(ctx *encoder.RuntimeContext, code *encoder.Opcode, b []byte, v interface{}) ([]byte, error) {
- return encoder.AppendMarshalJSON(ctx, code, b, v)
-}
-
-func appendMarshalText(ctx *encoder.RuntimeContext, code *encoder.Opcode, b []byte, v interface{}) ([]byte, error) {
- return encoder.AppendMarshalText(ctx, code, b, v)
-}
-
-func appendArrayHead(_ *encoder.RuntimeContext, _ *encoder.Opcode, b []byte) []byte {
- return append(b, '[')
-}
-
-func appendArrayEnd(_ *encoder.RuntimeContext, _ *encoder.Opcode, b []byte) []byte {
- last := len(b) - 1
- b[last] = ']'
- return append(b, ',')
-}
-
-func appendEmptyArray(_ *encoder.RuntimeContext, b []byte) []byte {
- return append(b, '[', ']', ',')
-}
-
-func appendEmptyObject(_ *encoder.RuntimeContext, b []byte) []byte {
- return append(b, '{', '}', ',')
-}
-
-func appendObjectEnd(_ *encoder.RuntimeContext, _ *encoder.Opcode, b []byte) []byte {
- last := len(b) - 1
- b[last] = '}'
- return append(b, ',')
-}
-
-func appendStructHead(_ *encoder.RuntimeContext, b []byte) []byte {
- return append(b, '{')
-}
-
-func appendStructKey(_ *encoder.RuntimeContext, code *encoder.Opcode, b []byte) []byte {
- return append(b, code.Key...)
-}
-
-func appendStructEnd(_ *encoder.RuntimeContext, _ *encoder.Opcode, b []byte) []byte {
- return append(b, '}', ',')
-}
-
-func appendStructEndSkipLast(ctx *encoder.RuntimeContext, code *encoder.Opcode, b []byte) []byte {
- last := len(b) - 1
- if b[last] == ',' {
- b[last] = '}'
- return appendComma(ctx, b)
- }
- return appendStructEnd(ctx, code, b)
-}
-
-func restoreIndent(_ *encoder.RuntimeContext, _ *encoder.Opcode, _ uintptr) {}
-func storeIndent(_ uintptr, _ *encoder.Opcode, _ uintptr) {}
-func appendMapKeyIndent(_ *encoder.RuntimeContext, _ *encoder.Opcode, b []byte) []byte { return b }
-func appendArrayElemIndent(_ *encoder.RuntimeContext, _ *encoder.Opcode, b []byte) []byte { return b }
diff --git a/vendor/github.com/goccy/go-json/internal/encoder/vm/vm.go b/vendor/github.com/goccy/go-json/internal/encoder/vm/vm.go
deleted file mode 100644
index 645d20f9..00000000
--- a/vendor/github.com/goccy/go-json/internal/encoder/vm/vm.go
+++ /dev/null
@@ -1,4859 +0,0 @@
-// Code generated by internal/cmd/generator. DO NOT EDIT!
-package vm
-
-import (
- "math"
- "reflect"
- "sort"
- "unsafe"
-
- "github.com/goccy/go-json/internal/encoder"
- "github.com/goccy/go-json/internal/runtime"
-)
-
-func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet) ([]byte, error) {
- recursiveLevel := 0
- ptrOffset := uintptr(0)
- ctxptr := ctx.Ptr()
- var code *encoder.Opcode
- if (ctx.Option.Flag & encoder.HTMLEscapeOption) != 0 {
- code = codeSet.EscapeKeyCode
- } else {
- code = codeSet.NoescapeKeyCode
- }
-
- for {
- switch code.Op {
- default:
- return nil, errUnimplementedOp(code.Op)
- case encoder.OpPtr:
- p := load(ctxptr, code.Idx)
- code = code.Next
- store(ctxptr, code.Idx, ptrToPtr(p))
- case encoder.OpIntPtr:
- p := loadNPtr(ctxptr, code.Idx, code.PtrNum)
- if p == 0 {
- b = appendNullComma(ctx, b)
- code = code.Next
- break
- }
- store(ctxptr, code.Idx, p)
- fallthrough
- case encoder.OpInt:
- b = appendInt(ctx, b, load(ctxptr, code.Idx), code)
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpUintPtr:
- p := loadNPtr(ctxptr, code.Idx, code.PtrNum)
- if p == 0 {
- b = appendNullComma(ctx, b)
- code = code.Next
- break
- }
- store(ctxptr, code.Idx, p)
- fallthrough
- case encoder.OpUint:
- b = appendUint(ctx, b, load(ctxptr, code.Idx), code)
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpIntString:
- b = append(b, '"')
- b = appendInt(ctx, b, load(ctxptr, code.Idx), code)
- b = append(b, '"')
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpUintString:
- b = append(b, '"')
- b = appendUint(ctx, b, load(ctxptr, code.Idx), code)
- b = append(b, '"')
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpFloat32Ptr:
- p := loadNPtr(ctxptr, code.Idx, code.PtrNum)
- if p == 0 {
- b = appendNull(ctx, b)
- b = appendComma(ctx, b)
- code = code.Next
- break
- }
- store(ctxptr, code.Idx, p)
- fallthrough
- case encoder.OpFloat32:
- b = appendFloat32(ctx, b, ptrToFloat32(load(ctxptr, code.Idx)))
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpFloat64Ptr:
- p := loadNPtr(ctxptr, code.Idx, code.PtrNum)
- if p == 0 {
- b = appendNullComma(ctx, b)
- code = code.Next
- break
- }
- store(ctxptr, code.Idx, p)
- fallthrough
- case encoder.OpFloat64:
- v := ptrToFloat64(load(ctxptr, code.Idx))
- if math.IsInf(v, 0) || math.IsNaN(v) {
- return nil, errUnsupportedFloat(v)
- }
- b = appendFloat64(ctx, b, v)
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStringPtr:
- p := loadNPtr(ctxptr, code.Idx, code.PtrNum)
- if p == 0 {
- b = appendNullComma(ctx, b)
- code = code.Next
- break
- }
- store(ctxptr, code.Idx, p)
- fallthrough
- case encoder.OpString:
- b = appendString(ctx, b, ptrToString(load(ctxptr, code.Idx)))
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpBoolPtr:
- p := loadNPtr(ctxptr, code.Idx, code.PtrNum)
- if p == 0 {
- b = appendNullComma(ctx, b)
- code = code.Next
- break
- }
- store(ctxptr, code.Idx, p)
- fallthrough
- case encoder.OpBool:
- b = appendBool(ctx, b, ptrToBool(load(ctxptr, code.Idx)))
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpBytesPtr:
- p := loadNPtr(ctxptr, code.Idx, code.PtrNum)
- if p == 0 {
- b = appendNullComma(ctx, b)
- code = code.Next
- break
- }
- store(ctxptr, code.Idx, p)
- fallthrough
- case encoder.OpBytes:
- b = appendByteSlice(ctx, b, ptrToBytes(load(ctxptr, code.Idx)))
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpNumberPtr:
- p := loadNPtr(ctxptr, code.Idx, code.PtrNum)
- if p == 0 {
- b = appendNullComma(ctx, b)
- code = code.Next
- break
- }
- store(ctxptr, code.Idx, p)
- fallthrough
- case encoder.OpNumber:
- bb, err := appendNumber(ctx, b, ptrToNumber(load(ctxptr, code.Idx)))
- if err != nil {
- return nil, err
- }
- b = appendComma(ctx, bb)
- code = code.Next
- case encoder.OpInterfacePtr:
- p := loadNPtr(ctxptr, code.Idx, code.PtrNum)
- if p == 0 {
- b = appendNullComma(ctx, b)
- code = code.Next
- break
- }
- store(ctxptr, code.Idx, p)
- fallthrough
- case encoder.OpInterface:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- b = appendNullComma(ctx, b)
- code = code.Next
- break
- }
- if recursiveLevel > encoder.StartDetectingCyclesAfter {
- for _, seen := range ctx.SeenPtr {
- if p == seen {
- return nil, errUnsupportedValue(code, p)
- }
- }
- }
- ctx.SeenPtr = append(ctx.SeenPtr, p)
- var (
- typ *runtime.Type
- ifacePtr unsafe.Pointer
- )
- up := ptrToUnsafePtr(p)
- if code.Flags&encoder.NonEmptyInterfaceFlags != 0 {
- iface := (*nonEmptyInterface)(up)
- ifacePtr = iface.ptr
- if iface.itab != nil {
- typ = iface.itab.typ
- }
- } else {
- iface := (*emptyInterface)(up)
- ifacePtr = iface.ptr
- typ = iface.typ
- }
- if ifacePtr == nil {
- isDirectedNil := typ != nil && typ.Kind() == reflect.Struct && !runtime.IfaceIndir(typ)
- if !isDirectedNil {
- b = appendNullComma(ctx, b)
- code = code.Next
- break
- }
- }
- ctx.KeepRefs = append(ctx.KeepRefs, up)
- ifaceCodeSet, err := encoder.CompileToGetCodeSet(ctx, uintptr(unsafe.Pointer(typ)))
- if err != nil {
- return nil, err
- }
-
- totalLength := uintptr(code.Length) + 3
- nextTotalLength := uintptr(ifaceCodeSet.CodeLength) + 3
-
- var c *encoder.Opcode
- if (ctx.Option.Flag & encoder.HTMLEscapeOption) != 0 {
- c = ifaceCodeSet.InterfaceEscapeKeyCode
- } else {
- c = ifaceCodeSet.InterfaceNoescapeKeyCode
- }
- curlen := uintptr(len(ctx.Ptrs))
- offsetNum := ptrOffset / uintptrSize
- oldOffset := ptrOffset
- ptrOffset += totalLength * uintptrSize
- oldBaseIndent := ctx.BaseIndent
- ctx.BaseIndent += code.Indent
-
- newLen := offsetNum + totalLength + nextTotalLength
- if curlen < newLen {
- ctx.Ptrs = append(ctx.Ptrs, make([]uintptr, newLen-curlen)...)
- }
- ctxptr = ctx.Ptr() + ptrOffset // assign new ctxptr
-
- end := ifaceCodeSet.EndCode
- store(ctxptr, c.Idx, uintptr(ifacePtr))
- store(ctxptr, end.Idx, oldOffset)
- store(ctxptr, end.ElemIdx, uintptr(unsafe.Pointer(code.Next)))
- storeIndent(ctxptr, end, uintptr(oldBaseIndent))
- code = c
- recursiveLevel++
- case encoder.OpInterfaceEnd:
- recursiveLevel--
-
- // restore ctxptr
- offset := load(ctxptr, code.Idx)
- restoreIndent(ctx, code, ctxptr)
- ctx.SeenPtr = ctx.SeenPtr[:len(ctx.SeenPtr)-1]
-
- codePtr := load(ctxptr, code.ElemIdx)
- code = (*encoder.Opcode)(ptrToUnsafePtr(codePtr))
- ctxptr = ctx.Ptr() + offset
- ptrOffset = offset
- case encoder.OpMarshalJSONPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- b = appendNullComma(ctx, b)
- code = code.Next
- break
- }
- store(ctxptr, code.Idx, ptrToPtr(p))
- fallthrough
- case encoder.OpMarshalJSON:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- b = appendNullComma(ctx, b)
- code = code.Next
- break
- }
- if (code.Flags&encoder.IsNilableTypeFlags) != 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- p = ptrToPtr(p)
- }
- bb, err := appendMarshalJSON(ctx, code, b, ptrToInterface(code, p))
- if err != nil {
- return nil, err
- }
- b = appendComma(ctx, bb)
- code = code.Next
- case encoder.OpMarshalTextPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- b = appendNullComma(ctx, b)
- code = code.Next
- break
- }
- store(ctxptr, code.Idx, ptrToPtr(p))
- fallthrough
- case encoder.OpMarshalText:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- b = append(b, `""`...)
- b = appendComma(ctx, b)
- code = code.Next
- break
- }
- if (code.Flags&encoder.IsNilableTypeFlags) != 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- p = ptrToPtr(p)
- }
- bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p))
- if err != nil {
- return nil, err
- }
- b = appendComma(ctx, bb)
- code = code.Next
- case encoder.OpSlicePtr:
- p := loadNPtr(ctxptr, code.Idx, code.PtrNum)
- if p == 0 {
- b = appendNullComma(ctx, b)
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, p)
- fallthrough
- case encoder.OpSlice:
- p := load(ctxptr, code.Idx)
- slice := ptrToSlice(p)
- if p == 0 || slice.Data == nil {
- b = appendNullComma(ctx, b)
- code = code.End.Next
- break
- }
- store(ctxptr, code.ElemIdx, 0)
- store(ctxptr, code.Length, uintptr(slice.Len))
- store(ctxptr, code.Idx, uintptr(slice.Data))
- if slice.Len > 0 {
- b = appendArrayHead(ctx, code, b)
- code = code.Next
- store(ctxptr, code.Idx, uintptr(slice.Data))
- } else {
- b = appendEmptyArray(ctx, b)
- code = code.End.Next
- }
- case encoder.OpSliceElem:
- idx := load(ctxptr, code.ElemIdx)
- length := load(ctxptr, code.Length)
- idx++
- if idx < length {
- b = appendArrayElemIndent(ctx, code, b)
- store(ctxptr, code.ElemIdx, idx)
- data := load(ctxptr, code.Idx)
- size := uintptr(code.Size)
- code = code.Next
- store(ctxptr, code.Idx, data+idx*size)
- } else {
- b = appendArrayEnd(ctx, code, b)
- code = code.End.Next
- }
- case encoder.OpArrayPtr:
- p := loadNPtr(ctxptr, code.Idx, code.PtrNum)
- if p == 0 {
- b = appendNullComma(ctx, b)
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, p)
- fallthrough
- case encoder.OpArray:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- b = appendNullComma(ctx, b)
- code = code.End.Next
- break
- }
- if code.Length > 0 {
- b = appendArrayHead(ctx, code, b)
- store(ctxptr, code.ElemIdx, 0)
- code = code.Next
- store(ctxptr, code.Idx, p)
- } else {
- b = appendEmptyArray(ctx, b)
- code = code.End.Next
- }
- case encoder.OpArrayElem:
- idx := load(ctxptr, code.ElemIdx)
- idx++
- if idx < uintptr(code.Length) {
- b = appendArrayElemIndent(ctx, code, b)
- store(ctxptr, code.ElemIdx, idx)
- p := load(ctxptr, code.Idx)
- size := uintptr(code.Size)
- code = code.Next
- store(ctxptr, code.Idx, p+idx*size)
- } else {
- b = appendArrayEnd(ctx, code, b)
- code = code.End.Next
- }
- case encoder.OpMapPtr:
- p := loadNPtr(ctxptr, code.Idx, code.PtrNum)
- if p == 0 {
- b = appendNullComma(ctx, b)
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, p)
- fallthrough
- case encoder.OpMap:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- b = appendNullComma(ctx, b)
- code = code.End.Next
- break
- }
- uptr := ptrToUnsafePtr(p)
- mlen := maplen(uptr)
- if mlen <= 0 {
- b = appendEmptyObject(ctx, b)
- code = code.End.Next
- break
- }
- b = appendStructHead(ctx, b)
- unorderedMap := (ctx.Option.Flag & encoder.UnorderedMapOption) != 0
- mapCtx := encoder.NewMapContext(mlen, unorderedMap)
- mapiterinit(code.Type, uptr, &mapCtx.Iter)
- store(ctxptr, code.Idx, uintptr(unsafe.Pointer(mapCtx)))
- ctx.KeepRefs = append(ctx.KeepRefs, unsafe.Pointer(mapCtx))
- if unorderedMap {
- b = appendMapKeyIndent(ctx, code.Next, b)
- } else {
- mapCtx.Start = len(b)
- mapCtx.First = len(b)
- }
- key := mapiterkey(&mapCtx.Iter)
- store(ctxptr, code.Next.Idx, uintptr(key))
- code = code.Next
- case encoder.OpMapKey:
- mapCtx := (*encoder.MapContext)(ptrToUnsafePtr(load(ctxptr, code.Idx)))
- idx := mapCtx.Idx
- idx++
- if (ctx.Option.Flag & encoder.UnorderedMapOption) != 0 {
- if idx < mapCtx.Len {
- b = appendMapKeyIndent(ctx, code, b)
- mapCtx.Idx = int(idx)
- key := mapiterkey(&mapCtx.Iter)
- store(ctxptr, code.Next.Idx, uintptr(key))
- code = code.Next
- } else {
- b = appendObjectEnd(ctx, code, b)
- encoder.ReleaseMapContext(mapCtx)
- code = code.End.Next
- }
- } else {
- mapCtx.Slice.Items[mapCtx.Idx].Value = b[mapCtx.Start:len(b)]
- if idx < mapCtx.Len {
- mapCtx.Idx = int(idx)
- mapCtx.Start = len(b)
- key := mapiterkey(&mapCtx.Iter)
- store(ctxptr, code.Next.Idx, uintptr(key))
- code = code.Next
- } else {
- code = code.End
- }
- }
- case encoder.OpMapValue:
- mapCtx := (*encoder.MapContext)(ptrToUnsafePtr(load(ctxptr, code.Idx)))
- if (ctx.Option.Flag & encoder.UnorderedMapOption) != 0 {
- b = appendColon(ctx, b)
- } else {
- mapCtx.Slice.Items[mapCtx.Idx].Key = b[mapCtx.Start:len(b)]
- mapCtx.Start = len(b)
- }
- value := mapitervalue(&mapCtx.Iter)
- store(ctxptr, code.Next.Idx, uintptr(value))
- mapiternext(&mapCtx.Iter)
- code = code.Next
- case encoder.OpMapEnd:
- // this operation only used by sorted map.
- mapCtx := (*encoder.MapContext)(ptrToUnsafePtr(load(ctxptr, code.Idx)))
- sort.Sort(mapCtx.Slice)
- buf := mapCtx.Buf
- for _, item := range mapCtx.Slice.Items {
- buf = appendMapKeyValue(ctx, code, buf, item.Key, item.Value)
- }
- buf = appendMapEnd(ctx, code, buf)
- b = b[:mapCtx.First]
- b = append(b, buf...)
- mapCtx.Buf = buf
- encoder.ReleaseMapContext(mapCtx)
- code = code.Next
- case encoder.OpRecursivePtr:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- code = code.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpRecursive:
- ptr := load(ctxptr, code.Idx)
- if ptr != 0 {
- if recursiveLevel > encoder.StartDetectingCyclesAfter {
- for _, seen := range ctx.SeenPtr {
- if ptr == seen {
- return nil, errUnsupportedValue(code, ptr)
- }
- }
- }
- }
- ctx.SeenPtr = append(ctx.SeenPtr, ptr)
- c := code.Jmp.Code
- curlen := uintptr(len(ctx.Ptrs))
- offsetNum := ptrOffset / uintptrSize
- oldOffset := ptrOffset
- ptrOffset += code.Jmp.CurLen * uintptrSize
- oldBaseIndent := ctx.BaseIndent
- indentDiffFromTop := c.Indent - 1
- ctx.BaseIndent += code.Indent - indentDiffFromTop
-
- newLen := offsetNum + code.Jmp.CurLen + code.Jmp.NextLen
- if curlen < newLen {
- ctx.Ptrs = append(ctx.Ptrs, make([]uintptr, newLen-curlen)...)
- }
- ctxptr = ctx.Ptr() + ptrOffset // assign new ctxptr
-
- store(ctxptr, c.Idx, ptr)
- store(ctxptr, c.End.Next.Idx, oldOffset)
- store(ctxptr, c.End.Next.ElemIdx, uintptr(unsafe.Pointer(code.Next)))
- storeIndent(ctxptr, c.End.Next, uintptr(oldBaseIndent))
- code = c
- recursiveLevel++
- case encoder.OpRecursiveEnd:
- recursiveLevel--
-
- // restore ctxptr
- restoreIndent(ctx, code, ctxptr)
- offset := load(ctxptr, code.Idx)
- ctx.SeenPtr = ctx.SeenPtr[:len(ctx.SeenPtr)-1]
-
- codePtr := load(ctxptr, code.ElemIdx)
- code = (*encoder.Opcode)(ptrToUnsafePtr(codePtr))
- ctxptr = ctx.Ptr() + offset
- ptrOffset = offset
- case encoder.OpStructPtrHead:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHead:
- p := load(ctxptr, code.Idx)
- if p == 0 && ((code.Flags&encoder.IndirectFlags) != 0 || code.Next.Op == encoder.OpStructEnd) {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- if len(code.Key) > 0 {
- if (code.Flags&encoder.IsTaggedKeyFlags) != 0 || code.Flags&encoder.AnonymousKeyFlags == 0 {
- b = appendStructKey(ctx, code, b)
- }
- }
- p += uintptr(code.Offset)
- code = code.Next
- store(ctxptr, code.Idx, p)
- case encoder.OpStructPtrHeadOmitEmpty:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadOmitEmpty:
- p := load(ctxptr, code.Idx)
- if p == 0 && ((code.Flags&encoder.IndirectFlags) != 0 || code.Next.Op == encoder.OpStructEnd) {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- p += uintptr(code.Offset)
- if p == 0 || (ptrToPtr(p) == 0 && (code.Flags&encoder.IsNextOpPtrTypeFlags) != 0) {
- code = code.NextField
- } else {
- b = appendStructKey(ctx, code, b)
- code = code.Next
- store(ctxptr, code.Idx, p)
- }
- case encoder.OpStructPtrHeadInt:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadInt:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- b = appendInt(ctx, b, p+uintptr(code.Offset), code)
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyInt:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadOmitEmptyInt:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- u64 := ptrToUint64(p+uintptr(code.Offset), code.NumBitSize)
- v := u64 & ((1 << code.NumBitSize) - 1)
- if v == 0 {
- code = code.NextField
- } else {
- b = appendStructKey(ctx, code, b)
- b = appendInt(ctx, b, p+uintptr(code.Offset), code)
- b = appendComma(ctx, b)
- code = code.Next
- }
- case encoder.OpStructPtrHeadIntString:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadIntString:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendInt(ctx, b, p+uintptr(code.Offset), code)
- b = append(b, '"')
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyIntString:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadOmitEmptyIntString:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- p += uintptr(code.Offset)
- u64 := ptrToUint64(p, code.NumBitSize)
- v := u64 & ((1 << code.NumBitSize) - 1)
- if v == 0 {
- code = code.NextField
- } else {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendInt(ctx, b, p, code)
- b = append(b, '"')
- b = appendComma(ctx, b)
- code = code.Next
- }
- case encoder.OpStructPtrHeadIntPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadIntPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = appendInt(ctx, b, p, code)
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyIntPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadOmitEmptyIntPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = appendInt(ctx, b, p, code)
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructPtrHeadIntPtrString:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadIntPtrString:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = append(b, '"')
- b = appendInt(ctx, b, p, code)
- b = append(b, '"')
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyIntPtrString:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadOmitEmptyIntPtrString:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendInt(ctx, b, p, code)
- b = append(b, '"')
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructPtrHeadUint:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadUint:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- b = appendUint(ctx, b, p+uintptr(code.Offset), code)
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyUint:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadOmitEmptyUint:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- u64 := ptrToUint64(p+uintptr(code.Offset), code.NumBitSize)
- v := u64 & ((1 << code.NumBitSize) - 1)
- if v == 0 {
- code = code.NextField
- } else {
- b = appendStructKey(ctx, code, b)
- b = appendUint(ctx, b, p+uintptr(code.Offset), code)
- b = appendComma(ctx, b)
- code = code.Next
- }
- case encoder.OpStructPtrHeadUintString:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadUintString:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendUint(ctx, b, p+uintptr(code.Offset), code)
- b = append(b, '"')
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyUintString:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadOmitEmptyUintString:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- u64 := ptrToUint64(p+uintptr(code.Offset), code.NumBitSize)
- v := u64 & ((1 << code.NumBitSize) - 1)
- if v == 0 {
- code = code.NextField
- } else {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendUint(ctx, b, p+uintptr(code.Offset), code)
- b = append(b, '"')
- b = appendComma(ctx, b)
- code = code.Next
- }
- case encoder.OpStructPtrHeadUintPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadUintPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = appendUint(ctx, b, p, code)
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyUintPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadOmitEmptyUintPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = appendUint(ctx, b, p, code)
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructPtrHeadUintPtrString:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadUintPtrString:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = append(b, '"')
- b = appendUint(ctx, b, p, code)
- b = append(b, '"')
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyUintPtrString:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadOmitEmptyUintPtrString:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendUint(ctx, b, p, code)
- b = append(b, '"')
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructPtrHeadFloat32:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadFloat32:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- b = appendFloat32(ctx, b, ptrToFloat32(p+uintptr(code.Offset)))
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyFloat32:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadOmitEmptyFloat32:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- v := ptrToFloat32(p + uintptr(code.Offset))
- if v == 0 {
- code = code.NextField
- } else {
- b = appendStructKey(ctx, code, b)
- b = appendFloat32(ctx, b, v)
- b = appendComma(ctx, b)
- code = code.Next
- }
- case encoder.OpStructPtrHeadFloat32String:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadFloat32String:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendFloat32(ctx, b, ptrToFloat32(p+uintptr(code.Offset)))
- b = append(b, '"')
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyFloat32String:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadOmitEmptyFloat32String:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- v := ptrToFloat32(p + uintptr(code.Offset))
- if v == 0 {
- code = code.NextField
- } else {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendFloat32(ctx, b, v)
- b = append(b, '"')
- b = appendComma(ctx, b)
- code = code.Next
- }
- case encoder.OpStructPtrHeadFloat32Ptr:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadFloat32Ptr:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = appendFloat32(ctx, b, ptrToFloat32(p))
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyFloat32Ptr:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadOmitEmptyFloat32Ptr:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = appendFloat32(ctx, b, ptrToFloat32(p))
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructPtrHeadFloat32PtrString:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadFloat32PtrString:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = append(b, '"')
- b = appendFloat32(ctx, b, ptrToFloat32(p))
- b = append(b, '"')
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyFloat32PtrString:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadOmitEmptyFloat32PtrString:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendFloat32(ctx, b, ptrToFloat32(p))
- b = append(b, '"')
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructPtrHeadFloat64:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadFloat64:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- v := ptrToFloat64(p + uintptr(code.Offset))
- if math.IsInf(v, 0) || math.IsNaN(v) {
- return nil, errUnsupportedFloat(v)
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- b = appendFloat64(ctx, b, v)
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyFloat64:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadOmitEmptyFloat64:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- v := ptrToFloat64(p + uintptr(code.Offset))
- if v == 0 {
- code = code.NextField
- } else {
- if math.IsInf(v, 0) || math.IsNaN(v) {
- return nil, errUnsupportedFloat(v)
- }
- b = appendStructKey(ctx, code, b)
- b = appendFloat64(ctx, b, v)
- b = appendComma(ctx, b)
- code = code.Next
- }
- case encoder.OpStructPtrHeadFloat64String:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadFloat64String:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- v := ptrToFloat64(p + uintptr(code.Offset))
- if math.IsInf(v, 0) || math.IsNaN(v) {
- return nil, errUnsupportedFloat(v)
- }
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendFloat64(ctx, b, v)
- b = append(b, '"')
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyFloat64String:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadOmitEmptyFloat64String:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- v := ptrToFloat64(p + uintptr(code.Offset))
- if v == 0 {
- code = code.NextField
- } else {
- if math.IsInf(v, 0) || math.IsNaN(v) {
- return nil, errUnsupportedFloat(v)
- }
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendFloat64(ctx, b, v)
- b = append(b, '"')
- b = appendComma(ctx, b)
- code = code.Next
- }
- case encoder.OpStructPtrHeadFloat64Ptr:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadFloat64Ptr:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- v := ptrToFloat64(p)
- if math.IsInf(v, 0) || math.IsNaN(v) {
- return nil, errUnsupportedFloat(v)
- }
- b = appendFloat64(ctx, b, v)
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyFloat64Ptr:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadOmitEmptyFloat64Ptr:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- v := ptrToFloat64(p)
- if math.IsInf(v, 0) || math.IsNaN(v) {
- return nil, errUnsupportedFloat(v)
- }
- b = appendFloat64(ctx, b, v)
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructPtrHeadFloat64PtrString:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadFloat64PtrString:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = append(b, '"')
- v := ptrToFloat64(p)
- if math.IsInf(v, 0) || math.IsNaN(v) {
- return nil, errUnsupportedFloat(v)
- }
- b = appendFloat64(ctx, b, v)
- b = append(b, '"')
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyFloat64PtrString:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadOmitEmptyFloat64PtrString:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- v := ptrToFloat64(p)
- if math.IsInf(v, 0) || math.IsNaN(v) {
- return nil, errUnsupportedFloat(v)
- }
- b = appendFloat64(ctx, b, v)
- b = append(b, '"')
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructPtrHeadString:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadString:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNull(ctx, b)
- b = appendComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- b = appendString(ctx, b, ptrToString(p+uintptr(code.Offset)))
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyString:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadOmitEmptyString:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- v := ptrToString(p + uintptr(code.Offset))
- if v == "" {
- code = code.NextField
- } else {
- b = appendStructKey(ctx, code, b)
- b = appendString(ctx, b, v)
- b = appendComma(ctx, b)
- code = code.Next
- }
- case encoder.OpStructPtrHeadStringString:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadStringString:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- b = appendString(ctx, b, string(appendString(ctx, []byte{}, ptrToString(p+uintptr(code.Offset)))))
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyStringString:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadOmitEmptyStringString:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- v := ptrToString(p + uintptr(code.Offset))
- if v == "" {
- code = code.NextField
- } else {
- b = appendStructKey(ctx, code, b)
- b = appendString(ctx, b, string(appendString(ctx, []byte{}, v)))
- b = appendComma(ctx, b)
- code = code.Next
- }
- case encoder.OpStructPtrHeadStringPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadStringPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = appendString(ctx, b, ptrToString(p))
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyStringPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadOmitEmptyStringPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = appendString(ctx, b, ptrToString(p))
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructPtrHeadStringPtrString:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadStringPtrString:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = appendString(ctx, b, string(appendString(ctx, []byte{}, ptrToString(p))))
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyStringPtrString:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadOmitEmptyStringPtrString:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = appendString(ctx, b, string(appendString(ctx, []byte{}, ptrToString(p))))
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructPtrHeadBool:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadBool:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- b = appendBool(ctx, b, ptrToBool(p+uintptr(code.Offset)))
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyBool:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadOmitEmptyBool:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- v := ptrToBool(p + uintptr(code.Offset))
- if v {
- b = appendStructKey(ctx, code, b)
- b = appendBool(ctx, b, v)
- b = appendComma(ctx, b)
- code = code.Next
- } else {
- code = code.NextField
- }
- case encoder.OpStructPtrHeadBoolString:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadBoolString:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendBool(ctx, b, ptrToBool(p+uintptr(code.Offset)))
- b = append(b, '"')
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyBoolString:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadOmitEmptyBoolString:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- v := ptrToBool(p + uintptr(code.Offset))
- if v {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendBool(ctx, b, v)
- b = append(b, '"')
- b = appendComma(ctx, b)
- code = code.Next
- } else {
- code = code.NextField
- }
- case encoder.OpStructPtrHeadBoolPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadBoolPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = appendBool(ctx, b, ptrToBool(p))
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyBoolPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadOmitEmptyBoolPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = appendBool(ctx, b, ptrToBool(p))
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructPtrHeadBoolPtrString:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadBoolPtrString:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = append(b, '"')
- b = appendBool(ctx, b, ptrToBool(p))
- b = append(b, '"')
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyBoolPtrString:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadOmitEmptyBoolPtrString:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendBool(ctx, b, ptrToBool(p))
- b = append(b, '"')
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructPtrHeadBytes:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadBytes:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- b = appendByteSlice(ctx, b, ptrToBytes(p+uintptr(code.Offset)))
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyBytes:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadOmitEmptyBytes:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- v := ptrToBytes(p + uintptr(code.Offset))
- if len(v) == 0 {
- code = code.NextField
- } else {
- b = appendStructKey(ctx, code, b)
- b = appendByteSlice(ctx, b, v)
- b = appendComma(ctx, b)
- code = code.Next
- }
- case encoder.OpStructPtrHeadBytesPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadBytesPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = appendByteSlice(ctx, b, ptrToBytes(p))
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyBytesPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadOmitEmptyBytesPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = appendByteSlice(ctx, b, ptrToBytes(p))
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructPtrHeadNumber:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadNumber:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- bb, err := appendNumber(ctx, b, ptrToNumber(p+uintptr(code.Offset)))
- if err != nil {
- return nil, err
- }
- b = appendComma(ctx, bb)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyNumber:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadOmitEmptyNumber:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- v := ptrToNumber(p + uintptr(code.Offset))
- if v == "" {
- code = code.NextField
- } else {
- b = appendStructKey(ctx, code, b)
- bb, err := appendNumber(ctx, b, v)
- if err != nil {
- return nil, err
- }
- b = appendComma(ctx, bb)
- code = code.Next
- }
- case encoder.OpStructPtrHeadNumberString:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadNumberString:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- bb, err := appendNumber(ctx, b, ptrToNumber(p+uintptr(code.Offset)))
- if err != nil {
- return nil, err
- }
- b = append(bb, '"')
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyNumberString:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadOmitEmptyNumberString:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- v := ptrToNumber(p + uintptr(code.Offset))
- if v == "" {
- code = code.NextField
- } else {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- bb, err := appendNumber(ctx, b, v)
- if err != nil {
- return nil, err
- }
- b = append(bb, '"')
- b = appendComma(ctx, b)
- code = code.Next
- }
- case encoder.OpStructPtrHeadNumberPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadNumberPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- bb, err := appendNumber(ctx, b, ptrToNumber(p))
- if err != nil {
- return nil, err
- }
- b = bb
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyNumberPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadOmitEmptyNumberPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- bb, err := appendNumber(ctx, b, ptrToNumber(p))
- if err != nil {
- return nil, err
- }
- b = appendComma(ctx, bb)
- }
- code = code.Next
- case encoder.OpStructPtrHeadNumberPtrString:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadNumberPtrString:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = append(b, '"')
- bb, err := appendNumber(ctx, b, ptrToNumber(p))
- if err != nil {
- return nil, err
- }
- b = append(bb, '"')
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyNumberPtrString:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadOmitEmptyNumberPtrString:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- bb, err := appendNumber(ctx, b, ptrToNumber(p))
- if err != nil {
- return nil, err
- }
- b = append(bb, '"')
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructPtrHeadArray, encoder.OpStructPtrHeadSlice:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadArray, encoder.OpStructHeadSlice:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- p += uintptr(code.Offset)
- code = code.Next
- store(ctxptr, code.Idx, p)
- case encoder.OpStructPtrHeadOmitEmptyArray:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadOmitEmptyArray:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- p += uintptr(code.Offset)
- b = appendStructKey(ctx, code, b)
- code = code.Next
- store(ctxptr, code.Idx, p)
- case encoder.OpStructPtrHeadOmitEmptySlice:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadOmitEmptySlice:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- p += uintptr(code.Offset)
- slice := ptrToSlice(p)
- if slice.Len == 0 {
- code = code.NextField
- } else {
- b = appendStructKey(ctx, code, b)
- code = code.Next
- store(ctxptr, code.Idx, p)
- }
- case encoder.OpStructPtrHeadArrayPtr, encoder.OpStructPtrHeadSlicePtr:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadArrayPtr, encoder.OpStructHeadSlicePtr:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p == 0 {
- b = appendNullComma(ctx, b)
- code = code.NextField
- } else {
- code = code.Next
- store(ctxptr, code.Idx, p)
- }
- case encoder.OpStructPtrHeadOmitEmptyArrayPtr, encoder.OpStructPtrHeadOmitEmptySlicePtr:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadOmitEmptyArrayPtr, encoder.OpStructHeadOmitEmptySlicePtr:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p == 0 {
- code = code.NextField
- } else {
- b = appendStructKey(ctx, code, b)
- code = code.Next
- store(ctxptr, code.Idx, p)
- }
- case encoder.OpStructPtrHeadMap:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadMap:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- if p != 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- p = ptrToPtr(p + uintptr(code.Offset))
- }
- code = code.Next
- store(ctxptr, code.Idx, p)
- case encoder.OpStructPtrHeadOmitEmptyMap:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadOmitEmptyMap:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- if p != 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- p = ptrToPtr(p + uintptr(code.Offset))
- }
- if maplen(ptrToUnsafePtr(p)) == 0 {
- code = code.NextField
- } else {
- b = appendStructKey(ctx, code, b)
- code = code.Next
- store(ctxptr, code.Idx, p)
- }
- case encoder.OpStructPtrHeadMapPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadMapPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- if p == 0 {
- b = appendNullComma(ctx, b)
- code = code.NextField
- break
- }
- p = ptrToPtr(p + uintptr(code.Offset))
- if p == 0 {
- b = appendNullComma(ctx, b)
- code = code.NextField
- } else {
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p, code.PtrNum)
- }
- code = code.Next
- store(ctxptr, code.Idx, p)
- }
- case encoder.OpStructPtrHeadOmitEmptyMapPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadOmitEmptyMapPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- if p == 0 {
- code = code.NextField
- break
- }
- p = ptrToPtr(p + uintptr(code.Offset))
- if p == 0 {
- code = code.NextField
- } else {
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p, code.PtrNum)
- }
- b = appendStructKey(ctx, code, b)
- code = code.Next
- store(ctxptr, code.Idx, p)
- }
- case encoder.OpStructPtrHeadMarshalJSON:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if (code.Flags & encoder.IndirectFlags) != 0 {
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadMarshalJSON:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- p += uintptr(code.Offset)
- if (code.Flags & encoder.IsNilableTypeFlags) != 0 {
- if (code.Flags&encoder.IndirectFlags) != 0 || code.Op == encoder.OpStructPtrHeadMarshalJSON {
- p = ptrToPtr(p)
- }
- }
- if p == 0 && (code.Flags&encoder.NilCheckFlags) != 0 {
- b = appendNull(ctx, b)
- } else {
- bb, err := appendMarshalJSON(ctx, code, b, ptrToInterface(code, p))
- if err != nil {
- return nil, err
- }
- b = bb
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyMarshalJSON:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if (code.Flags & encoder.IndirectFlags) != 0 {
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadOmitEmptyMarshalJSON:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- p += uintptr(code.Offset)
- if (code.Flags & encoder.IsNilableTypeFlags) != 0 {
- if (code.Flags&encoder.IndirectFlags) != 0 || code.Op == encoder.OpStructPtrHeadOmitEmptyMarshalJSON {
- p = ptrToPtr(p)
- }
- }
- iface := ptrToInterface(code, p)
- if (code.Flags&encoder.NilCheckFlags) != 0 && encoder.IsNilForMarshaler(iface) {
- code = code.NextField
- } else {
- b = appendStructKey(ctx, code, b)
- bb, err := appendMarshalJSON(ctx, code, b, iface)
- if err != nil {
- return nil, err
- }
- b = bb
- b = appendComma(ctx, b)
- code = code.Next
- }
- case encoder.OpStructPtrHeadMarshalJSONPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadMarshalJSONPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- bb, err := appendMarshalJSON(ctx, code, b, ptrToInterface(code, p))
- if err != nil {
- return nil, err
- }
- b = bb
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyMarshalJSONPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadOmitEmptyMarshalJSONPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- if p == 0 {
- code = code.NextField
- } else {
- b = appendStructKey(ctx, code, b)
- bb, err := appendMarshalJSON(ctx, code, b, ptrToInterface(code, p))
- if err != nil {
- return nil, err
- }
- b = bb
- b = appendComma(ctx, b)
- code = code.Next
- }
- case encoder.OpStructPtrHeadMarshalText:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if (code.Flags & encoder.IndirectFlags) != 0 {
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadMarshalText:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- p += uintptr(code.Offset)
- if (code.Flags & encoder.IsNilableTypeFlags) != 0 {
- if (code.Flags&encoder.IndirectFlags) != 0 || code.Op == encoder.OpStructPtrHeadMarshalText {
- p = ptrToPtr(p)
- }
- }
- if p == 0 && (code.Flags&encoder.NilCheckFlags) != 0 {
- b = appendNull(ctx, b)
- } else {
- bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p))
- if err != nil {
- return nil, err
- }
- b = bb
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyMarshalText:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if (code.Flags & encoder.IndirectFlags) != 0 {
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadOmitEmptyMarshalText:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- p += uintptr(code.Offset)
- if (code.Flags & encoder.IsNilableTypeFlags) != 0 {
- if (code.Flags&encoder.IndirectFlags) != 0 || code.Op == encoder.OpStructPtrHeadOmitEmptyMarshalText {
- p = ptrToPtr(p)
- }
- }
- if p == 0 && (code.Flags&encoder.NilCheckFlags) != 0 {
- code = code.NextField
- } else {
- b = appendStructKey(ctx, code, b)
- bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p))
- if err != nil {
- return nil, err
- }
- b = bb
- b = appendComma(ctx, b)
- code = code.Next
- }
- case encoder.OpStructPtrHeadMarshalTextPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadMarshalTextPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p))
- if err != nil {
- return nil, err
- }
- b = bb
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyMarshalTextPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadOmitEmptyMarshalTextPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- if p == 0 {
- code = code.NextField
- } else {
- b = appendStructKey(ctx, code, b)
- bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p))
- if err != nil {
- return nil, err
- }
- b = bb
- b = appendComma(ctx, b)
- code = code.Next
- }
- case encoder.OpStructField:
- if code.Flags&encoder.IsTaggedKeyFlags != 0 || code.Flags&encoder.AnonymousKeyFlags == 0 {
- b = appendStructKey(ctx, code, b)
- }
- p := load(ctxptr, code.Idx) + uintptr(code.Offset)
- code = code.Next
- store(ctxptr, code.Idx, p)
- case encoder.OpStructFieldOmitEmpty:
- p := load(ctxptr, code.Idx)
- p += uintptr(code.Offset)
- if ptrToPtr(p) == 0 && (code.Flags&encoder.IsNextOpPtrTypeFlags) != 0 {
- code = code.NextField
- } else {
- b = appendStructKey(ctx, code, b)
- code = code.Next
- store(ctxptr, code.Idx, p)
- }
- case encoder.OpStructFieldInt:
- p := load(ctxptr, code.Idx)
- b = appendStructKey(ctx, code, b)
- b = appendInt(ctx, b, p+uintptr(code.Offset), code)
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyInt:
- p := load(ctxptr, code.Idx)
- u64 := ptrToUint64(p+uintptr(code.Offset), code.NumBitSize)
- v := u64 & ((1 << code.NumBitSize) - 1)
- if v != 0 {
- b = appendStructKey(ctx, code, b)
- b = appendInt(ctx, b, p+uintptr(code.Offset), code)
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructFieldIntString:
- p := load(ctxptr, code.Idx)
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendInt(ctx, b, p+uintptr(code.Offset), code)
- b = append(b, '"')
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyIntString:
- p := load(ctxptr, code.Idx)
- u64 := ptrToUint64(p+uintptr(code.Offset), code.NumBitSize)
- v := u64 & ((1 << code.NumBitSize) - 1)
- if v != 0 {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendInt(ctx, b, p+uintptr(code.Offset), code)
- b = append(b, '"')
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructFieldIntPtr:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- b = appendStructKey(ctx, code, b)
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = appendInt(ctx, b, p, code)
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyIntPtr:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = appendInt(ctx, b, p, code)
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructFieldIntPtrString:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- b = appendStructKey(ctx, code, b)
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = append(b, '"')
- b = appendInt(ctx, b, p, code)
- b = append(b, '"')
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyIntPtrString:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendInt(ctx, b, p, code)
- b = append(b, '"')
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructFieldUint:
- p := load(ctxptr, code.Idx)
- b = appendStructKey(ctx, code, b)
- b = appendUint(ctx, b, p+uintptr(code.Offset), code)
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyUint:
- p := load(ctxptr, code.Idx)
- u64 := ptrToUint64(p+uintptr(code.Offset), code.NumBitSize)
- v := u64 & ((1 << code.NumBitSize) - 1)
- if v != 0 {
- b = appendStructKey(ctx, code, b)
- b = appendUint(ctx, b, p+uintptr(code.Offset), code)
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructFieldUintString:
- p := load(ctxptr, code.Idx)
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendUint(ctx, b, p+uintptr(code.Offset), code)
- b = append(b, '"')
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyUintString:
- p := load(ctxptr, code.Idx)
- u64 := ptrToUint64(p+uintptr(code.Offset), code.NumBitSize)
- v := u64 & ((1 << code.NumBitSize) - 1)
- if v != 0 {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendUint(ctx, b, p+uintptr(code.Offset), code)
- b = append(b, '"')
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructFieldUintPtr:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- b = appendStructKey(ctx, code, b)
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = appendUint(ctx, b, p, code)
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyUintPtr:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = appendUint(ctx, b, p, code)
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructFieldUintPtrString:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- b = appendStructKey(ctx, code, b)
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = append(b, '"')
- b = appendUint(ctx, b, p, code)
- b = append(b, '"')
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyUintPtrString:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendUint(ctx, b, p, code)
- b = append(b, '"')
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructFieldFloat32:
- p := load(ctxptr, code.Idx)
- b = appendStructKey(ctx, code, b)
- b = appendFloat32(ctx, b, ptrToFloat32(p+uintptr(code.Offset)))
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyFloat32:
- p := load(ctxptr, code.Idx)
- v := ptrToFloat32(p + uintptr(code.Offset))
- if v != 0 {
- b = appendStructKey(ctx, code, b)
- b = appendFloat32(ctx, b, v)
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructFieldFloat32String:
- p := load(ctxptr, code.Idx)
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendFloat32(ctx, b, ptrToFloat32(p+uintptr(code.Offset)))
- b = append(b, '"')
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyFloat32String:
- p := load(ctxptr, code.Idx)
- v := ptrToFloat32(p + uintptr(code.Offset))
- if v != 0 {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendFloat32(ctx, b, v)
- b = append(b, '"')
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructFieldFloat32Ptr:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- b = appendStructKey(ctx, code, b)
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = appendFloat32(ctx, b, ptrToFloat32(p))
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyFloat32Ptr:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = appendFloat32(ctx, b, ptrToFloat32(p))
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructFieldFloat32PtrString:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- b = appendStructKey(ctx, code, b)
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = append(b, '"')
- b = appendFloat32(ctx, b, ptrToFloat32(p))
- b = append(b, '"')
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyFloat32PtrString:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendFloat32(ctx, b, ptrToFloat32(p))
- b = append(b, '"')
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructFieldFloat64:
- p := load(ctxptr, code.Idx)
- b = appendStructKey(ctx, code, b)
- v := ptrToFloat64(p + uintptr(code.Offset))
- if math.IsInf(v, 0) || math.IsNaN(v) {
- return nil, errUnsupportedFloat(v)
- }
- b = appendFloat64(ctx, b, v)
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyFloat64:
- p := load(ctxptr, code.Idx)
- v := ptrToFloat64(p + uintptr(code.Offset))
- if v != 0 {
- if math.IsInf(v, 0) || math.IsNaN(v) {
- return nil, errUnsupportedFloat(v)
- }
- b = appendStructKey(ctx, code, b)
- b = appendFloat64(ctx, b, v)
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructFieldFloat64String:
- p := load(ctxptr, code.Idx)
- v := ptrToFloat64(p + uintptr(code.Offset))
- if math.IsInf(v, 0) || math.IsNaN(v) {
- return nil, errUnsupportedFloat(v)
- }
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendFloat64(ctx, b, v)
- b = append(b, '"')
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyFloat64String:
- p := load(ctxptr, code.Idx)
- v := ptrToFloat64(p + uintptr(code.Offset))
- if v != 0 {
- if math.IsInf(v, 0) || math.IsNaN(v) {
- return nil, errUnsupportedFloat(v)
- }
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendFloat64(ctx, b, v)
- b = append(b, '"')
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructFieldFloat64Ptr:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- b = appendStructKey(ctx, code, b)
- if p == 0 {
- b = appendNullComma(ctx, b)
- code = code.Next
- break
- }
- v := ptrToFloat64(p)
- if math.IsInf(v, 0) || math.IsNaN(v) {
- return nil, errUnsupportedFloat(v)
- }
- b = appendFloat64(ctx, b, v)
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyFloat64Ptr:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- v := ptrToFloat64(p)
- if math.IsInf(v, 0) || math.IsNaN(v) {
- return nil, errUnsupportedFloat(v)
- }
- b = appendFloat64(ctx, b, v)
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructFieldFloat64PtrString:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- b = appendStructKey(ctx, code, b)
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- v := ptrToFloat64(p)
- if math.IsInf(v, 0) || math.IsNaN(v) {
- return nil, errUnsupportedFloat(v)
- }
- b = append(b, '"')
- b = appendFloat64(ctx, b, v)
- b = append(b, '"')
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyFloat64PtrString:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- v := ptrToFloat64(p)
- if math.IsInf(v, 0) || math.IsNaN(v) {
- return nil, errUnsupportedFloat(v)
- }
- b = appendFloat64(ctx, b, v)
- b = append(b, '"')
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructFieldString:
- p := load(ctxptr, code.Idx)
- b = appendStructKey(ctx, code, b)
- b = appendString(ctx, b, ptrToString(p+uintptr(code.Offset)))
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyString:
- p := load(ctxptr, code.Idx)
- v := ptrToString(p + uintptr(code.Offset))
- if v != "" {
- b = appendStructKey(ctx, code, b)
- b = appendString(ctx, b, v)
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructFieldStringString:
- p := load(ctxptr, code.Idx)
- s := ptrToString(p + uintptr(code.Offset))
- b = appendStructKey(ctx, code, b)
- b = appendString(ctx, b, string(appendString(ctx, []byte{}, s)))
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyStringString:
- p := load(ctxptr, code.Idx)
- v := ptrToString(p + uintptr(code.Offset))
- if v != "" {
- b = appendStructKey(ctx, code, b)
- b = appendString(ctx, b, string(appendString(ctx, []byte{}, v)))
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructFieldStringPtr:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- b = appendStructKey(ctx, code, b)
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = appendString(ctx, b, ptrToString(p))
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyStringPtr:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = appendString(ctx, b, ptrToString(p))
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructFieldStringPtrString:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- b = appendStructKey(ctx, code, b)
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = appendString(ctx, b, string(appendString(ctx, []byte{}, ptrToString(p))))
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyStringPtrString:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = appendString(ctx, b, string(appendString(ctx, []byte{}, ptrToString(p))))
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructFieldBool:
- p := load(ctxptr, code.Idx)
- b = appendStructKey(ctx, code, b)
- b = appendBool(ctx, b, ptrToBool(p+uintptr(code.Offset)))
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyBool:
- p := load(ctxptr, code.Idx)
- v := ptrToBool(p + uintptr(code.Offset))
- if v {
- b = appendStructKey(ctx, code, b)
- b = appendBool(ctx, b, v)
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructFieldBoolString:
- p := load(ctxptr, code.Idx)
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendBool(ctx, b, ptrToBool(p+uintptr(code.Offset)))
- b = append(b, '"')
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyBoolString:
- p := load(ctxptr, code.Idx)
- v := ptrToBool(p + uintptr(code.Offset))
- if v {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendBool(ctx, b, v)
- b = append(b, '"')
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructFieldBoolPtr:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- b = appendStructKey(ctx, code, b)
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = appendBool(ctx, b, ptrToBool(p))
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyBoolPtr:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = appendBool(ctx, b, ptrToBool(p))
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructFieldBoolPtrString:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- b = appendStructKey(ctx, code, b)
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = append(b, '"')
- b = appendBool(ctx, b, ptrToBool(p))
- b = append(b, '"')
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyBoolPtrString:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendBool(ctx, b, ptrToBool(p))
- b = append(b, '"')
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructFieldBytes:
- p := load(ctxptr, code.Idx)
- b = appendStructKey(ctx, code, b)
- b = appendByteSlice(ctx, b, ptrToBytes(p+uintptr(code.Offset)))
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyBytes:
- p := load(ctxptr, code.Idx)
- v := ptrToBytes(p + uintptr(code.Offset))
- if len(v) > 0 {
- b = appendStructKey(ctx, code, b)
- b = appendByteSlice(ctx, b, v)
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructFieldBytesPtr:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- b = appendStructKey(ctx, code, b)
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = appendByteSlice(ctx, b, ptrToBytes(p))
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyBytesPtr:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = appendByteSlice(ctx, b, ptrToBytes(p))
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructFieldNumber:
- p := load(ctxptr, code.Idx)
- b = appendStructKey(ctx, code, b)
- bb, err := appendNumber(ctx, b, ptrToNumber(p+uintptr(code.Offset)))
- if err != nil {
- return nil, err
- }
- b = appendComma(ctx, bb)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyNumber:
- p := load(ctxptr, code.Idx)
- v := ptrToNumber(p + uintptr(code.Offset))
- if v != "" {
- b = appendStructKey(ctx, code, b)
- bb, err := appendNumber(ctx, b, v)
- if err != nil {
- return nil, err
- }
- b = appendComma(ctx, bb)
- }
- code = code.Next
- case encoder.OpStructFieldNumberString:
- p := load(ctxptr, code.Idx)
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- bb, err := appendNumber(ctx, b, ptrToNumber(p+uintptr(code.Offset)))
- if err != nil {
- return nil, err
- }
- b = append(bb, '"')
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyNumberString:
- p := load(ctxptr, code.Idx)
- v := ptrToNumber(p + uintptr(code.Offset))
- if v != "" {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- bb, err := appendNumber(ctx, b, v)
- if err != nil {
- return nil, err
- }
- b = append(bb, '"')
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructFieldNumberPtr:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- b = appendStructKey(ctx, code, b)
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- bb, err := appendNumber(ctx, b, ptrToNumber(p))
- if err != nil {
- return nil, err
- }
- b = bb
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyNumberPtr:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- bb, err := appendNumber(ctx, b, ptrToNumber(p))
- if err != nil {
- return nil, err
- }
- b = appendComma(ctx, bb)
- }
- code = code.Next
- case encoder.OpStructFieldNumberPtrString:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- b = appendStructKey(ctx, code, b)
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = append(b, '"')
- bb, err := appendNumber(ctx, b, ptrToNumber(p))
- if err != nil {
- return nil, err
- }
- b = append(bb, '"')
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyNumberPtrString:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- bb, err := appendNumber(ctx, b, ptrToNumber(p))
- if err != nil {
- return nil, err
- }
- b = append(bb, '"')
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructFieldMarshalJSON:
- p := load(ctxptr, code.Idx)
- b = appendStructKey(ctx, code, b)
- p += uintptr(code.Offset)
- if (code.Flags & encoder.IsNilableTypeFlags) != 0 {
- p = ptrToPtr(p)
- }
- if p == 0 && (code.Flags&encoder.NilCheckFlags) != 0 {
- b = appendNull(ctx, b)
- } else {
- bb, err := appendMarshalJSON(ctx, code, b, ptrToInterface(code, p))
- if err != nil {
- return nil, err
- }
- b = bb
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyMarshalJSON:
- p := load(ctxptr, code.Idx)
- p += uintptr(code.Offset)
- if (code.Flags & encoder.IsNilableTypeFlags) != 0 {
- p = ptrToPtr(p)
- }
- if p == 0 && (code.Flags&encoder.NilCheckFlags) != 0 {
- code = code.NextField
- break
- }
- iface := ptrToInterface(code, p)
- if (code.Flags&encoder.NilCheckFlags) != 0 && encoder.IsNilForMarshaler(iface) {
- code = code.NextField
- break
- }
- b = appendStructKey(ctx, code, b)
- bb, err := appendMarshalJSON(ctx, code, b, iface)
- if err != nil {
- return nil, err
- }
- b = appendComma(ctx, bb)
- code = code.Next
- case encoder.OpStructFieldMarshalJSONPtr:
- p := load(ctxptr, code.Idx)
- b = appendStructKey(ctx, code, b)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- bb, err := appendMarshalJSON(ctx, code, b, ptrToInterface(code, p))
- if err != nil {
- return nil, err
- }
- b = bb
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyMarshalJSONPtr:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- bb, err := appendMarshalJSON(ctx, code, b, ptrToInterface(code, p))
- if err != nil {
- return nil, err
- }
- b = appendComma(ctx, bb)
- }
- code = code.Next
- case encoder.OpStructFieldMarshalText:
- p := load(ctxptr, code.Idx)
- b = appendStructKey(ctx, code, b)
- p += uintptr(code.Offset)
- if (code.Flags & encoder.IsNilableTypeFlags) != 0 {
- p = ptrToPtr(p)
- }
- if p == 0 && (code.Flags&encoder.NilCheckFlags) != 0 {
- b = appendNull(ctx, b)
- } else {
- bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p))
- if err != nil {
- return nil, err
- }
- b = bb
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyMarshalText:
- p := load(ctxptr, code.Idx)
- p += uintptr(code.Offset)
- if (code.Flags & encoder.IsNilableTypeFlags) != 0 {
- p = ptrToPtr(p)
- }
- if p == 0 && (code.Flags&encoder.NilCheckFlags) != 0 {
- code = code.NextField
- break
- }
- b = appendStructKey(ctx, code, b)
- bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p))
- if err != nil {
- return nil, err
- }
- b = appendComma(ctx, bb)
- code = code.Next
- case encoder.OpStructFieldMarshalTextPtr:
- p := load(ctxptr, code.Idx)
- b = appendStructKey(ctx, code, b)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p))
- if err != nil {
- return nil, err
- }
- b = bb
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyMarshalTextPtr:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p))
- if err != nil {
- return nil, err
- }
- b = appendComma(ctx, bb)
- }
- code = code.Next
- case encoder.OpStructFieldArray:
- b = appendStructKey(ctx, code, b)
- p := load(ctxptr, code.Idx)
- p += uintptr(code.Offset)
- code = code.Next
- store(ctxptr, code.Idx, p)
- case encoder.OpStructFieldOmitEmptyArray:
- b = appendStructKey(ctx, code, b)
- p := load(ctxptr, code.Idx)
- p += uintptr(code.Offset)
- code = code.Next
- store(ctxptr, code.Idx, p)
- case encoder.OpStructFieldArrayPtr:
- b = appendStructKey(ctx, code, b)
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- code = code.Next
- store(ctxptr, code.Idx, p)
- case encoder.OpStructFieldOmitEmptyArrayPtr:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- code = code.Next
- store(ctxptr, code.Idx, p)
- } else {
- code = code.NextField
- }
- case encoder.OpStructFieldSlice:
- b = appendStructKey(ctx, code, b)
- p := load(ctxptr, code.Idx)
- p += uintptr(code.Offset)
- code = code.Next
- store(ctxptr, code.Idx, p)
- case encoder.OpStructFieldOmitEmptySlice:
- p := load(ctxptr, code.Idx)
- p += uintptr(code.Offset)
- slice := ptrToSlice(p)
- if slice.Len == 0 {
- code = code.NextField
- } else {
- b = appendStructKey(ctx, code, b)
- code = code.Next
- store(ctxptr, code.Idx, p)
- }
- case encoder.OpStructFieldSlicePtr:
- b = appendStructKey(ctx, code, b)
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- code = code.Next
- store(ctxptr, code.Idx, p)
- case encoder.OpStructFieldOmitEmptySlicePtr:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- code = code.Next
- store(ctxptr, code.Idx, p)
- } else {
- code = code.NextField
- }
- case encoder.OpStructFieldMap:
- b = appendStructKey(ctx, code, b)
- p := load(ctxptr, code.Idx)
- p = ptrToPtr(p + uintptr(code.Offset))
- code = code.Next
- store(ctxptr, code.Idx, p)
- case encoder.OpStructFieldOmitEmptyMap:
- p := load(ctxptr, code.Idx)
- p = ptrToPtr(p + uintptr(code.Offset))
- if p == 0 || maplen(ptrToUnsafePtr(p)) == 0 {
- code = code.NextField
- } else {
- b = appendStructKey(ctx, code, b)
- code = code.Next
- store(ctxptr, code.Idx, p)
- }
- case encoder.OpStructFieldMapPtr:
- b = appendStructKey(ctx, code, b)
- p := load(ctxptr, code.Idx)
- p = ptrToPtr(p + uintptr(code.Offset))
- if p != 0 {
- p = ptrToNPtr(p, code.PtrNum)
- }
- code = code.Next
- store(ctxptr, code.Idx, p)
- case encoder.OpStructFieldOmitEmptyMapPtr:
- p := load(ctxptr, code.Idx)
- p = ptrToPtr(p + uintptr(code.Offset))
- if p != 0 {
- p = ptrToNPtr(p, code.PtrNum)
- }
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- code = code.Next
- store(ctxptr, code.Idx, p)
- } else {
- code = code.NextField
- }
- case encoder.OpStructFieldStruct:
- b = appendStructKey(ctx, code, b)
- p := load(ctxptr, code.Idx)
- p += uintptr(code.Offset)
- code = code.Next
- store(ctxptr, code.Idx, p)
- case encoder.OpStructFieldOmitEmptyStruct:
- p := load(ctxptr, code.Idx)
- p += uintptr(code.Offset)
- if ptrToPtr(p) == 0 && (code.Flags&encoder.IsNextOpPtrTypeFlags) != 0 {
- code = code.NextField
- } else {
- b = appendStructKey(ctx, code, b)
- code = code.Next
- store(ctxptr, code.Idx, p)
- }
- case encoder.OpStructEnd:
- b = appendStructEndSkipLast(ctx, code, b)
- code = code.Next
- case encoder.OpStructEndInt:
- p := load(ctxptr, code.Idx)
- b = appendStructKey(ctx, code, b)
- b = appendInt(ctx, b, p+uintptr(code.Offset), code)
- b = appendStructEnd(ctx, code, b)
- code = code.Next
- case encoder.OpStructEndOmitEmptyInt:
- p := load(ctxptr, code.Idx)
- u64 := ptrToUint64(p+uintptr(code.Offset), code.NumBitSize)
- v := u64 & ((1 << code.NumBitSize) - 1)
- if v != 0 {
- b = appendStructKey(ctx, code, b)
- b = appendInt(ctx, b, p+uintptr(code.Offset), code)
- b = appendStructEnd(ctx, code, b)
- } else {
- b = appendStructEndSkipLast(ctx, code, b)
- }
- code = code.Next
- case encoder.OpStructEndIntString:
- p := load(ctxptr, code.Idx)
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendInt(ctx, b, p+uintptr(code.Offset), code)
- b = append(b, '"')
- b = appendStructEnd(ctx, code, b)
- code = code.Next
- case encoder.OpStructEndOmitEmptyIntString:
- p := load(ctxptr, code.Idx)
- u64 := ptrToUint64(p+uintptr(code.Offset), code.NumBitSize)
- v := u64 & ((1 << code.NumBitSize) - 1)
- if v != 0 {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendInt(ctx, b, p+uintptr(code.Offset), code)
- b = append(b, '"')
- b = appendStructEnd(ctx, code, b)
- } else {
- b = appendStructEndSkipLast(ctx, code, b)
- }
- code = code.Next
- case encoder.OpStructEndIntPtr:
- b = appendStructKey(ctx, code, b)
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = appendInt(ctx, b, p, code)
- }
- b = appendStructEnd(ctx, code, b)
- code = code.Next
- case encoder.OpStructEndOmitEmptyIntPtr:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = appendInt(ctx, b, p, code)
- b = appendStructEnd(ctx, code, b)
- } else {
- b = appendStructEndSkipLast(ctx, code, b)
- }
- code = code.Next
- case encoder.OpStructEndIntPtrString:
- b = appendStructKey(ctx, code, b)
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = append(b, '"')
- b = appendInt(ctx, b, p, code)
- b = append(b, '"')
- }
- b = appendStructEnd(ctx, code, b)
- code = code.Next
- case encoder.OpStructEndOmitEmptyIntPtrString:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendInt(ctx, b, p, code)
- b = append(b, '"')
- b = appendStructEnd(ctx, code, b)
- } else {
- b = appendStructEndSkipLast(ctx, code, b)
- }
- code = code.Next
- case encoder.OpStructEndUint:
- p := load(ctxptr, code.Idx)
- b = appendStructKey(ctx, code, b)
- b = appendUint(ctx, b, p+uintptr(code.Offset), code)
- b = appendStructEnd(ctx, code, b)
- code = code.Next
- case encoder.OpStructEndOmitEmptyUint:
- p := load(ctxptr, code.Idx)
- u64 := ptrToUint64(p+uintptr(code.Offset), code.NumBitSize)
- v := u64 & ((1 << code.NumBitSize) - 1)
- if v != 0 {
- b = appendStructKey(ctx, code, b)
- b = appendUint(ctx, b, p+uintptr(code.Offset), code)
- b = appendStructEnd(ctx, code, b)
- } else {
- b = appendStructEndSkipLast(ctx, code, b)
- }
- code = code.Next
- case encoder.OpStructEndUintString:
- p := load(ctxptr, code.Idx)
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendUint(ctx, b, p+uintptr(code.Offset), code)
- b = append(b, '"')
- b = appendStructEnd(ctx, code, b)
- code = code.Next
- case encoder.OpStructEndOmitEmptyUintString:
- p := load(ctxptr, code.Idx)
- u64 := ptrToUint64(p+uintptr(code.Offset), code.NumBitSize)
- v := u64 & ((1 << code.NumBitSize) - 1)
- if v != 0 {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendUint(ctx, b, p+uintptr(code.Offset), code)
- b = append(b, '"')
- b = appendStructEnd(ctx, code, b)
- } else {
- b = appendStructEndSkipLast(ctx, code, b)
- }
- code = code.Next
- case encoder.OpStructEndUintPtr:
- b = appendStructKey(ctx, code, b)
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = appendUint(ctx, b, p, code)
- }
- b = appendStructEnd(ctx, code, b)
- code = code.Next
- case encoder.OpStructEndOmitEmptyUintPtr:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = appendUint(ctx, b, p, code)
- b = appendStructEnd(ctx, code, b)
- } else {
- b = appendStructEndSkipLast(ctx, code, b)
- }
- code = code.Next
- case encoder.OpStructEndUintPtrString:
- b = appendStructKey(ctx, code, b)
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = append(b, '"')
- b = appendUint(ctx, b, p, code)
- b = append(b, '"')
- }
- b = appendStructEnd(ctx, code, b)
- code = code.Next
- case encoder.OpStructEndOmitEmptyUintPtrString:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendUint(ctx, b, p, code)
- b = append(b, '"')
- b = appendStructEnd(ctx, code, b)
- } else {
- b = appendStructEndSkipLast(ctx, code, b)
- }
- code = code.Next
- case encoder.OpStructEndFloat32:
- p := load(ctxptr, code.Idx)
- b = appendStructKey(ctx, code, b)
- b = appendFloat32(ctx, b, ptrToFloat32(p+uintptr(code.Offset)))
- b = appendStructEnd(ctx, code, b)
- code = code.Next
- case encoder.OpStructEndOmitEmptyFloat32:
- p := load(ctxptr, code.Idx)
- v := ptrToFloat32(p + uintptr(code.Offset))
- if v != 0 {
- b = appendStructKey(ctx, code, b)
- b = appendFloat32(ctx, b, v)
- b = appendStructEnd(ctx, code, b)
- } else {
- b = appendStructEndSkipLast(ctx, code, b)
- }
- code = code.Next
- case encoder.OpStructEndFloat32String:
- p := load(ctxptr, code.Idx)
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendFloat32(ctx, b, ptrToFloat32(p+uintptr(code.Offset)))
- b = append(b, '"')
- b = appendStructEnd(ctx, code, b)
- code = code.Next
- case encoder.OpStructEndOmitEmptyFloat32String:
- p := load(ctxptr, code.Idx)
- v := ptrToFloat32(p + uintptr(code.Offset))
- if v != 0 {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendFloat32(ctx, b, v)
- b = append(b, '"')
- b = appendStructEnd(ctx, code, b)
- } else {
- b = appendStructEndSkipLast(ctx, code, b)
- }
- code = code.Next
- case encoder.OpStructEndFloat32Ptr:
- b = appendStructKey(ctx, code, b)
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = appendFloat32(ctx, b, ptrToFloat32(p))
- }
- b = appendStructEnd(ctx, code, b)
- code = code.Next
- case encoder.OpStructEndOmitEmptyFloat32Ptr:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = appendFloat32(ctx, b, ptrToFloat32(p))
- b = appendStructEnd(ctx, code, b)
- } else {
- b = appendStructEndSkipLast(ctx, code, b)
- }
- code = code.Next
- case encoder.OpStructEndFloat32PtrString:
- b = appendStructKey(ctx, code, b)
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = append(b, '"')
- b = appendFloat32(ctx, b, ptrToFloat32(p))
- b = append(b, '"')
- }
- b = appendStructEnd(ctx, code, b)
- code = code.Next
- case encoder.OpStructEndOmitEmptyFloat32PtrString:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendFloat32(ctx, b, ptrToFloat32(p))
- b = append(b, '"')
- b = appendStructEnd(ctx, code, b)
- } else {
- b = appendStructEndSkipLast(ctx, code, b)
- }
- code = code.Next
- case encoder.OpStructEndFloat64:
- p := load(ctxptr, code.Idx)
- v := ptrToFloat64(p + uintptr(code.Offset))
- if math.IsInf(v, 0) || math.IsNaN(v) {
- return nil, errUnsupportedFloat(v)
- }
- b = appendStructKey(ctx, code, b)
- b = appendFloat64(ctx, b, v)
- b = appendStructEnd(ctx, code, b)
- code = code.Next
- case encoder.OpStructEndOmitEmptyFloat64:
- p := load(ctxptr, code.Idx)
- v := ptrToFloat64(p + uintptr(code.Offset))
- if v != 0 {
- if math.IsInf(v, 0) || math.IsNaN(v) {
- return nil, errUnsupportedFloat(v)
- }
- b = appendStructKey(ctx, code, b)
- b = appendFloat64(ctx, b, v)
- b = appendStructEnd(ctx, code, b)
- } else {
- b = appendStructEndSkipLast(ctx, code, b)
- }
- code = code.Next
- case encoder.OpStructEndFloat64String:
- p := load(ctxptr, code.Idx)
- v := ptrToFloat64(p + uintptr(code.Offset))
- if math.IsInf(v, 0) || math.IsNaN(v) {
- return nil, errUnsupportedFloat(v)
- }
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendFloat64(ctx, b, v)
- b = append(b, '"')
- b = appendStructEnd(ctx, code, b)
- code = code.Next
- case encoder.OpStructEndOmitEmptyFloat64String:
- p := load(ctxptr, code.Idx)
- v := ptrToFloat64(p + uintptr(code.Offset))
- if v != 0 {
- if math.IsInf(v, 0) || math.IsNaN(v) {
- return nil, errUnsupportedFloat(v)
- }
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendFloat64(ctx, b, v)
- b = append(b, '"')
- b = appendStructEnd(ctx, code, b)
- } else {
- b = appendStructEndSkipLast(ctx, code, b)
- }
- code = code.Next
- case encoder.OpStructEndFloat64Ptr:
- b = appendStructKey(ctx, code, b)
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p == 0 {
- b = appendNull(ctx, b)
- b = appendStructEnd(ctx, code, b)
- code = code.Next
- break
- }
- v := ptrToFloat64(p)
- if math.IsInf(v, 0) || math.IsNaN(v) {
- return nil, errUnsupportedFloat(v)
- }
- b = appendFloat64(ctx, b, v)
- b = appendStructEnd(ctx, code, b)
- code = code.Next
- case encoder.OpStructEndOmitEmptyFloat64Ptr:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- v := ptrToFloat64(p)
- if math.IsInf(v, 0) || math.IsNaN(v) {
- return nil, errUnsupportedFloat(v)
- }
- b = appendFloat64(ctx, b, v)
- b = appendStructEnd(ctx, code, b)
- } else {
- b = appendStructEndSkipLast(ctx, code, b)
- }
- code = code.Next
- case encoder.OpStructEndFloat64PtrString:
- b = appendStructKey(ctx, code, b)
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = append(b, '"')
- v := ptrToFloat64(p)
- if math.IsInf(v, 0) || math.IsNaN(v) {
- return nil, errUnsupportedFloat(v)
- }
- b = appendFloat64(ctx, b, v)
- b = append(b, '"')
- }
- b = appendStructEnd(ctx, code, b)
- code = code.Next
- case encoder.OpStructEndOmitEmptyFloat64PtrString:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- v := ptrToFloat64(p)
- if math.IsInf(v, 0) || math.IsNaN(v) {
- return nil, errUnsupportedFloat(v)
- }
- b = append(b, '"')
- b = appendFloat64(ctx, b, v)
- b = append(b, '"')
- b = appendStructEnd(ctx, code, b)
- } else {
- b = appendStructEndSkipLast(ctx, code, b)
- }
- code = code.Next
- case encoder.OpStructEndString:
- p := load(ctxptr, code.Idx)
- b = appendStructKey(ctx, code, b)
- b = appendString(ctx, b, ptrToString(p+uintptr(code.Offset)))
- b = appendStructEnd(ctx, code, b)
- code = code.Next
- case encoder.OpStructEndOmitEmptyString:
- p := load(ctxptr, code.Idx)
- v := ptrToString(p + uintptr(code.Offset))
- if v != "" {
- b = appendStructKey(ctx, code, b)
- b = appendString(ctx, b, v)
- b = appendStructEnd(ctx, code, b)
- } else {
- b = appendStructEndSkipLast(ctx, code, b)
- }
- code = code.Next
- case encoder.OpStructEndStringString:
- p := load(ctxptr, code.Idx)
- b = appendStructKey(ctx, code, b)
- s := ptrToString(p + uintptr(code.Offset))
- b = appendString(ctx, b, string(appendString(ctx, []byte{}, s)))
- b = appendStructEnd(ctx, code, b)
- code = code.Next
- case encoder.OpStructEndOmitEmptyStringString:
- p := load(ctxptr, code.Idx)
- v := ptrToString(p + uintptr(code.Offset))
- if v != "" {
- b = appendStructKey(ctx, code, b)
- b = appendString(ctx, b, string(appendString(ctx, []byte{}, v)))
- b = appendStructEnd(ctx, code, b)
- } else {
- b = appendStructEndSkipLast(ctx, code, b)
- }
- code = code.Next
- case encoder.OpStructEndStringPtr:
- b = appendStructKey(ctx, code, b)
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = appendString(ctx, b, ptrToString(p))
- }
- b = appendStructEnd(ctx, code, b)
- code = code.Next
- case encoder.OpStructEndOmitEmptyStringPtr:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = appendString(ctx, b, ptrToString(p))
- b = appendStructEnd(ctx, code, b)
- } else {
- b = appendStructEndSkipLast(ctx, code, b)
- }
- code = code.Next
- case encoder.OpStructEndStringPtrString:
- b = appendStructKey(ctx, code, b)
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = appendString(ctx, b, string(appendString(ctx, []byte{}, ptrToString(p))))
- }
- b = appendStructEnd(ctx, code, b)
- code = code.Next
- case encoder.OpStructEndOmitEmptyStringPtrString:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = appendString(ctx, b, string(appendString(ctx, []byte{}, ptrToString(p))))
- b = appendStructEnd(ctx, code, b)
- } else {
- b = appendStructEndSkipLast(ctx, code, b)
- }
- code = code.Next
- case encoder.OpStructEndBool:
- p := load(ctxptr, code.Idx)
- b = appendStructKey(ctx, code, b)
- b = appendBool(ctx, b, ptrToBool(p+uintptr(code.Offset)))
- b = appendStructEnd(ctx, code, b)
- code = code.Next
- case encoder.OpStructEndOmitEmptyBool:
- p := load(ctxptr, code.Idx)
- v := ptrToBool(p + uintptr(code.Offset))
- if v {
- b = appendStructKey(ctx, code, b)
- b = appendBool(ctx, b, v)
- b = appendStructEnd(ctx, code, b)
- } else {
- b = appendStructEndSkipLast(ctx, code, b)
- }
- code = code.Next
- case encoder.OpStructEndBoolString:
- p := load(ctxptr, code.Idx)
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendBool(ctx, b, ptrToBool(p+uintptr(code.Offset)))
- b = append(b, '"')
- b = appendStructEnd(ctx, code, b)
- code = code.Next
- case encoder.OpStructEndOmitEmptyBoolString:
- p := load(ctxptr, code.Idx)
- v := ptrToBool(p + uintptr(code.Offset))
- if v {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendBool(ctx, b, v)
- b = append(b, '"')
- b = appendStructEnd(ctx, code, b)
- } else {
- b = appendStructEndSkipLast(ctx, code, b)
- }
- code = code.Next
- case encoder.OpStructEndBoolPtr:
- b = appendStructKey(ctx, code, b)
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = appendBool(ctx, b, ptrToBool(p))
- }
- b = appendStructEnd(ctx, code, b)
- code = code.Next
- case encoder.OpStructEndOmitEmptyBoolPtr:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = appendBool(ctx, b, ptrToBool(p))
- b = appendStructEnd(ctx, code, b)
- } else {
- b = appendStructEndSkipLast(ctx, code, b)
- }
- code = code.Next
- case encoder.OpStructEndBoolPtrString:
- b = appendStructKey(ctx, code, b)
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = append(b, '"')
- b = appendBool(ctx, b, ptrToBool(p))
- b = append(b, '"')
- }
- b = appendStructEnd(ctx, code, b)
- code = code.Next
- case encoder.OpStructEndOmitEmptyBoolPtrString:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendBool(ctx, b, ptrToBool(p))
- b = append(b, '"')
- b = appendStructEnd(ctx, code, b)
- } else {
- b = appendStructEndSkipLast(ctx, code, b)
- }
- code = code.Next
- case encoder.OpStructEndBytes:
- p := load(ctxptr, code.Idx)
- b = appendStructKey(ctx, code, b)
- b = appendByteSlice(ctx, b, ptrToBytes(p+uintptr(code.Offset)))
- b = appendStructEnd(ctx, code, b)
- code = code.Next
- case encoder.OpStructEndOmitEmptyBytes:
- p := load(ctxptr, code.Idx)
- v := ptrToBytes(p + uintptr(code.Offset))
- if len(v) > 0 {
- b = appendStructKey(ctx, code, b)
- b = appendByteSlice(ctx, b, v)
- b = appendStructEnd(ctx, code, b)
- } else {
- b = appendStructEndSkipLast(ctx, code, b)
- }
- code = code.Next
- case encoder.OpStructEndBytesPtr:
- b = appendStructKey(ctx, code, b)
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = appendByteSlice(ctx, b, ptrToBytes(p))
- }
- b = appendStructEnd(ctx, code, b)
- code = code.Next
- case encoder.OpStructEndOmitEmptyBytesPtr:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = appendByteSlice(ctx, b, ptrToBytes(p))
- b = appendStructEnd(ctx, code, b)
- } else {
- b = appendStructEndSkipLast(ctx, code, b)
- }
- code = code.Next
- case encoder.OpStructEndNumber:
- p := load(ctxptr, code.Idx)
- b = appendStructKey(ctx, code, b)
- bb, err := appendNumber(ctx, b, ptrToNumber(p+uintptr(code.Offset)))
- if err != nil {
- return nil, err
- }
- b = appendStructEnd(ctx, code, bb)
- code = code.Next
- case encoder.OpStructEndOmitEmptyNumber:
- p := load(ctxptr, code.Idx)
- v := ptrToNumber(p + uintptr(code.Offset))
- if v != "" {
- b = appendStructKey(ctx, code, b)
- bb, err := appendNumber(ctx, b, v)
- if err != nil {
- return nil, err
- }
- b = appendStructEnd(ctx, code, bb)
- } else {
- b = appendStructEndSkipLast(ctx, code, b)
- }
- code = code.Next
- case encoder.OpStructEndNumberString:
- p := load(ctxptr, code.Idx)
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- bb, err := appendNumber(ctx, b, ptrToNumber(p+uintptr(code.Offset)))
- if err != nil {
- return nil, err
- }
- b = append(bb, '"')
- b = appendStructEnd(ctx, code, b)
- code = code.Next
- case encoder.OpStructEndOmitEmptyNumberString:
- p := load(ctxptr, code.Idx)
- v := ptrToNumber(p + uintptr(code.Offset))
- if v != "" {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- bb, err := appendNumber(ctx, b, v)
- if err != nil {
- return nil, err
- }
- b = append(bb, '"')
- b = appendStructEnd(ctx, code, b)
- } else {
- b = appendStructEndSkipLast(ctx, code, b)
- }
- code = code.Next
- case encoder.OpStructEndNumberPtr:
- b = appendStructKey(ctx, code, b)
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- bb, err := appendNumber(ctx, b, ptrToNumber(p))
- if err != nil {
- return nil, err
- }
- b = bb
- }
- b = appendStructEnd(ctx, code, b)
- code = code.Next
- case encoder.OpStructEndOmitEmptyNumberPtr:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- bb, err := appendNumber(ctx, b, ptrToNumber(p))
- if err != nil {
- return nil, err
- }
- b = appendStructEnd(ctx, code, bb)
- } else {
- b = appendStructEndSkipLast(ctx, code, b)
- }
- code = code.Next
- case encoder.OpStructEndNumberPtrString:
- b = appendStructKey(ctx, code, b)
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = append(b, '"')
- bb, err := appendNumber(ctx, b, ptrToNumber(p))
- if err != nil {
- return nil, err
- }
- b = append(bb, '"')
- }
- b = appendStructEnd(ctx, code, b)
- code = code.Next
- case encoder.OpStructEndOmitEmptyNumberPtrString:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- bb, err := appendNumber(ctx, b, ptrToNumber(p))
- if err != nil {
- return nil, err
- }
- b = append(bb, '"')
- b = appendStructEnd(ctx, code, b)
- } else {
- b = appendStructEndSkipLast(ctx, code, b)
- }
- code = code.Next
- case encoder.OpEnd:
- goto END
- }
- }
-END:
- return b, nil
-}
diff --git a/vendor/github.com/goccy/go-json/internal/encoder/vm_color/debug_vm.go b/vendor/github.com/goccy/go-json/internal/encoder/vm_color/debug_vm.go
deleted file mode 100644
index 925f61ed..00000000
--- a/vendor/github.com/goccy/go-json/internal/encoder/vm_color/debug_vm.go
+++ /dev/null
@@ -1,35 +0,0 @@
-package vm_color
-
-import (
- "fmt"
-
- "github.com/goccy/go-json/internal/encoder"
-)
-
-func DebugRun(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet) ([]byte, error) {
- var code *encoder.Opcode
- if (ctx.Option.Flag & encoder.HTMLEscapeOption) != 0 {
- code = codeSet.EscapeKeyCode
- } else {
- code = codeSet.NoescapeKeyCode
- }
-
- defer func() {
- if err := recover(); err != nil {
- w := ctx.Option.DebugOut
- fmt.Fprintln(w, "=============[DEBUG]===============")
- fmt.Fprintln(w, "* [TYPE]")
- fmt.Fprintln(w, codeSet.Type)
- fmt.Fprintf(w, "\n")
- fmt.Fprintln(w, "* [ALL OPCODE]")
- fmt.Fprintln(w, code.Dump())
- fmt.Fprintf(w, "\n")
- fmt.Fprintln(w, "* [CONTEXT]")
- fmt.Fprintf(w, "%+v\n", ctx)
- fmt.Fprintln(w, "===================================")
- panic(err)
- }
- }()
-
- return Run(ctx, b, codeSet)
-}
diff --git a/vendor/github.com/goccy/go-json/internal/encoder/vm_color/hack.go b/vendor/github.com/goccy/go-json/internal/encoder/vm_color/hack.go
deleted file mode 100644
index 12ec56c5..00000000
--- a/vendor/github.com/goccy/go-json/internal/encoder/vm_color/hack.go
+++ /dev/null
@@ -1,9 +0,0 @@
-package vm_color
-
-import (
- // HACK: compile order
- // `vm`, `vm_indent`, `vm_color`, `vm_color_indent` packages uses a lot of memory to compile,
- // so forcibly make dependencies and avoid compiling in concurrent.
- // dependency order: vm => vm_indent => vm_color => vm_color_indent
- _ "github.com/goccy/go-json/internal/encoder/vm_color_indent"
-)
diff --git a/vendor/github.com/goccy/go-json/internal/encoder/vm_color/util.go b/vendor/github.com/goccy/go-json/internal/encoder/vm_color/util.go
deleted file mode 100644
index 33f29aee..00000000
--- a/vendor/github.com/goccy/go-json/internal/encoder/vm_color/util.go
+++ /dev/null
@@ -1,274 +0,0 @@
-package vm_color
-
-import (
- "encoding/json"
- "fmt"
- "unsafe"
-
- "github.com/goccy/go-json/internal/encoder"
- "github.com/goccy/go-json/internal/runtime"
-)
-
-const uintptrSize = 4 << (^uintptr(0) >> 63)
-
-var (
- errUnsupportedValue = encoder.ErrUnsupportedValue
- errUnsupportedFloat = encoder.ErrUnsupportedFloat
- mapiterinit = encoder.MapIterInit
- mapiterkey = encoder.MapIterKey
- mapitervalue = encoder.MapIterValue
- mapiternext = encoder.MapIterNext
- maplen = encoder.MapLen
-)
-
-type emptyInterface struct {
- typ *runtime.Type
- ptr unsafe.Pointer
-}
-
-type nonEmptyInterface struct {
- itab *struct {
- ityp *runtime.Type // static interface type
- typ *runtime.Type // dynamic concrete type
- // unused fields...
- }
- ptr unsafe.Pointer
-}
-
-func errUnimplementedOp(op encoder.OpType) error {
- return fmt.Errorf("encoder: opcode %s has not been implemented", op)
-}
-
-func load(base uintptr, idx uint32) uintptr {
- addr := base + uintptr(idx)
- return **(**uintptr)(unsafe.Pointer(&addr))
-}
-
-func store(base uintptr, idx uint32, p uintptr) {
- addr := base + uintptr(idx)
- **(**uintptr)(unsafe.Pointer(&addr)) = p
-}
-
-func loadNPtr(base uintptr, idx uint32, ptrNum uint8) uintptr {
- addr := base + uintptr(idx)
- p := **(**uintptr)(unsafe.Pointer(&addr))
- for i := uint8(0); i < ptrNum; i++ {
- if p == 0 {
- return 0
- }
- p = ptrToPtr(p)
- }
- return p
-}
-
-func ptrToUint64(p uintptr, bitSize uint8) uint64 {
- switch bitSize {
- case 8:
- return (uint64)(**(**uint8)(unsafe.Pointer(&p)))
- case 16:
- return (uint64)(**(**uint16)(unsafe.Pointer(&p)))
- case 32:
- return (uint64)(**(**uint32)(unsafe.Pointer(&p)))
- case 64:
- return **(**uint64)(unsafe.Pointer(&p))
- }
- return 0
-}
-func ptrToFloat32(p uintptr) float32 { return **(**float32)(unsafe.Pointer(&p)) }
-func ptrToFloat64(p uintptr) float64 { return **(**float64)(unsafe.Pointer(&p)) }
-func ptrToBool(p uintptr) bool { return **(**bool)(unsafe.Pointer(&p)) }
-func ptrToBytes(p uintptr) []byte { return **(**[]byte)(unsafe.Pointer(&p)) }
-func ptrToNumber(p uintptr) json.Number { return **(**json.Number)(unsafe.Pointer(&p)) }
-func ptrToString(p uintptr) string { return **(**string)(unsafe.Pointer(&p)) }
-func ptrToSlice(p uintptr) *runtime.SliceHeader { return *(**runtime.SliceHeader)(unsafe.Pointer(&p)) }
-func ptrToPtr(p uintptr) uintptr {
- return uintptr(**(**unsafe.Pointer)(unsafe.Pointer(&p)))
-}
-func ptrToNPtr(p uintptr, ptrNum uint8) uintptr {
- for i := uint8(0); i < ptrNum; i++ {
- if p == 0 {
- return 0
- }
- p = ptrToPtr(p)
- }
- return p
-}
-
-func ptrToUnsafePtr(p uintptr) unsafe.Pointer {
- return *(*unsafe.Pointer)(unsafe.Pointer(&p))
-}
-func ptrToInterface(code *encoder.Opcode, p uintptr) interface{} {
- return *(*interface{})(unsafe.Pointer(&emptyInterface{
- typ: code.Type,
- ptr: *(*unsafe.Pointer)(unsafe.Pointer(&p)),
- }))
-}
-
-func appendInt(ctx *encoder.RuntimeContext, b []byte, p uintptr, code *encoder.Opcode) []byte {
- format := ctx.Option.ColorScheme.Int
- b = append(b, format.Header...)
- b = encoder.AppendInt(ctx, b, p, code)
- return append(b, format.Footer...)
-}
-
-func appendUint(ctx *encoder.RuntimeContext, b []byte, p uintptr, code *encoder.Opcode) []byte {
- format := ctx.Option.ColorScheme.Uint
- b = append(b, format.Header...)
- b = encoder.AppendUint(ctx, b, p, code)
- return append(b, format.Footer...)
-}
-
-func appendFloat32(ctx *encoder.RuntimeContext, b []byte, v float32) []byte {
- format := ctx.Option.ColorScheme.Float
- b = append(b, format.Header...)
- b = encoder.AppendFloat32(ctx, b, v)
- return append(b, format.Footer...)
-}
-
-func appendFloat64(ctx *encoder.RuntimeContext, b []byte, v float64) []byte {
- format := ctx.Option.ColorScheme.Float
- b = append(b, format.Header...)
- b = encoder.AppendFloat64(ctx, b, v)
- return append(b, format.Footer...)
-}
-
-func appendString(ctx *encoder.RuntimeContext, b []byte, v string) []byte {
- format := ctx.Option.ColorScheme.String
- b = append(b, format.Header...)
- b = encoder.AppendString(ctx, b, v)
- return append(b, format.Footer...)
-}
-
-func appendByteSlice(ctx *encoder.RuntimeContext, b []byte, src []byte) []byte {
- format := ctx.Option.ColorScheme.Binary
- b = append(b, format.Header...)
- b = encoder.AppendByteSlice(ctx, b, src)
- return append(b, format.Footer...)
-}
-
-func appendNumber(ctx *encoder.RuntimeContext, b []byte, n json.Number) ([]byte, error) {
- format := ctx.Option.ColorScheme.Int
- b = append(b, format.Header...)
- bb, err := encoder.AppendNumber(ctx, b, n)
- if err != nil {
- return nil, err
- }
- return append(bb, format.Footer...), nil
-}
-
-func appendBool(ctx *encoder.RuntimeContext, b []byte, v bool) []byte {
- format := ctx.Option.ColorScheme.Bool
- b = append(b, format.Header...)
- if v {
- b = append(b, "true"...)
- } else {
- b = append(b, "false"...)
- }
- return append(b, format.Footer...)
-}
-
-func appendNull(ctx *encoder.RuntimeContext, b []byte) []byte {
- format := ctx.Option.ColorScheme.Null
- b = append(b, format.Header...)
- b = append(b, "null"...)
- return append(b, format.Footer...)
-}
-
-func appendComma(_ *encoder.RuntimeContext, b []byte) []byte {
- return append(b, ',')
-}
-
-func appendNullComma(ctx *encoder.RuntimeContext, b []byte) []byte {
- format := ctx.Option.ColorScheme.Null
- b = append(b, format.Header...)
- b = append(b, "null"...)
- return append(append(b, format.Footer...), ',')
-}
-
-func appendColon(_ *encoder.RuntimeContext, b []byte) []byte {
- last := len(b) - 1
- b[last] = ':'
- return b
-}
-
-func appendMapKeyValue(_ *encoder.RuntimeContext, _ *encoder.Opcode, b, key, value []byte) []byte {
- b = append(b, key[:len(key)-1]...)
- b = append(b, ':')
- return append(b, value...)
-}
-
-func appendMapEnd(_ *encoder.RuntimeContext, _ *encoder.Opcode, b []byte) []byte {
- last := len(b) - 1
- b[last] = '}'
- b = append(b, ',')
- return b
-}
-
-func appendMarshalJSON(ctx *encoder.RuntimeContext, code *encoder.Opcode, b []byte, v interface{}) ([]byte, error) {
- return encoder.AppendMarshalJSON(ctx, code, b, v)
-}
-
-func appendMarshalText(ctx *encoder.RuntimeContext, code *encoder.Opcode, b []byte, v interface{}) ([]byte, error) {
- format := ctx.Option.ColorScheme.String
- b = append(b, format.Header...)
- bb, err := encoder.AppendMarshalText(ctx, code, b, v)
- if err != nil {
- return nil, err
- }
- return append(bb, format.Footer...), nil
-}
-
-func appendArrayHead(_ *encoder.RuntimeContext, _ *encoder.Opcode, b []byte) []byte {
- return append(b, '[')
-}
-
-func appendArrayEnd(_ *encoder.RuntimeContext, _ *encoder.Opcode, b []byte) []byte {
- last := len(b) - 1
- b[last] = ']'
- return append(b, ',')
-}
-
-func appendEmptyArray(_ *encoder.RuntimeContext, b []byte) []byte {
- return append(b, '[', ']', ',')
-}
-
-func appendEmptyObject(_ *encoder.RuntimeContext, b []byte) []byte {
- return append(b, '{', '}', ',')
-}
-
-func appendObjectEnd(_ *encoder.RuntimeContext, _ *encoder.Opcode, b []byte) []byte {
- last := len(b) - 1
- b[last] = '}'
- return append(b, ',')
-}
-
-func appendStructHead(_ *encoder.RuntimeContext, b []byte) []byte {
- return append(b, '{')
-}
-
-func appendStructKey(ctx *encoder.RuntimeContext, code *encoder.Opcode, b []byte) []byte {
- format := ctx.Option.ColorScheme.ObjectKey
- b = append(b, format.Header...)
- b = append(b, code.Key[:len(code.Key)-1]...)
- b = append(b, format.Footer...)
-
- return append(b, ':')
-}
-
-func appendStructEnd(_ *encoder.RuntimeContext, _ *encoder.Opcode, b []byte) []byte {
- return append(b, '}', ',')
-}
-
-func appendStructEndSkipLast(ctx *encoder.RuntimeContext, code *encoder.Opcode, b []byte) []byte {
- last := len(b) - 1
- if b[last] == ',' {
- b[last] = '}'
- return appendComma(ctx, b)
- }
- return appendStructEnd(ctx, code, b)
-}
-
-func restoreIndent(_ *encoder.RuntimeContext, _ *encoder.Opcode, _ uintptr) {}
-func storeIndent(_ uintptr, _ *encoder.Opcode, _ uintptr) {}
-func appendMapKeyIndent(_ *encoder.RuntimeContext, _ *encoder.Opcode, b []byte) []byte { return b }
-func appendArrayElemIndent(_ *encoder.RuntimeContext, _ *encoder.Opcode, b []byte) []byte { return b }
diff --git a/vendor/github.com/goccy/go-json/internal/encoder/vm_color/vm.go b/vendor/github.com/goccy/go-json/internal/encoder/vm_color/vm.go
deleted file mode 100644
index a63e83e5..00000000
--- a/vendor/github.com/goccy/go-json/internal/encoder/vm_color/vm.go
+++ /dev/null
@@ -1,4859 +0,0 @@
-// Code generated by internal/cmd/generator. DO NOT EDIT!
-package vm_color
-
-import (
- "math"
- "reflect"
- "sort"
- "unsafe"
-
- "github.com/goccy/go-json/internal/encoder"
- "github.com/goccy/go-json/internal/runtime"
-)
-
-func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet) ([]byte, error) {
- recursiveLevel := 0
- ptrOffset := uintptr(0)
- ctxptr := ctx.Ptr()
- var code *encoder.Opcode
- if (ctx.Option.Flag & encoder.HTMLEscapeOption) != 0 {
- code = codeSet.EscapeKeyCode
- } else {
- code = codeSet.NoescapeKeyCode
- }
-
- for {
- switch code.Op {
- default:
- return nil, errUnimplementedOp(code.Op)
- case encoder.OpPtr:
- p := load(ctxptr, code.Idx)
- code = code.Next
- store(ctxptr, code.Idx, ptrToPtr(p))
- case encoder.OpIntPtr:
- p := loadNPtr(ctxptr, code.Idx, code.PtrNum)
- if p == 0 {
- b = appendNullComma(ctx, b)
- code = code.Next
- break
- }
- store(ctxptr, code.Idx, p)
- fallthrough
- case encoder.OpInt:
- b = appendInt(ctx, b, load(ctxptr, code.Idx), code)
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpUintPtr:
- p := loadNPtr(ctxptr, code.Idx, code.PtrNum)
- if p == 0 {
- b = appendNullComma(ctx, b)
- code = code.Next
- break
- }
- store(ctxptr, code.Idx, p)
- fallthrough
- case encoder.OpUint:
- b = appendUint(ctx, b, load(ctxptr, code.Idx), code)
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpIntString:
- b = append(b, '"')
- b = appendInt(ctx, b, load(ctxptr, code.Idx), code)
- b = append(b, '"')
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpUintString:
- b = append(b, '"')
- b = appendUint(ctx, b, load(ctxptr, code.Idx), code)
- b = append(b, '"')
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpFloat32Ptr:
- p := loadNPtr(ctxptr, code.Idx, code.PtrNum)
- if p == 0 {
- b = appendNull(ctx, b)
- b = appendComma(ctx, b)
- code = code.Next
- break
- }
- store(ctxptr, code.Idx, p)
- fallthrough
- case encoder.OpFloat32:
- b = appendFloat32(ctx, b, ptrToFloat32(load(ctxptr, code.Idx)))
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpFloat64Ptr:
- p := loadNPtr(ctxptr, code.Idx, code.PtrNum)
- if p == 0 {
- b = appendNullComma(ctx, b)
- code = code.Next
- break
- }
- store(ctxptr, code.Idx, p)
- fallthrough
- case encoder.OpFloat64:
- v := ptrToFloat64(load(ctxptr, code.Idx))
- if math.IsInf(v, 0) || math.IsNaN(v) {
- return nil, errUnsupportedFloat(v)
- }
- b = appendFloat64(ctx, b, v)
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStringPtr:
- p := loadNPtr(ctxptr, code.Idx, code.PtrNum)
- if p == 0 {
- b = appendNullComma(ctx, b)
- code = code.Next
- break
- }
- store(ctxptr, code.Idx, p)
- fallthrough
- case encoder.OpString:
- b = appendString(ctx, b, ptrToString(load(ctxptr, code.Idx)))
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpBoolPtr:
- p := loadNPtr(ctxptr, code.Idx, code.PtrNum)
- if p == 0 {
- b = appendNullComma(ctx, b)
- code = code.Next
- break
- }
- store(ctxptr, code.Idx, p)
- fallthrough
- case encoder.OpBool:
- b = appendBool(ctx, b, ptrToBool(load(ctxptr, code.Idx)))
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpBytesPtr:
- p := loadNPtr(ctxptr, code.Idx, code.PtrNum)
- if p == 0 {
- b = appendNullComma(ctx, b)
- code = code.Next
- break
- }
- store(ctxptr, code.Idx, p)
- fallthrough
- case encoder.OpBytes:
- b = appendByteSlice(ctx, b, ptrToBytes(load(ctxptr, code.Idx)))
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpNumberPtr:
- p := loadNPtr(ctxptr, code.Idx, code.PtrNum)
- if p == 0 {
- b = appendNullComma(ctx, b)
- code = code.Next
- break
- }
- store(ctxptr, code.Idx, p)
- fallthrough
- case encoder.OpNumber:
- bb, err := appendNumber(ctx, b, ptrToNumber(load(ctxptr, code.Idx)))
- if err != nil {
- return nil, err
- }
- b = appendComma(ctx, bb)
- code = code.Next
- case encoder.OpInterfacePtr:
- p := loadNPtr(ctxptr, code.Idx, code.PtrNum)
- if p == 0 {
- b = appendNullComma(ctx, b)
- code = code.Next
- break
- }
- store(ctxptr, code.Idx, p)
- fallthrough
- case encoder.OpInterface:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- b = appendNullComma(ctx, b)
- code = code.Next
- break
- }
- if recursiveLevel > encoder.StartDetectingCyclesAfter {
- for _, seen := range ctx.SeenPtr {
- if p == seen {
- return nil, errUnsupportedValue(code, p)
- }
- }
- }
- ctx.SeenPtr = append(ctx.SeenPtr, p)
- var (
- typ *runtime.Type
- ifacePtr unsafe.Pointer
- )
- up := ptrToUnsafePtr(p)
- if code.Flags&encoder.NonEmptyInterfaceFlags != 0 {
- iface := (*nonEmptyInterface)(up)
- ifacePtr = iface.ptr
- if iface.itab != nil {
- typ = iface.itab.typ
- }
- } else {
- iface := (*emptyInterface)(up)
- ifacePtr = iface.ptr
- typ = iface.typ
- }
- if ifacePtr == nil {
- isDirectedNil := typ != nil && typ.Kind() == reflect.Struct && !runtime.IfaceIndir(typ)
- if !isDirectedNil {
- b = appendNullComma(ctx, b)
- code = code.Next
- break
- }
- }
- ctx.KeepRefs = append(ctx.KeepRefs, up)
- ifaceCodeSet, err := encoder.CompileToGetCodeSet(ctx, uintptr(unsafe.Pointer(typ)))
- if err != nil {
- return nil, err
- }
-
- totalLength := uintptr(code.Length) + 3
- nextTotalLength := uintptr(ifaceCodeSet.CodeLength) + 3
-
- var c *encoder.Opcode
- if (ctx.Option.Flag & encoder.HTMLEscapeOption) != 0 {
- c = ifaceCodeSet.InterfaceEscapeKeyCode
- } else {
- c = ifaceCodeSet.InterfaceNoescapeKeyCode
- }
- curlen := uintptr(len(ctx.Ptrs))
- offsetNum := ptrOffset / uintptrSize
- oldOffset := ptrOffset
- ptrOffset += totalLength * uintptrSize
- oldBaseIndent := ctx.BaseIndent
- ctx.BaseIndent += code.Indent
-
- newLen := offsetNum + totalLength + nextTotalLength
- if curlen < newLen {
- ctx.Ptrs = append(ctx.Ptrs, make([]uintptr, newLen-curlen)...)
- }
- ctxptr = ctx.Ptr() + ptrOffset // assign new ctxptr
-
- end := ifaceCodeSet.EndCode
- store(ctxptr, c.Idx, uintptr(ifacePtr))
- store(ctxptr, end.Idx, oldOffset)
- store(ctxptr, end.ElemIdx, uintptr(unsafe.Pointer(code.Next)))
- storeIndent(ctxptr, end, uintptr(oldBaseIndent))
- code = c
- recursiveLevel++
- case encoder.OpInterfaceEnd:
- recursiveLevel--
-
- // restore ctxptr
- offset := load(ctxptr, code.Idx)
- restoreIndent(ctx, code, ctxptr)
- ctx.SeenPtr = ctx.SeenPtr[:len(ctx.SeenPtr)-1]
-
- codePtr := load(ctxptr, code.ElemIdx)
- code = (*encoder.Opcode)(ptrToUnsafePtr(codePtr))
- ctxptr = ctx.Ptr() + offset
- ptrOffset = offset
- case encoder.OpMarshalJSONPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- b = appendNullComma(ctx, b)
- code = code.Next
- break
- }
- store(ctxptr, code.Idx, ptrToPtr(p))
- fallthrough
- case encoder.OpMarshalJSON:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- b = appendNullComma(ctx, b)
- code = code.Next
- break
- }
- if (code.Flags&encoder.IsNilableTypeFlags) != 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- p = ptrToPtr(p)
- }
- bb, err := appendMarshalJSON(ctx, code, b, ptrToInterface(code, p))
- if err != nil {
- return nil, err
- }
- b = appendComma(ctx, bb)
- code = code.Next
- case encoder.OpMarshalTextPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- b = appendNullComma(ctx, b)
- code = code.Next
- break
- }
- store(ctxptr, code.Idx, ptrToPtr(p))
- fallthrough
- case encoder.OpMarshalText:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- b = append(b, `""`...)
- b = appendComma(ctx, b)
- code = code.Next
- break
- }
- if (code.Flags&encoder.IsNilableTypeFlags) != 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- p = ptrToPtr(p)
- }
- bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p))
- if err != nil {
- return nil, err
- }
- b = appendComma(ctx, bb)
- code = code.Next
- case encoder.OpSlicePtr:
- p := loadNPtr(ctxptr, code.Idx, code.PtrNum)
- if p == 0 {
- b = appendNullComma(ctx, b)
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, p)
- fallthrough
- case encoder.OpSlice:
- p := load(ctxptr, code.Idx)
- slice := ptrToSlice(p)
- if p == 0 || slice.Data == nil {
- b = appendNullComma(ctx, b)
- code = code.End.Next
- break
- }
- store(ctxptr, code.ElemIdx, 0)
- store(ctxptr, code.Length, uintptr(slice.Len))
- store(ctxptr, code.Idx, uintptr(slice.Data))
- if slice.Len > 0 {
- b = appendArrayHead(ctx, code, b)
- code = code.Next
- store(ctxptr, code.Idx, uintptr(slice.Data))
- } else {
- b = appendEmptyArray(ctx, b)
- code = code.End.Next
- }
- case encoder.OpSliceElem:
- idx := load(ctxptr, code.ElemIdx)
- length := load(ctxptr, code.Length)
- idx++
- if idx < length {
- b = appendArrayElemIndent(ctx, code, b)
- store(ctxptr, code.ElemIdx, idx)
- data := load(ctxptr, code.Idx)
- size := uintptr(code.Size)
- code = code.Next
- store(ctxptr, code.Idx, data+idx*size)
- } else {
- b = appendArrayEnd(ctx, code, b)
- code = code.End.Next
- }
- case encoder.OpArrayPtr:
- p := loadNPtr(ctxptr, code.Idx, code.PtrNum)
- if p == 0 {
- b = appendNullComma(ctx, b)
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, p)
- fallthrough
- case encoder.OpArray:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- b = appendNullComma(ctx, b)
- code = code.End.Next
- break
- }
- if code.Length > 0 {
- b = appendArrayHead(ctx, code, b)
- store(ctxptr, code.ElemIdx, 0)
- code = code.Next
- store(ctxptr, code.Idx, p)
- } else {
- b = appendEmptyArray(ctx, b)
- code = code.End.Next
- }
- case encoder.OpArrayElem:
- idx := load(ctxptr, code.ElemIdx)
- idx++
- if idx < uintptr(code.Length) {
- b = appendArrayElemIndent(ctx, code, b)
- store(ctxptr, code.ElemIdx, idx)
- p := load(ctxptr, code.Idx)
- size := uintptr(code.Size)
- code = code.Next
- store(ctxptr, code.Idx, p+idx*size)
- } else {
- b = appendArrayEnd(ctx, code, b)
- code = code.End.Next
- }
- case encoder.OpMapPtr:
- p := loadNPtr(ctxptr, code.Idx, code.PtrNum)
- if p == 0 {
- b = appendNullComma(ctx, b)
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, p)
- fallthrough
- case encoder.OpMap:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- b = appendNullComma(ctx, b)
- code = code.End.Next
- break
- }
- uptr := ptrToUnsafePtr(p)
- mlen := maplen(uptr)
- if mlen <= 0 {
- b = appendEmptyObject(ctx, b)
- code = code.End.Next
- break
- }
- b = appendStructHead(ctx, b)
- unorderedMap := (ctx.Option.Flag & encoder.UnorderedMapOption) != 0
- mapCtx := encoder.NewMapContext(mlen, unorderedMap)
- mapiterinit(code.Type, uptr, &mapCtx.Iter)
- store(ctxptr, code.Idx, uintptr(unsafe.Pointer(mapCtx)))
- ctx.KeepRefs = append(ctx.KeepRefs, unsafe.Pointer(mapCtx))
- if unorderedMap {
- b = appendMapKeyIndent(ctx, code.Next, b)
- } else {
- mapCtx.Start = len(b)
- mapCtx.First = len(b)
- }
- key := mapiterkey(&mapCtx.Iter)
- store(ctxptr, code.Next.Idx, uintptr(key))
- code = code.Next
- case encoder.OpMapKey:
- mapCtx := (*encoder.MapContext)(ptrToUnsafePtr(load(ctxptr, code.Idx)))
- idx := mapCtx.Idx
- idx++
- if (ctx.Option.Flag & encoder.UnorderedMapOption) != 0 {
- if idx < mapCtx.Len {
- b = appendMapKeyIndent(ctx, code, b)
- mapCtx.Idx = int(idx)
- key := mapiterkey(&mapCtx.Iter)
- store(ctxptr, code.Next.Idx, uintptr(key))
- code = code.Next
- } else {
- b = appendObjectEnd(ctx, code, b)
- encoder.ReleaseMapContext(mapCtx)
- code = code.End.Next
- }
- } else {
- mapCtx.Slice.Items[mapCtx.Idx].Value = b[mapCtx.Start:len(b)]
- if idx < mapCtx.Len {
- mapCtx.Idx = int(idx)
- mapCtx.Start = len(b)
- key := mapiterkey(&mapCtx.Iter)
- store(ctxptr, code.Next.Idx, uintptr(key))
- code = code.Next
- } else {
- code = code.End
- }
- }
- case encoder.OpMapValue:
- mapCtx := (*encoder.MapContext)(ptrToUnsafePtr(load(ctxptr, code.Idx)))
- if (ctx.Option.Flag & encoder.UnorderedMapOption) != 0 {
- b = appendColon(ctx, b)
- } else {
- mapCtx.Slice.Items[mapCtx.Idx].Key = b[mapCtx.Start:len(b)]
- mapCtx.Start = len(b)
- }
- value := mapitervalue(&mapCtx.Iter)
- store(ctxptr, code.Next.Idx, uintptr(value))
- mapiternext(&mapCtx.Iter)
- code = code.Next
- case encoder.OpMapEnd:
- // this operation only used by sorted map.
- mapCtx := (*encoder.MapContext)(ptrToUnsafePtr(load(ctxptr, code.Idx)))
- sort.Sort(mapCtx.Slice)
- buf := mapCtx.Buf
- for _, item := range mapCtx.Slice.Items {
- buf = appendMapKeyValue(ctx, code, buf, item.Key, item.Value)
- }
- buf = appendMapEnd(ctx, code, buf)
- b = b[:mapCtx.First]
- b = append(b, buf...)
- mapCtx.Buf = buf
- encoder.ReleaseMapContext(mapCtx)
- code = code.Next
- case encoder.OpRecursivePtr:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- code = code.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpRecursive:
- ptr := load(ctxptr, code.Idx)
- if ptr != 0 {
- if recursiveLevel > encoder.StartDetectingCyclesAfter {
- for _, seen := range ctx.SeenPtr {
- if ptr == seen {
- return nil, errUnsupportedValue(code, ptr)
- }
- }
- }
- }
- ctx.SeenPtr = append(ctx.SeenPtr, ptr)
- c := code.Jmp.Code
- curlen := uintptr(len(ctx.Ptrs))
- offsetNum := ptrOffset / uintptrSize
- oldOffset := ptrOffset
- ptrOffset += code.Jmp.CurLen * uintptrSize
- oldBaseIndent := ctx.BaseIndent
- indentDiffFromTop := c.Indent - 1
- ctx.BaseIndent += code.Indent - indentDiffFromTop
-
- newLen := offsetNum + code.Jmp.CurLen + code.Jmp.NextLen
- if curlen < newLen {
- ctx.Ptrs = append(ctx.Ptrs, make([]uintptr, newLen-curlen)...)
- }
- ctxptr = ctx.Ptr() + ptrOffset // assign new ctxptr
-
- store(ctxptr, c.Idx, ptr)
- store(ctxptr, c.End.Next.Idx, oldOffset)
- store(ctxptr, c.End.Next.ElemIdx, uintptr(unsafe.Pointer(code.Next)))
- storeIndent(ctxptr, c.End.Next, uintptr(oldBaseIndent))
- code = c
- recursiveLevel++
- case encoder.OpRecursiveEnd:
- recursiveLevel--
-
- // restore ctxptr
- restoreIndent(ctx, code, ctxptr)
- offset := load(ctxptr, code.Idx)
- ctx.SeenPtr = ctx.SeenPtr[:len(ctx.SeenPtr)-1]
-
- codePtr := load(ctxptr, code.ElemIdx)
- code = (*encoder.Opcode)(ptrToUnsafePtr(codePtr))
- ctxptr = ctx.Ptr() + offset
- ptrOffset = offset
- case encoder.OpStructPtrHead:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHead:
- p := load(ctxptr, code.Idx)
- if p == 0 && ((code.Flags&encoder.IndirectFlags) != 0 || code.Next.Op == encoder.OpStructEnd) {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- if len(code.Key) > 0 {
- if (code.Flags&encoder.IsTaggedKeyFlags) != 0 || code.Flags&encoder.AnonymousKeyFlags == 0 {
- b = appendStructKey(ctx, code, b)
- }
- }
- p += uintptr(code.Offset)
- code = code.Next
- store(ctxptr, code.Idx, p)
- case encoder.OpStructPtrHeadOmitEmpty:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadOmitEmpty:
- p := load(ctxptr, code.Idx)
- if p == 0 && ((code.Flags&encoder.IndirectFlags) != 0 || code.Next.Op == encoder.OpStructEnd) {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- p += uintptr(code.Offset)
- if p == 0 || (ptrToPtr(p) == 0 && (code.Flags&encoder.IsNextOpPtrTypeFlags) != 0) {
- code = code.NextField
- } else {
- b = appendStructKey(ctx, code, b)
- code = code.Next
- store(ctxptr, code.Idx, p)
- }
- case encoder.OpStructPtrHeadInt:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadInt:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- b = appendInt(ctx, b, p+uintptr(code.Offset), code)
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyInt:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadOmitEmptyInt:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- u64 := ptrToUint64(p+uintptr(code.Offset), code.NumBitSize)
- v := u64 & ((1 << code.NumBitSize) - 1)
- if v == 0 {
- code = code.NextField
- } else {
- b = appendStructKey(ctx, code, b)
- b = appendInt(ctx, b, p+uintptr(code.Offset), code)
- b = appendComma(ctx, b)
- code = code.Next
- }
- case encoder.OpStructPtrHeadIntString:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadIntString:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendInt(ctx, b, p+uintptr(code.Offset), code)
- b = append(b, '"')
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyIntString:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadOmitEmptyIntString:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- p += uintptr(code.Offset)
- u64 := ptrToUint64(p, code.NumBitSize)
- v := u64 & ((1 << code.NumBitSize) - 1)
- if v == 0 {
- code = code.NextField
- } else {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendInt(ctx, b, p, code)
- b = append(b, '"')
- b = appendComma(ctx, b)
- code = code.Next
- }
- case encoder.OpStructPtrHeadIntPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadIntPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = appendInt(ctx, b, p, code)
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyIntPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadOmitEmptyIntPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = appendInt(ctx, b, p, code)
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructPtrHeadIntPtrString:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadIntPtrString:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = append(b, '"')
- b = appendInt(ctx, b, p, code)
- b = append(b, '"')
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyIntPtrString:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadOmitEmptyIntPtrString:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendInt(ctx, b, p, code)
- b = append(b, '"')
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructPtrHeadUint:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadUint:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- b = appendUint(ctx, b, p+uintptr(code.Offset), code)
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyUint:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadOmitEmptyUint:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- u64 := ptrToUint64(p+uintptr(code.Offset), code.NumBitSize)
- v := u64 & ((1 << code.NumBitSize) - 1)
- if v == 0 {
- code = code.NextField
- } else {
- b = appendStructKey(ctx, code, b)
- b = appendUint(ctx, b, p+uintptr(code.Offset), code)
- b = appendComma(ctx, b)
- code = code.Next
- }
- case encoder.OpStructPtrHeadUintString:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadUintString:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendUint(ctx, b, p+uintptr(code.Offset), code)
- b = append(b, '"')
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyUintString:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadOmitEmptyUintString:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- u64 := ptrToUint64(p+uintptr(code.Offset), code.NumBitSize)
- v := u64 & ((1 << code.NumBitSize) - 1)
- if v == 0 {
- code = code.NextField
- } else {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendUint(ctx, b, p+uintptr(code.Offset), code)
- b = append(b, '"')
- b = appendComma(ctx, b)
- code = code.Next
- }
- case encoder.OpStructPtrHeadUintPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadUintPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = appendUint(ctx, b, p, code)
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyUintPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadOmitEmptyUintPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = appendUint(ctx, b, p, code)
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructPtrHeadUintPtrString:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadUintPtrString:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = append(b, '"')
- b = appendUint(ctx, b, p, code)
- b = append(b, '"')
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyUintPtrString:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadOmitEmptyUintPtrString:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendUint(ctx, b, p, code)
- b = append(b, '"')
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructPtrHeadFloat32:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadFloat32:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- b = appendFloat32(ctx, b, ptrToFloat32(p+uintptr(code.Offset)))
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyFloat32:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadOmitEmptyFloat32:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- v := ptrToFloat32(p + uintptr(code.Offset))
- if v == 0 {
- code = code.NextField
- } else {
- b = appendStructKey(ctx, code, b)
- b = appendFloat32(ctx, b, v)
- b = appendComma(ctx, b)
- code = code.Next
- }
- case encoder.OpStructPtrHeadFloat32String:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadFloat32String:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendFloat32(ctx, b, ptrToFloat32(p+uintptr(code.Offset)))
- b = append(b, '"')
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyFloat32String:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadOmitEmptyFloat32String:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- v := ptrToFloat32(p + uintptr(code.Offset))
- if v == 0 {
- code = code.NextField
- } else {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendFloat32(ctx, b, v)
- b = append(b, '"')
- b = appendComma(ctx, b)
- code = code.Next
- }
- case encoder.OpStructPtrHeadFloat32Ptr:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadFloat32Ptr:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = appendFloat32(ctx, b, ptrToFloat32(p))
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyFloat32Ptr:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadOmitEmptyFloat32Ptr:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = appendFloat32(ctx, b, ptrToFloat32(p))
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructPtrHeadFloat32PtrString:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadFloat32PtrString:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = append(b, '"')
- b = appendFloat32(ctx, b, ptrToFloat32(p))
- b = append(b, '"')
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyFloat32PtrString:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadOmitEmptyFloat32PtrString:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendFloat32(ctx, b, ptrToFloat32(p))
- b = append(b, '"')
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructPtrHeadFloat64:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadFloat64:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- v := ptrToFloat64(p + uintptr(code.Offset))
- if math.IsInf(v, 0) || math.IsNaN(v) {
- return nil, errUnsupportedFloat(v)
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- b = appendFloat64(ctx, b, v)
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyFloat64:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadOmitEmptyFloat64:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- v := ptrToFloat64(p + uintptr(code.Offset))
- if v == 0 {
- code = code.NextField
- } else {
- if math.IsInf(v, 0) || math.IsNaN(v) {
- return nil, errUnsupportedFloat(v)
- }
- b = appendStructKey(ctx, code, b)
- b = appendFloat64(ctx, b, v)
- b = appendComma(ctx, b)
- code = code.Next
- }
- case encoder.OpStructPtrHeadFloat64String:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadFloat64String:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- v := ptrToFloat64(p + uintptr(code.Offset))
- if math.IsInf(v, 0) || math.IsNaN(v) {
- return nil, errUnsupportedFloat(v)
- }
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendFloat64(ctx, b, v)
- b = append(b, '"')
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyFloat64String:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadOmitEmptyFloat64String:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- v := ptrToFloat64(p + uintptr(code.Offset))
- if v == 0 {
- code = code.NextField
- } else {
- if math.IsInf(v, 0) || math.IsNaN(v) {
- return nil, errUnsupportedFloat(v)
- }
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendFloat64(ctx, b, v)
- b = append(b, '"')
- b = appendComma(ctx, b)
- code = code.Next
- }
- case encoder.OpStructPtrHeadFloat64Ptr:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadFloat64Ptr:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- v := ptrToFloat64(p)
- if math.IsInf(v, 0) || math.IsNaN(v) {
- return nil, errUnsupportedFloat(v)
- }
- b = appendFloat64(ctx, b, v)
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyFloat64Ptr:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadOmitEmptyFloat64Ptr:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- v := ptrToFloat64(p)
- if math.IsInf(v, 0) || math.IsNaN(v) {
- return nil, errUnsupportedFloat(v)
- }
- b = appendFloat64(ctx, b, v)
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructPtrHeadFloat64PtrString:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadFloat64PtrString:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = append(b, '"')
- v := ptrToFloat64(p)
- if math.IsInf(v, 0) || math.IsNaN(v) {
- return nil, errUnsupportedFloat(v)
- }
- b = appendFloat64(ctx, b, v)
- b = append(b, '"')
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyFloat64PtrString:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadOmitEmptyFloat64PtrString:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- v := ptrToFloat64(p)
- if math.IsInf(v, 0) || math.IsNaN(v) {
- return nil, errUnsupportedFloat(v)
- }
- b = appendFloat64(ctx, b, v)
- b = append(b, '"')
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructPtrHeadString:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadString:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNull(ctx, b)
- b = appendComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- b = appendString(ctx, b, ptrToString(p+uintptr(code.Offset)))
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyString:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadOmitEmptyString:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- v := ptrToString(p + uintptr(code.Offset))
- if v == "" {
- code = code.NextField
- } else {
- b = appendStructKey(ctx, code, b)
- b = appendString(ctx, b, v)
- b = appendComma(ctx, b)
- code = code.Next
- }
- case encoder.OpStructPtrHeadStringString:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadStringString:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- b = appendString(ctx, b, string(appendString(ctx, []byte{}, ptrToString(p+uintptr(code.Offset)))))
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyStringString:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadOmitEmptyStringString:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- v := ptrToString(p + uintptr(code.Offset))
- if v == "" {
- code = code.NextField
- } else {
- b = appendStructKey(ctx, code, b)
- b = appendString(ctx, b, string(appendString(ctx, []byte{}, v)))
- b = appendComma(ctx, b)
- code = code.Next
- }
- case encoder.OpStructPtrHeadStringPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadStringPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = appendString(ctx, b, ptrToString(p))
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyStringPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadOmitEmptyStringPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = appendString(ctx, b, ptrToString(p))
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructPtrHeadStringPtrString:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadStringPtrString:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = appendString(ctx, b, string(appendString(ctx, []byte{}, ptrToString(p))))
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyStringPtrString:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadOmitEmptyStringPtrString:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = appendString(ctx, b, string(appendString(ctx, []byte{}, ptrToString(p))))
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructPtrHeadBool:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadBool:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- b = appendBool(ctx, b, ptrToBool(p+uintptr(code.Offset)))
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyBool:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadOmitEmptyBool:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- v := ptrToBool(p + uintptr(code.Offset))
- if v {
- b = appendStructKey(ctx, code, b)
- b = appendBool(ctx, b, v)
- b = appendComma(ctx, b)
- code = code.Next
- } else {
- code = code.NextField
- }
- case encoder.OpStructPtrHeadBoolString:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadBoolString:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendBool(ctx, b, ptrToBool(p+uintptr(code.Offset)))
- b = append(b, '"')
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyBoolString:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadOmitEmptyBoolString:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- v := ptrToBool(p + uintptr(code.Offset))
- if v {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendBool(ctx, b, v)
- b = append(b, '"')
- b = appendComma(ctx, b)
- code = code.Next
- } else {
- code = code.NextField
- }
- case encoder.OpStructPtrHeadBoolPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadBoolPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = appendBool(ctx, b, ptrToBool(p))
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyBoolPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadOmitEmptyBoolPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = appendBool(ctx, b, ptrToBool(p))
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructPtrHeadBoolPtrString:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadBoolPtrString:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = append(b, '"')
- b = appendBool(ctx, b, ptrToBool(p))
- b = append(b, '"')
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyBoolPtrString:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadOmitEmptyBoolPtrString:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendBool(ctx, b, ptrToBool(p))
- b = append(b, '"')
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructPtrHeadBytes:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadBytes:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- b = appendByteSlice(ctx, b, ptrToBytes(p+uintptr(code.Offset)))
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyBytes:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadOmitEmptyBytes:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- v := ptrToBytes(p + uintptr(code.Offset))
- if len(v) == 0 {
- code = code.NextField
- } else {
- b = appendStructKey(ctx, code, b)
- b = appendByteSlice(ctx, b, v)
- b = appendComma(ctx, b)
- code = code.Next
- }
- case encoder.OpStructPtrHeadBytesPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadBytesPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = appendByteSlice(ctx, b, ptrToBytes(p))
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyBytesPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadOmitEmptyBytesPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = appendByteSlice(ctx, b, ptrToBytes(p))
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructPtrHeadNumber:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadNumber:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- bb, err := appendNumber(ctx, b, ptrToNumber(p+uintptr(code.Offset)))
- if err != nil {
- return nil, err
- }
- b = appendComma(ctx, bb)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyNumber:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadOmitEmptyNumber:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- v := ptrToNumber(p + uintptr(code.Offset))
- if v == "" {
- code = code.NextField
- } else {
- b = appendStructKey(ctx, code, b)
- bb, err := appendNumber(ctx, b, v)
- if err != nil {
- return nil, err
- }
- b = appendComma(ctx, bb)
- code = code.Next
- }
- case encoder.OpStructPtrHeadNumberString:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadNumberString:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- bb, err := appendNumber(ctx, b, ptrToNumber(p+uintptr(code.Offset)))
- if err != nil {
- return nil, err
- }
- b = append(bb, '"')
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyNumberString:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadOmitEmptyNumberString:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- v := ptrToNumber(p + uintptr(code.Offset))
- if v == "" {
- code = code.NextField
- } else {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- bb, err := appendNumber(ctx, b, v)
- if err != nil {
- return nil, err
- }
- b = append(bb, '"')
- b = appendComma(ctx, b)
- code = code.Next
- }
- case encoder.OpStructPtrHeadNumberPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadNumberPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- bb, err := appendNumber(ctx, b, ptrToNumber(p))
- if err != nil {
- return nil, err
- }
- b = bb
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyNumberPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadOmitEmptyNumberPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- bb, err := appendNumber(ctx, b, ptrToNumber(p))
- if err != nil {
- return nil, err
- }
- b = appendComma(ctx, bb)
- }
- code = code.Next
- case encoder.OpStructPtrHeadNumberPtrString:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadNumberPtrString:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = append(b, '"')
- bb, err := appendNumber(ctx, b, ptrToNumber(p))
- if err != nil {
- return nil, err
- }
- b = append(bb, '"')
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyNumberPtrString:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadOmitEmptyNumberPtrString:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- bb, err := appendNumber(ctx, b, ptrToNumber(p))
- if err != nil {
- return nil, err
- }
- b = append(bb, '"')
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructPtrHeadArray, encoder.OpStructPtrHeadSlice:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadArray, encoder.OpStructHeadSlice:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- p += uintptr(code.Offset)
- code = code.Next
- store(ctxptr, code.Idx, p)
- case encoder.OpStructPtrHeadOmitEmptyArray:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadOmitEmptyArray:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- p += uintptr(code.Offset)
- b = appendStructKey(ctx, code, b)
- code = code.Next
- store(ctxptr, code.Idx, p)
- case encoder.OpStructPtrHeadOmitEmptySlice:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadOmitEmptySlice:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- p += uintptr(code.Offset)
- slice := ptrToSlice(p)
- if slice.Len == 0 {
- code = code.NextField
- } else {
- b = appendStructKey(ctx, code, b)
- code = code.Next
- store(ctxptr, code.Idx, p)
- }
- case encoder.OpStructPtrHeadArrayPtr, encoder.OpStructPtrHeadSlicePtr:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadArrayPtr, encoder.OpStructHeadSlicePtr:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p == 0 {
- b = appendNullComma(ctx, b)
- code = code.NextField
- } else {
- code = code.Next
- store(ctxptr, code.Idx, p)
- }
- case encoder.OpStructPtrHeadOmitEmptyArrayPtr, encoder.OpStructPtrHeadOmitEmptySlicePtr:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadOmitEmptyArrayPtr, encoder.OpStructHeadOmitEmptySlicePtr:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p == 0 {
- code = code.NextField
- } else {
- b = appendStructKey(ctx, code, b)
- code = code.Next
- store(ctxptr, code.Idx, p)
- }
- case encoder.OpStructPtrHeadMap:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadMap:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- if p != 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- p = ptrToPtr(p + uintptr(code.Offset))
- }
- code = code.Next
- store(ctxptr, code.Idx, p)
- case encoder.OpStructPtrHeadOmitEmptyMap:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadOmitEmptyMap:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- if p != 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- p = ptrToPtr(p + uintptr(code.Offset))
- }
- if maplen(ptrToUnsafePtr(p)) == 0 {
- code = code.NextField
- } else {
- b = appendStructKey(ctx, code, b)
- code = code.Next
- store(ctxptr, code.Idx, p)
- }
- case encoder.OpStructPtrHeadMapPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadMapPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- if p == 0 {
- b = appendNullComma(ctx, b)
- code = code.NextField
- break
- }
- p = ptrToPtr(p + uintptr(code.Offset))
- if p == 0 {
- b = appendNullComma(ctx, b)
- code = code.NextField
- } else {
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p, code.PtrNum)
- }
- code = code.Next
- store(ctxptr, code.Idx, p)
- }
- case encoder.OpStructPtrHeadOmitEmptyMapPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadOmitEmptyMapPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- if p == 0 {
- code = code.NextField
- break
- }
- p = ptrToPtr(p + uintptr(code.Offset))
- if p == 0 {
- code = code.NextField
- } else {
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p, code.PtrNum)
- }
- b = appendStructKey(ctx, code, b)
- code = code.Next
- store(ctxptr, code.Idx, p)
- }
- case encoder.OpStructPtrHeadMarshalJSON:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if (code.Flags & encoder.IndirectFlags) != 0 {
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadMarshalJSON:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- p += uintptr(code.Offset)
- if (code.Flags & encoder.IsNilableTypeFlags) != 0 {
- if (code.Flags&encoder.IndirectFlags) != 0 || code.Op == encoder.OpStructPtrHeadMarshalJSON {
- p = ptrToPtr(p)
- }
- }
- if p == 0 && (code.Flags&encoder.NilCheckFlags) != 0 {
- b = appendNull(ctx, b)
- } else {
- bb, err := appendMarshalJSON(ctx, code, b, ptrToInterface(code, p))
- if err != nil {
- return nil, err
- }
- b = bb
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyMarshalJSON:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if (code.Flags & encoder.IndirectFlags) != 0 {
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadOmitEmptyMarshalJSON:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- p += uintptr(code.Offset)
- if (code.Flags & encoder.IsNilableTypeFlags) != 0 {
- if (code.Flags&encoder.IndirectFlags) != 0 || code.Op == encoder.OpStructPtrHeadOmitEmptyMarshalJSON {
- p = ptrToPtr(p)
- }
- }
- iface := ptrToInterface(code, p)
- if (code.Flags&encoder.NilCheckFlags) != 0 && encoder.IsNilForMarshaler(iface) {
- code = code.NextField
- } else {
- b = appendStructKey(ctx, code, b)
- bb, err := appendMarshalJSON(ctx, code, b, iface)
- if err != nil {
- return nil, err
- }
- b = bb
- b = appendComma(ctx, b)
- code = code.Next
- }
- case encoder.OpStructPtrHeadMarshalJSONPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadMarshalJSONPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- bb, err := appendMarshalJSON(ctx, code, b, ptrToInterface(code, p))
- if err != nil {
- return nil, err
- }
- b = bb
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyMarshalJSONPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadOmitEmptyMarshalJSONPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- if p == 0 {
- code = code.NextField
- } else {
- b = appendStructKey(ctx, code, b)
- bb, err := appendMarshalJSON(ctx, code, b, ptrToInterface(code, p))
- if err != nil {
- return nil, err
- }
- b = bb
- b = appendComma(ctx, b)
- code = code.Next
- }
- case encoder.OpStructPtrHeadMarshalText:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if (code.Flags & encoder.IndirectFlags) != 0 {
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadMarshalText:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- p += uintptr(code.Offset)
- if (code.Flags & encoder.IsNilableTypeFlags) != 0 {
- if (code.Flags&encoder.IndirectFlags) != 0 || code.Op == encoder.OpStructPtrHeadMarshalText {
- p = ptrToPtr(p)
- }
- }
- if p == 0 && (code.Flags&encoder.NilCheckFlags) != 0 {
- b = appendNull(ctx, b)
- } else {
- bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p))
- if err != nil {
- return nil, err
- }
- b = bb
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyMarshalText:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if (code.Flags & encoder.IndirectFlags) != 0 {
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadOmitEmptyMarshalText:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- p += uintptr(code.Offset)
- if (code.Flags & encoder.IsNilableTypeFlags) != 0 {
- if (code.Flags&encoder.IndirectFlags) != 0 || code.Op == encoder.OpStructPtrHeadOmitEmptyMarshalText {
- p = ptrToPtr(p)
- }
- }
- if p == 0 && (code.Flags&encoder.NilCheckFlags) != 0 {
- code = code.NextField
- } else {
- b = appendStructKey(ctx, code, b)
- bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p))
- if err != nil {
- return nil, err
- }
- b = bb
- b = appendComma(ctx, b)
- code = code.Next
- }
- case encoder.OpStructPtrHeadMarshalTextPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadMarshalTextPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p))
- if err != nil {
- return nil, err
- }
- b = bb
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyMarshalTextPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadOmitEmptyMarshalTextPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- if p == 0 {
- code = code.NextField
- } else {
- b = appendStructKey(ctx, code, b)
- bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p))
- if err != nil {
- return nil, err
- }
- b = bb
- b = appendComma(ctx, b)
- code = code.Next
- }
- case encoder.OpStructField:
- if code.Flags&encoder.IsTaggedKeyFlags != 0 || code.Flags&encoder.AnonymousKeyFlags == 0 {
- b = appendStructKey(ctx, code, b)
- }
- p := load(ctxptr, code.Idx) + uintptr(code.Offset)
- code = code.Next
- store(ctxptr, code.Idx, p)
- case encoder.OpStructFieldOmitEmpty:
- p := load(ctxptr, code.Idx)
- p += uintptr(code.Offset)
- if ptrToPtr(p) == 0 && (code.Flags&encoder.IsNextOpPtrTypeFlags) != 0 {
- code = code.NextField
- } else {
- b = appendStructKey(ctx, code, b)
- code = code.Next
- store(ctxptr, code.Idx, p)
- }
- case encoder.OpStructFieldInt:
- p := load(ctxptr, code.Idx)
- b = appendStructKey(ctx, code, b)
- b = appendInt(ctx, b, p+uintptr(code.Offset), code)
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyInt:
- p := load(ctxptr, code.Idx)
- u64 := ptrToUint64(p+uintptr(code.Offset), code.NumBitSize)
- v := u64 & ((1 << code.NumBitSize) - 1)
- if v != 0 {
- b = appendStructKey(ctx, code, b)
- b = appendInt(ctx, b, p+uintptr(code.Offset), code)
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructFieldIntString:
- p := load(ctxptr, code.Idx)
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendInt(ctx, b, p+uintptr(code.Offset), code)
- b = append(b, '"')
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyIntString:
- p := load(ctxptr, code.Idx)
- u64 := ptrToUint64(p+uintptr(code.Offset), code.NumBitSize)
- v := u64 & ((1 << code.NumBitSize) - 1)
- if v != 0 {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendInt(ctx, b, p+uintptr(code.Offset), code)
- b = append(b, '"')
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructFieldIntPtr:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- b = appendStructKey(ctx, code, b)
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = appendInt(ctx, b, p, code)
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyIntPtr:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = appendInt(ctx, b, p, code)
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructFieldIntPtrString:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- b = appendStructKey(ctx, code, b)
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = append(b, '"')
- b = appendInt(ctx, b, p, code)
- b = append(b, '"')
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyIntPtrString:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendInt(ctx, b, p, code)
- b = append(b, '"')
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructFieldUint:
- p := load(ctxptr, code.Idx)
- b = appendStructKey(ctx, code, b)
- b = appendUint(ctx, b, p+uintptr(code.Offset), code)
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyUint:
- p := load(ctxptr, code.Idx)
- u64 := ptrToUint64(p+uintptr(code.Offset), code.NumBitSize)
- v := u64 & ((1 << code.NumBitSize) - 1)
- if v != 0 {
- b = appendStructKey(ctx, code, b)
- b = appendUint(ctx, b, p+uintptr(code.Offset), code)
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructFieldUintString:
- p := load(ctxptr, code.Idx)
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendUint(ctx, b, p+uintptr(code.Offset), code)
- b = append(b, '"')
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyUintString:
- p := load(ctxptr, code.Idx)
- u64 := ptrToUint64(p+uintptr(code.Offset), code.NumBitSize)
- v := u64 & ((1 << code.NumBitSize) - 1)
- if v != 0 {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendUint(ctx, b, p+uintptr(code.Offset), code)
- b = append(b, '"')
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructFieldUintPtr:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- b = appendStructKey(ctx, code, b)
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = appendUint(ctx, b, p, code)
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyUintPtr:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = appendUint(ctx, b, p, code)
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructFieldUintPtrString:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- b = appendStructKey(ctx, code, b)
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = append(b, '"')
- b = appendUint(ctx, b, p, code)
- b = append(b, '"')
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyUintPtrString:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendUint(ctx, b, p, code)
- b = append(b, '"')
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructFieldFloat32:
- p := load(ctxptr, code.Idx)
- b = appendStructKey(ctx, code, b)
- b = appendFloat32(ctx, b, ptrToFloat32(p+uintptr(code.Offset)))
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyFloat32:
- p := load(ctxptr, code.Idx)
- v := ptrToFloat32(p + uintptr(code.Offset))
- if v != 0 {
- b = appendStructKey(ctx, code, b)
- b = appendFloat32(ctx, b, v)
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructFieldFloat32String:
- p := load(ctxptr, code.Idx)
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendFloat32(ctx, b, ptrToFloat32(p+uintptr(code.Offset)))
- b = append(b, '"')
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyFloat32String:
- p := load(ctxptr, code.Idx)
- v := ptrToFloat32(p + uintptr(code.Offset))
- if v != 0 {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendFloat32(ctx, b, v)
- b = append(b, '"')
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructFieldFloat32Ptr:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- b = appendStructKey(ctx, code, b)
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = appendFloat32(ctx, b, ptrToFloat32(p))
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyFloat32Ptr:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = appendFloat32(ctx, b, ptrToFloat32(p))
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructFieldFloat32PtrString:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- b = appendStructKey(ctx, code, b)
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = append(b, '"')
- b = appendFloat32(ctx, b, ptrToFloat32(p))
- b = append(b, '"')
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyFloat32PtrString:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendFloat32(ctx, b, ptrToFloat32(p))
- b = append(b, '"')
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructFieldFloat64:
- p := load(ctxptr, code.Idx)
- b = appendStructKey(ctx, code, b)
- v := ptrToFloat64(p + uintptr(code.Offset))
- if math.IsInf(v, 0) || math.IsNaN(v) {
- return nil, errUnsupportedFloat(v)
- }
- b = appendFloat64(ctx, b, v)
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyFloat64:
- p := load(ctxptr, code.Idx)
- v := ptrToFloat64(p + uintptr(code.Offset))
- if v != 0 {
- if math.IsInf(v, 0) || math.IsNaN(v) {
- return nil, errUnsupportedFloat(v)
- }
- b = appendStructKey(ctx, code, b)
- b = appendFloat64(ctx, b, v)
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructFieldFloat64String:
- p := load(ctxptr, code.Idx)
- v := ptrToFloat64(p + uintptr(code.Offset))
- if math.IsInf(v, 0) || math.IsNaN(v) {
- return nil, errUnsupportedFloat(v)
- }
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendFloat64(ctx, b, v)
- b = append(b, '"')
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyFloat64String:
- p := load(ctxptr, code.Idx)
- v := ptrToFloat64(p + uintptr(code.Offset))
- if v != 0 {
- if math.IsInf(v, 0) || math.IsNaN(v) {
- return nil, errUnsupportedFloat(v)
- }
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendFloat64(ctx, b, v)
- b = append(b, '"')
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructFieldFloat64Ptr:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- b = appendStructKey(ctx, code, b)
- if p == 0 {
- b = appendNullComma(ctx, b)
- code = code.Next
- break
- }
- v := ptrToFloat64(p)
- if math.IsInf(v, 0) || math.IsNaN(v) {
- return nil, errUnsupportedFloat(v)
- }
- b = appendFloat64(ctx, b, v)
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyFloat64Ptr:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- v := ptrToFloat64(p)
- if math.IsInf(v, 0) || math.IsNaN(v) {
- return nil, errUnsupportedFloat(v)
- }
- b = appendFloat64(ctx, b, v)
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructFieldFloat64PtrString:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- b = appendStructKey(ctx, code, b)
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- v := ptrToFloat64(p)
- if math.IsInf(v, 0) || math.IsNaN(v) {
- return nil, errUnsupportedFloat(v)
- }
- b = append(b, '"')
- b = appendFloat64(ctx, b, v)
- b = append(b, '"')
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyFloat64PtrString:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- v := ptrToFloat64(p)
- if math.IsInf(v, 0) || math.IsNaN(v) {
- return nil, errUnsupportedFloat(v)
- }
- b = appendFloat64(ctx, b, v)
- b = append(b, '"')
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructFieldString:
- p := load(ctxptr, code.Idx)
- b = appendStructKey(ctx, code, b)
- b = appendString(ctx, b, ptrToString(p+uintptr(code.Offset)))
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyString:
- p := load(ctxptr, code.Idx)
- v := ptrToString(p + uintptr(code.Offset))
- if v != "" {
- b = appendStructKey(ctx, code, b)
- b = appendString(ctx, b, v)
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructFieldStringString:
- p := load(ctxptr, code.Idx)
- s := ptrToString(p + uintptr(code.Offset))
- b = appendStructKey(ctx, code, b)
- b = appendString(ctx, b, string(appendString(ctx, []byte{}, s)))
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyStringString:
- p := load(ctxptr, code.Idx)
- v := ptrToString(p + uintptr(code.Offset))
- if v != "" {
- b = appendStructKey(ctx, code, b)
- b = appendString(ctx, b, string(appendString(ctx, []byte{}, v)))
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructFieldStringPtr:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- b = appendStructKey(ctx, code, b)
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = appendString(ctx, b, ptrToString(p))
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyStringPtr:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = appendString(ctx, b, ptrToString(p))
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructFieldStringPtrString:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- b = appendStructKey(ctx, code, b)
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = appendString(ctx, b, string(appendString(ctx, []byte{}, ptrToString(p))))
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyStringPtrString:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = appendString(ctx, b, string(appendString(ctx, []byte{}, ptrToString(p))))
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructFieldBool:
- p := load(ctxptr, code.Idx)
- b = appendStructKey(ctx, code, b)
- b = appendBool(ctx, b, ptrToBool(p+uintptr(code.Offset)))
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyBool:
- p := load(ctxptr, code.Idx)
- v := ptrToBool(p + uintptr(code.Offset))
- if v {
- b = appendStructKey(ctx, code, b)
- b = appendBool(ctx, b, v)
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructFieldBoolString:
- p := load(ctxptr, code.Idx)
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendBool(ctx, b, ptrToBool(p+uintptr(code.Offset)))
- b = append(b, '"')
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyBoolString:
- p := load(ctxptr, code.Idx)
- v := ptrToBool(p + uintptr(code.Offset))
- if v {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendBool(ctx, b, v)
- b = append(b, '"')
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructFieldBoolPtr:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- b = appendStructKey(ctx, code, b)
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = appendBool(ctx, b, ptrToBool(p))
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyBoolPtr:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = appendBool(ctx, b, ptrToBool(p))
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructFieldBoolPtrString:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- b = appendStructKey(ctx, code, b)
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = append(b, '"')
- b = appendBool(ctx, b, ptrToBool(p))
- b = append(b, '"')
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyBoolPtrString:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendBool(ctx, b, ptrToBool(p))
- b = append(b, '"')
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructFieldBytes:
- p := load(ctxptr, code.Idx)
- b = appendStructKey(ctx, code, b)
- b = appendByteSlice(ctx, b, ptrToBytes(p+uintptr(code.Offset)))
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyBytes:
- p := load(ctxptr, code.Idx)
- v := ptrToBytes(p + uintptr(code.Offset))
- if len(v) > 0 {
- b = appendStructKey(ctx, code, b)
- b = appendByteSlice(ctx, b, v)
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructFieldBytesPtr:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- b = appendStructKey(ctx, code, b)
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = appendByteSlice(ctx, b, ptrToBytes(p))
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyBytesPtr:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = appendByteSlice(ctx, b, ptrToBytes(p))
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructFieldNumber:
- p := load(ctxptr, code.Idx)
- b = appendStructKey(ctx, code, b)
- bb, err := appendNumber(ctx, b, ptrToNumber(p+uintptr(code.Offset)))
- if err != nil {
- return nil, err
- }
- b = appendComma(ctx, bb)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyNumber:
- p := load(ctxptr, code.Idx)
- v := ptrToNumber(p + uintptr(code.Offset))
- if v != "" {
- b = appendStructKey(ctx, code, b)
- bb, err := appendNumber(ctx, b, v)
- if err != nil {
- return nil, err
- }
- b = appendComma(ctx, bb)
- }
- code = code.Next
- case encoder.OpStructFieldNumberString:
- p := load(ctxptr, code.Idx)
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- bb, err := appendNumber(ctx, b, ptrToNumber(p+uintptr(code.Offset)))
- if err != nil {
- return nil, err
- }
- b = append(bb, '"')
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyNumberString:
- p := load(ctxptr, code.Idx)
- v := ptrToNumber(p + uintptr(code.Offset))
- if v != "" {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- bb, err := appendNumber(ctx, b, v)
- if err != nil {
- return nil, err
- }
- b = append(bb, '"')
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructFieldNumberPtr:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- b = appendStructKey(ctx, code, b)
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- bb, err := appendNumber(ctx, b, ptrToNumber(p))
- if err != nil {
- return nil, err
- }
- b = bb
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyNumberPtr:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- bb, err := appendNumber(ctx, b, ptrToNumber(p))
- if err != nil {
- return nil, err
- }
- b = appendComma(ctx, bb)
- }
- code = code.Next
- case encoder.OpStructFieldNumberPtrString:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- b = appendStructKey(ctx, code, b)
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = append(b, '"')
- bb, err := appendNumber(ctx, b, ptrToNumber(p))
- if err != nil {
- return nil, err
- }
- b = append(bb, '"')
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyNumberPtrString:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- bb, err := appendNumber(ctx, b, ptrToNumber(p))
- if err != nil {
- return nil, err
- }
- b = append(bb, '"')
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructFieldMarshalJSON:
- p := load(ctxptr, code.Idx)
- b = appendStructKey(ctx, code, b)
- p += uintptr(code.Offset)
- if (code.Flags & encoder.IsNilableTypeFlags) != 0 {
- p = ptrToPtr(p)
- }
- if p == 0 && (code.Flags&encoder.NilCheckFlags) != 0 {
- b = appendNull(ctx, b)
- } else {
- bb, err := appendMarshalJSON(ctx, code, b, ptrToInterface(code, p))
- if err != nil {
- return nil, err
- }
- b = bb
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyMarshalJSON:
- p := load(ctxptr, code.Idx)
- p += uintptr(code.Offset)
- if (code.Flags & encoder.IsNilableTypeFlags) != 0 {
- p = ptrToPtr(p)
- }
- if p == 0 && (code.Flags&encoder.NilCheckFlags) != 0 {
- code = code.NextField
- break
- }
- iface := ptrToInterface(code, p)
- if (code.Flags&encoder.NilCheckFlags) != 0 && encoder.IsNilForMarshaler(iface) {
- code = code.NextField
- break
- }
- b = appendStructKey(ctx, code, b)
- bb, err := appendMarshalJSON(ctx, code, b, iface)
- if err != nil {
- return nil, err
- }
- b = appendComma(ctx, bb)
- code = code.Next
- case encoder.OpStructFieldMarshalJSONPtr:
- p := load(ctxptr, code.Idx)
- b = appendStructKey(ctx, code, b)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- bb, err := appendMarshalJSON(ctx, code, b, ptrToInterface(code, p))
- if err != nil {
- return nil, err
- }
- b = bb
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyMarshalJSONPtr:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- bb, err := appendMarshalJSON(ctx, code, b, ptrToInterface(code, p))
- if err != nil {
- return nil, err
- }
- b = appendComma(ctx, bb)
- }
- code = code.Next
- case encoder.OpStructFieldMarshalText:
- p := load(ctxptr, code.Idx)
- b = appendStructKey(ctx, code, b)
- p += uintptr(code.Offset)
- if (code.Flags & encoder.IsNilableTypeFlags) != 0 {
- p = ptrToPtr(p)
- }
- if p == 0 && (code.Flags&encoder.NilCheckFlags) != 0 {
- b = appendNull(ctx, b)
- } else {
- bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p))
- if err != nil {
- return nil, err
- }
- b = bb
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyMarshalText:
- p := load(ctxptr, code.Idx)
- p += uintptr(code.Offset)
- if (code.Flags & encoder.IsNilableTypeFlags) != 0 {
- p = ptrToPtr(p)
- }
- if p == 0 && (code.Flags&encoder.NilCheckFlags) != 0 {
- code = code.NextField
- break
- }
- b = appendStructKey(ctx, code, b)
- bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p))
- if err != nil {
- return nil, err
- }
- b = appendComma(ctx, bb)
- code = code.Next
- case encoder.OpStructFieldMarshalTextPtr:
- p := load(ctxptr, code.Idx)
- b = appendStructKey(ctx, code, b)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p))
- if err != nil {
- return nil, err
- }
- b = bb
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyMarshalTextPtr:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p))
- if err != nil {
- return nil, err
- }
- b = appendComma(ctx, bb)
- }
- code = code.Next
- case encoder.OpStructFieldArray:
- b = appendStructKey(ctx, code, b)
- p := load(ctxptr, code.Idx)
- p += uintptr(code.Offset)
- code = code.Next
- store(ctxptr, code.Idx, p)
- case encoder.OpStructFieldOmitEmptyArray:
- b = appendStructKey(ctx, code, b)
- p := load(ctxptr, code.Idx)
- p += uintptr(code.Offset)
- code = code.Next
- store(ctxptr, code.Idx, p)
- case encoder.OpStructFieldArrayPtr:
- b = appendStructKey(ctx, code, b)
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- code = code.Next
- store(ctxptr, code.Idx, p)
- case encoder.OpStructFieldOmitEmptyArrayPtr:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- code = code.Next
- store(ctxptr, code.Idx, p)
- } else {
- code = code.NextField
- }
- case encoder.OpStructFieldSlice:
- b = appendStructKey(ctx, code, b)
- p := load(ctxptr, code.Idx)
- p += uintptr(code.Offset)
- code = code.Next
- store(ctxptr, code.Idx, p)
- case encoder.OpStructFieldOmitEmptySlice:
- p := load(ctxptr, code.Idx)
- p += uintptr(code.Offset)
- slice := ptrToSlice(p)
- if slice.Len == 0 {
- code = code.NextField
- } else {
- b = appendStructKey(ctx, code, b)
- code = code.Next
- store(ctxptr, code.Idx, p)
- }
- case encoder.OpStructFieldSlicePtr:
- b = appendStructKey(ctx, code, b)
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- code = code.Next
- store(ctxptr, code.Idx, p)
- case encoder.OpStructFieldOmitEmptySlicePtr:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- code = code.Next
- store(ctxptr, code.Idx, p)
- } else {
- code = code.NextField
- }
- case encoder.OpStructFieldMap:
- b = appendStructKey(ctx, code, b)
- p := load(ctxptr, code.Idx)
- p = ptrToPtr(p + uintptr(code.Offset))
- code = code.Next
- store(ctxptr, code.Idx, p)
- case encoder.OpStructFieldOmitEmptyMap:
- p := load(ctxptr, code.Idx)
- p = ptrToPtr(p + uintptr(code.Offset))
- if p == 0 || maplen(ptrToUnsafePtr(p)) == 0 {
- code = code.NextField
- } else {
- b = appendStructKey(ctx, code, b)
- code = code.Next
- store(ctxptr, code.Idx, p)
- }
- case encoder.OpStructFieldMapPtr:
- b = appendStructKey(ctx, code, b)
- p := load(ctxptr, code.Idx)
- p = ptrToPtr(p + uintptr(code.Offset))
- if p != 0 {
- p = ptrToNPtr(p, code.PtrNum)
- }
- code = code.Next
- store(ctxptr, code.Idx, p)
- case encoder.OpStructFieldOmitEmptyMapPtr:
- p := load(ctxptr, code.Idx)
- p = ptrToPtr(p + uintptr(code.Offset))
- if p != 0 {
- p = ptrToNPtr(p, code.PtrNum)
- }
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- code = code.Next
- store(ctxptr, code.Idx, p)
- } else {
- code = code.NextField
- }
- case encoder.OpStructFieldStruct:
- b = appendStructKey(ctx, code, b)
- p := load(ctxptr, code.Idx)
- p += uintptr(code.Offset)
- code = code.Next
- store(ctxptr, code.Idx, p)
- case encoder.OpStructFieldOmitEmptyStruct:
- p := load(ctxptr, code.Idx)
- p += uintptr(code.Offset)
- if ptrToPtr(p) == 0 && (code.Flags&encoder.IsNextOpPtrTypeFlags) != 0 {
- code = code.NextField
- } else {
- b = appendStructKey(ctx, code, b)
- code = code.Next
- store(ctxptr, code.Idx, p)
- }
- case encoder.OpStructEnd:
- b = appendStructEndSkipLast(ctx, code, b)
- code = code.Next
- case encoder.OpStructEndInt:
- p := load(ctxptr, code.Idx)
- b = appendStructKey(ctx, code, b)
- b = appendInt(ctx, b, p+uintptr(code.Offset), code)
- b = appendStructEnd(ctx, code, b)
- code = code.Next
- case encoder.OpStructEndOmitEmptyInt:
- p := load(ctxptr, code.Idx)
- u64 := ptrToUint64(p+uintptr(code.Offset), code.NumBitSize)
- v := u64 & ((1 << code.NumBitSize) - 1)
- if v != 0 {
- b = appendStructKey(ctx, code, b)
- b = appendInt(ctx, b, p+uintptr(code.Offset), code)
- b = appendStructEnd(ctx, code, b)
- } else {
- b = appendStructEndSkipLast(ctx, code, b)
- }
- code = code.Next
- case encoder.OpStructEndIntString:
- p := load(ctxptr, code.Idx)
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendInt(ctx, b, p+uintptr(code.Offset), code)
- b = append(b, '"')
- b = appendStructEnd(ctx, code, b)
- code = code.Next
- case encoder.OpStructEndOmitEmptyIntString:
- p := load(ctxptr, code.Idx)
- u64 := ptrToUint64(p+uintptr(code.Offset), code.NumBitSize)
- v := u64 & ((1 << code.NumBitSize) - 1)
- if v != 0 {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendInt(ctx, b, p+uintptr(code.Offset), code)
- b = append(b, '"')
- b = appendStructEnd(ctx, code, b)
- } else {
- b = appendStructEndSkipLast(ctx, code, b)
- }
- code = code.Next
- case encoder.OpStructEndIntPtr:
- b = appendStructKey(ctx, code, b)
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = appendInt(ctx, b, p, code)
- }
- b = appendStructEnd(ctx, code, b)
- code = code.Next
- case encoder.OpStructEndOmitEmptyIntPtr:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = appendInt(ctx, b, p, code)
- b = appendStructEnd(ctx, code, b)
- } else {
- b = appendStructEndSkipLast(ctx, code, b)
- }
- code = code.Next
- case encoder.OpStructEndIntPtrString:
- b = appendStructKey(ctx, code, b)
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = append(b, '"')
- b = appendInt(ctx, b, p, code)
- b = append(b, '"')
- }
- b = appendStructEnd(ctx, code, b)
- code = code.Next
- case encoder.OpStructEndOmitEmptyIntPtrString:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendInt(ctx, b, p, code)
- b = append(b, '"')
- b = appendStructEnd(ctx, code, b)
- } else {
- b = appendStructEndSkipLast(ctx, code, b)
- }
- code = code.Next
- case encoder.OpStructEndUint:
- p := load(ctxptr, code.Idx)
- b = appendStructKey(ctx, code, b)
- b = appendUint(ctx, b, p+uintptr(code.Offset), code)
- b = appendStructEnd(ctx, code, b)
- code = code.Next
- case encoder.OpStructEndOmitEmptyUint:
- p := load(ctxptr, code.Idx)
- u64 := ptrToUint64(p+uintptr(code.Offset), code.NumBitSize)
- v := u64 & ((1 << code.NumBitSize) - 1)
- if v != 0 {
- b = appendStructKey(ctx, code, b)
- b = appendUint(ctx, b, p+uintptr(code.Offset), code)
- b = appendStructEnd(ctx, code, b)
- } else {
- b = appendStructEndSkipLast(ctx, code, b)
- }
- code = code.Next
- case encoder.OpStructEndUintString:
- p := load(ctxptr, code.Idx)
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendUint(ctx, b, p+uintptr(code.Offset), code)
- b = append(b, '"')
- b = appendStructEnd(ctx, code, b)
- code = code.Next
- case encoder.OpStructEndOmitEmptyUintString:
- p := load(ctxptr, code.Idx)
- u64 := ptrToUint64(p+uintptr(code.Offset), code.NumBitSize)
- v := u64 & ((1 << code.NumBitSize) - 1)
- if v != 0 {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendUint(ctx, b, p+uintptr(code.Offset), code)
- b = append(b, '"')
- b = appendStructEnd(ctx, code, b)
- } else {
- b = appendStructEndSkipLast(ctx, code, b)
- }
- code = code.Next
- case encoder.OpStructEndUintPtr:
- b = appendStructKey(ctx, code, b)
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = appendUint(ctx, b, p, code)
- }
- b = appendStructEnd(ctx, code, b)
- code = code.Next
- case encoder.OpStructEndOmitEmptyUintPtr:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = appendUint(ctx, b, p, code)
- b = appendStructEnd(ctx, code, b)
- } else {
- b = appendStructEndSkipLast(ctx, code, b)
- }
- code = code.Next
- case encoder.OpStructEndUintPtrString:
- b = appendStructKey(ctx, code, b)
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = append(b, '"')
- b = appendUint(ctx, b, p, code)
- b = append(b, '"')
- }
- b = appendStructEnd(ctx, code, b)
- code = code.Next
- case encoder.OpStructEndOmitEmptyUintPtrString:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendUint(ctx, b, p, code)
- b = append(b, '"')
- b = appendStructEnd(ctx, code, b)
- } else {
- b = appendStructEndSkipLast(ctx, code, b)
- }
- code = code.Next
- case encoder.OpStructEndFloat32:
- p := load(ctxptr, code.Idx)
- b = appendStructKey(ctx, code, b)
- b = appendFloat32(ctx, b, ptrToFloat32(p+uintptr(code.Offset)))
- b = appendStructEnd(ctx, code, b)
- code = code.Next
- case encoder.OpStructEndOmitEmptyFloat32:
- p := load(ctxptr, code.Idx)
- v := ptrToFloat32(p + uintptr(code.Offset))
- if v != 0 {
- b = appendStructKey(ctx, code, b)
- b = appendFloat32(ctx, b, v)
- b = appendStructEnd(ctx, code, b)
- } else {
- b = appendStructEndSkipLast(ctx, code, b)
- }
- code = code.Next
- case encoder.OpStructEndFloat32String:
- p := load(ctxptr, code.Idx)
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendFloat32(ctx, b, ptrToFloat32(p+uintptr(code.Offset)))
- b = append(b, '"')
- b = appendStructEnd(ctx, code, b)
- code = code.Next
- case encoder.OpStructEndOmitEmptyFloat32String:
- p := load(ctxptr, code.Idx)
- v := ptrToFloat32(p + uintptr(code.Offset))
- if v != 0 {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendFloat32(ctx, b, v)
- b = append(b, '"')
- b = appendStructEnd(ctx, code, b)
- } else {
- b = appendStructEndSkipLast(ctx, code, b)
- }
- code = code.Next
- case encoder.OpStructEndFloat32Ptr:
- b = appendStructKey(ctx, code, b)
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = appendFloat32(ctx, b, ptrToFloat32(p))
- }
- b = appendStructEnd(ctx, code, b)
- code = code.Next
- case encoder.OpStructEndOmitEmptyFloat32Ptr:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = appendFloat32(ctx, b, ptrToFloat32(p))
- b = appendStructEnd(ctx, code, b)
- } else {
- b = appendStructEndSkipLast(ctx, code, b)
- }
- code = code.Next
- case encoder.OpStructEndFloat32PtrString:
- b = appendStructKey(ctx, code, b)
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = append(b, '"')
- b = appendFloat32(ctx, b, ptrToFloat32(p))
- b = append(b, '"')
- }
- b = appendStructEnd(ctx, code, b)
- code = code.Next
- case encoder.OpStructEndOmitEmptyFloat32PtrString:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendFloat32(ctx, b, ptrToFloat32(p))
- b = append(b, '"')
- b = appendStructEnd(ctx, code, b)
- } else {
- b = appendStructEndSkipLast(ctx, code, b)
- }
- code = code.Next
- case encoder.OpStructEndFloat64:
- p := load(ctxptr, code.Idx)
- v := ptrToFloat64(p + uintptr(code.Offset))
- if math.IsInf(v, 0) || math.IsNaN(v) {
- return nil, errUnsupportedFloat(v)
- }
- b = appendStructKey(ctx, code, b)
- b = appendFloat64(ctx, b, v)
- b = appendStructEnd(ctx, code, b)
- code = code.Next
- case encoder.OpStructEndOmitEmptyFloat64:
- p := load(ctxptr, code.Idx)
- v := ptrToFloat64(p + uintptr(code.Offset))
- if v != 0 {
- if math.IsInf(v, 0) || math.IsNaN(v) {
- return nil, errUnsupportedFloat(v)
- }
- b = appendStructKey(ctx, code, b)
- b = appendFloat64(ctx, b, v)
- b = appendStructEnd(ctx, code, b)
- } else {
- b = appendStructEndSkipLast(ctx, code, b)
- }
- code = code.Next
- case encoder.OpStructEndFloat64String:
- p := load(ctxptr, code.Idx)
- v := ptrToFloat64(p + uintptr(code.Offset))
- if math.IsInf(v, 0) || math.IsNaN(v) {
- return nil, errUnsupportedFloat(v)
- }
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendFloat64(ctx, b, v)
- b = append(b, '"')
- b = appendStructEnd(ctx, code, b)
- code = code.Next
- case encoder.OpStructEndOmitEmptyFloat64String:
- p := load(ctxptr, code.Idx)
- v := ptrToFloat64(p + uintptr(code.Offset))
- if v != 0 {
- if math.IsInf(v, 0) || math.IsNaN(v) {
- return nil, errUnsupportedFloat(v)
- }
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendFloat64(ctx, b, v)
- b = append(b, '"')
- b = appendStructEnd(ctx, code, b)
- } else {
- b = appendStructEndSkipLast(ctx, code, b)
- }
- code = code.Next
- case encoder.OpStructEndFloat64Ptr:
- b = appendStructKey(ctx, code, b)
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p == 0 {
- b = appendNull(ctx, b)
- b = appendStructEnd(ctx, code, b)
- code = code.Next
- break
- }
- v := ptrToFloat64(p)
- if math.IsInf(v, 0) || math.IsNaN(v) {
- return nil, errUnsupportedFloat(v)
- }
- b = appendFloat64(ctx, b, v)
- b = appendStructEnd(ctx, code, b)
- code = code.Next
- case encoder.OpStructEndOmitEmptyFloat64Ptr:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- v := ptrToFloat64(p)
- if math.IsInf(v, 0) || math.IsNaN(v) {
- return nil, errUnsupportedFloat(v)
- }
- b = appendFloat64(ctx, b, v)
- b = appendStructEnd(ctx, code, b)
- } else {
- b = appendStructEndSkipLast(ctx, code, b)
- }
- code = code.Next
- case encoder.OpStructEndFloat64PtrString:
- b = appendStructKey(ctx, code, b)
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = append(b, '"')
- v := ptrToFloat64(p)
- if math.IsInf(v, 0) || math.IsNaN(v) {
- return nil, errUnsupportedFloat(v)
- }
- b = appendFloat64(ctx, b, v)
- b = append(b, '"')
- }
- b = appendStructEnd(ctx, code, b)
- code = code.Next
- case encoder.OpStructEndOmitEmptyFloat64PtrString:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- v := ptrToFloat64(p)
- if math.IsInf(v, 0) || math.IsNaN(v) {
- return nil, errUnsupportedFloat(v)
- }
- b = append(b, '"')
- b = appendFloat64(ctx, b, v)
- b = append(b, '"')
- b = appendStructEnd(ctx, code, b)
- } else {
- b = appendStructEndSkipLast(ctx, code, b)
- }
- code = code.Next
- case encoder.OpStructEndString:
- p := load(ctxptr, code.Idx)
- b = appendStructKey(ctx, code, b)
- b = appendString(ctx, b, ptrToString(p+uintptr(code.Offset)))
- b = appendStructEnd(ctx, code, b)
- code = code.Next
- case encoder.OpStructEndOmitEmptyString:
- p := load(ctxptr, code.Idx)
- v := ptrToString(p + uintptr(code.Offset))
- if v != "" {
- b = appendStructKey(ctx, code, b)
- b = appendString(ctx, b, v)
- b = appendStructEnd(ctx, code, b)
- } else {
- b = appendStructEndSkipLast(ctx, code, b)
- }
- code = code.Next
- case encoder.OpStructEndStringString:
- p := load(ctxptr, code.Idx)
- b = appendStructKey(ctx, code, b)
- s := ptrToString(p + uintptr(code.Offset))
- b = appendString(ctx, b, string(appendString(ctx, []byte{}, s)))
- b = appendStructEnd(ctx, code, b)
- code = code.Next
- case encoder.OpStructEndOmitEmptyStringString:
- p := load(ctxptr, code.Idx)
- v := ptrToString(p + uintptr(code.Offset))
- if v != "" {
- b = appendStructKey(ctx, code, b)
- b = appendString(ctx, b, string(appendString(ctx, []byte{}, v)))
- b = appendStructEnd(ctx, code, b)
- } else {
- b = appendStructEndSkipLast(ctx, code, b)
- }
- code = code.Next
- case encoder.OpStructEndStringPtr:
- b = appendStructKey(ctx, code, b)
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = appendString(ctx, b, ptrToString(p))
- }
- b = appendStructEnd(ctx, code, b)
- code = code.Next
- case encoder.OpStructEndOmitEmptyStringPtr:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = appendString(ctx, b, ptrToString(p))
- b = appendStructEnd(ctx, code, b)
- } else {
- b = appendStructEndSkipLast(ctx, code, b)
- }
- code = code.Next
- case encoder.OpStructEndStringPtrString:
- b = appendStructKey(ctx, code, b)
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = appendString(ctx, b, string(appendString(ctx, []byte{}, ptrToString(p))))
- }
- b = appendStructEnd(ctx, code, b)
- code = code.Next
- case encoder.OpStructEndOmitEmptyStringPtrString:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = appendString(ctx, b, string(appendString(ctx, []byte{}, ptrToString(p))))
- b = appendStructEnd(ctx, code, b)
- } else {
- b = appendStructEndSkipLast(ctx, code, b)
- }
- code = code.Next
- case encoder.OpStructEndBool:
- p := load(ctxptr, code.Idx)
- b = appendStructKey(ctx, code, b)
- b = appendBool(ctx, b, ptrToBool(p+uintptr(code.Offset)))
- b = appendStructEnd(ctx, code, b)
- code = code.Next
- case encoder.OpStructEndOmitEmptyBool:
- p := load(ctxptr, code.Idx)
- v := ptrToBool(p + uintptr(code.Offset))
- if v {
- b = appendStructKey(ctx, code, b)
- b = appendBool(ctx, b, v)
- b = appendStructEnd(ctx, code, b)
- } else {
- b = appendStructEndSkipLast(ctx, code, b)
- }
- code = code.Next
- case encoder.OpStructEndBoolString:
- p := load(ctxptr, code.Idx)
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendBool(ctx, b, ptrToBool(p+uintptr(code.Offset)))
- b = append(b, '"')
- b = appendStructEnd(ctx, code, b)
- code = code.Next
- case encoder.OpStructEndOmitEmptyBoolString:
- p := load(ctxptr, code.Idx)
- v := ptrToBool(p + uintptr(code.Offset))
- if v {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendBool(ctx, b, v)
- b = append(b, '"')
- b = appendStructEnd(ctx, code, b)
- } else {
- b = appendStructEndSkipLast(ctx, code, b)
- }
- code = code.Next
- case encoder.OpStructEndBoolPtr:
- b = appendStructKey(ctx, code, b)
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = appendBool(ctx, b, ptrToBool(p))
- }
- b = appendStructEnd(ctx, code, b)
- code = code.Next
- case encoder.OpStructEndOmitEmptyBoolPtr:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = appendBool(ctx, b, ptrToBool(p))
- b = appendStructEnd(ctx, code, b)
- } else {
- b = appendStructEndSkipLast(ctx, code, b)
- }
- code = code.Next
- case encoder.OpStructEndBoolPtrString:
- b = appendStructKey(ctx, code, b)
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = append(b, '"')
- b = appendBool(ctx, b, ptrToBool(p))
- b = append(b, '"')
- }
- b = appendStructEnd(ctx, code, b)
- code = code.Next
- case encoder.OpStructEndOmitEmptyBoolPtrString:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendBool(ctx, b, ptrToBool(p))
- b = append(b, '"')
- b = appendStructEnd(ctx, code, b)
- } else {
- b = appendStructEndSkipLast(ctx, code, b)
- }
- code = code.Next
- case encoder.OpStructEndBytes:
- p := load(ctxptr, code.Idx)
- b = appendStructKey(ctx, code, b)
- b = appendByteSlice(ctx, b, ptrToBytes(p+uintptr(code.Offset)))
- b = appendStructEnd(ctx, code, b)
- code = code.Next
- case encoder.OpStructEndOmitEmptyBytes:
- p := load(ctxptr, code.Idx)
- v := ptrToBytes(p + uintptr(code.Offset))
- if len(v) > 0 {
- b = appendStructKey(ctx, code, b)
- b = appendByteSlice(ctx, b, v)
- b = appendStructEnd(ctx, code, b)
- } else {
- b = appendStructEndSkipLast(ctx, code, b)
- }
- code = code.Next
- case encoder.OpStructEndBytesPtr:
- b = appendStructKey(ctx, code, b)
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = appendByteSlice(ctx, b, ptrToBytes(p))
- }
- b = appendStructEnd(ctx, code, b)
- code = code.Next
- case encoder.OpStructEndOmitEmptyBytesPtr:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = appendByteSlice(ctx, b, ptrToBytes(p))
- b = appendStructEnd(ctx, code, b)
- } else {
- b = appendStructEndSkipLast(ctx, code, b)
- }
- code = code.Next
- case encoder.OpStructEndNumber:
- p := load(ctxptr, code.Idx)
- b = appendStructKey(ctx, code, b)
- bb, err := appendNumber(ctx, b, ptrToNumber(p+uintptr(code.Offset)))
- if err != nil {
- return nil, err
- }
- b = appendStructEnd(ctx, code, bb)
- code = code.Next
- case encoder.OpStructEndOmitEmptyNumber:
- p := load(ctxptr, code.Idx)
- v := ptrToNumber(p + uintptr(code.Offset))
- if v != "" {
- b = appendStructKey(ctx, code, b)
- bb, err := appendNumber(ctx, b, v)
- if err != nil {
- return nil, err
- }
- b = appendStructEnd(ctx, code, bb)
- } else {
- b = appendStructEndSkipLast(ctx, code, b)
- }
- code = code.Next
- case encoder.OpStructEndNumberString:
- p := load(ctxptr, code.Idx)
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- bb, err := appendNumber(ctx, b, ptrToNumber(p+uintptr(code.Offset)))
- if err != nil {
- return nil, err
- }
- b = append(bb, '"')
- b = appendStructEnd(ctx, code, b)
- code = code.Next
- case encoder.OpStructEndOmitEmptyNumberString:
- p := load(ctxptr, code.Idx)
- v := ptrToNumber(p + uintptr(code.Offset))
- if v != "" {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- bb, err := appendNumber(ctx, b, v)
- if err != nil {
- return nil, err
- }
- b = append(bb, '"')
- b = appendStructEnd(ctx, code, b)
- } else {
- b = appendStructEndSkipLast(ctx, code, b)
- }
- code = code.Next
- case encoder.OpStructEndNumberPtr:
- b = appendStructKey(ctx, code, b)
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- bb, err := appendNumber(ctx, b, ptrToNumber(p))
- if err != nil {
- return nil, err
- }
- b = bb
- }
- b = appendStructEnd(ctx, code, b)
- code = code.Next
- case encoder.OpStructEndOmitEmptyNumberPtr:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- bb, err := appendNumber(ctx, b, ptrToNumber(p))
- if err != nil {
- return nil, err
- }
- b = appendStructEnd(ctx, code, bb)
- } else {
- b = appendStructEndSkipLast(ctx, code, b)
- }
- code = code.Next
- case encoder.OpStructEndNumberPtrString:
- b = appendStructKey(ctx, code, b)
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = append(b, '"')
- bb, err := appendNumber(ctx, b, ptrToNumber(p))
- if err != nil {
- return nil, err
- }
- b = append(bb, '"')
- }
- b = appendStructEnd(ctx, code, b)
- code = code.Next
- case encoder.OpStructEndOmitEmptyNumberPtrString:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- bb, err := appendNumber(ctx, b, ptrToNumber(p))
- if err != nil {
- return nil, err
- }
- b = append(bb, '"')
- b = appendStructEnd(ctx, code, b)
- } else {
- b = appendStructEndSkipLast(ctx, code, b)
- }
- code = code.Next
- case encoder.OpEnd:
- goto END
- }
- }
-END:
- return b, nil
-}
diff --git a/vendor/github.com/goccy/go-json/internal/encoder/vm_color_indent/debug_vm.go b/vendor/github.com/goccy/go-json/internal/encoder/vm_color_indent/debug_vm.go
deleted file mode 100644
index dd4cd489..00000000
--- a/vendor/github.com/goccy/go-json/internal/encoder/vm_color_indent/debug_vm.go
+++ /dev/null
@@ -1,35 +0,0 @@
-package vm_color_indent
-
-import (
- "fmt"
-
- "github.com/goccy/go-json/internal/encoder"
-)
-
-func DebugRun(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet) ([]byte, error) {
- var code *encoder.Opcode
- if (ctx.Option.Flag & encoder.HTMLEscapeOption) != 0 {
- code = codeSet.EscapeKeyCode
- } else {
- code = codeSet.NoescapeKeyCode
- }
-
- defer func() {
- if err := recover(); err != nil {
- w := ctx.Option.DebugOut
- fmt.Fprintln(w, "=============[DEBUG]===============")
- fmt.Fprintln(w, "* [TYPE]")
- fmt.Fprintln(w, codeSet.Type)
- fmt.Fprintf(w, "\n")
- fmt.Fprintln(w, "* [ALL OPCODE]")
- fmt.Fprintln(w, code.Dump())
- fmt.Fprintf(w, "\n")
- fmt.Fprintln(w, "* [CONTEXT]")
- fmt.Fprintf(w, "%+v\n", ctx)
- fmt.Fprintln(w, "===================================")
- panic(err)
- }
- }()
-
- return Run(ctx, b, codeSet)
-}
diff --git a/vendor/github.com/goccy/go-json/internal/encoder/vm_color_indent/util.go b/vendor/github.com/goccy/go-json/internal/encoder/vm_color_indent/util.go
deleted file mode 100644
index 2395abec..00000000
--- a/vendor/github.com/goccy/go-json/internal/encoder/vm_color_indent/util.go
+++ /dev/null
@@ -1,297 +0,0 @@
-package vm_color_indent
-
-import (
- "encoding/json"
- "fmt"
- "unsafe"
-
- "github.com/goccy/go-json/internal/encoder"
- "github.com/goccy/go-json/internal/runtime"
-)
-
-const uintptrSize = 4 << (^uintptr(0) >> 63)
-
-var (
- appendIndent = encoder.AppendIndent
- appendStructEnd = encoder.AppendStructEndIndent
- errUnsupportedValue = encoder.ErrUnsupportedValue
- errUnsupportedFloat = encoder.ErrUnsupportedFloat
- mapiterinit = encoder.MapIterInit
- mapiterkey = encoder.MapIterKey
- mapitervalue = encoder.MapIterValue
- mapiternext = encoder.MapIterNext
- maplen = encoder.MapLen
-)
-
-type emptyInterface struct {
- typ *runtime.Type
- ptr unsafe.Pointer
-}
-
-type nonEmptyInterface struct {
- itab *struct {
- ityp *runtime.Type // static interface type
- typ *runtime.Type // dynamic concrete type
- // unused fields...
- }
- ptr unsafe.Pointer
-}
-
-func errUnimplementedOp(op encoder.OpType) error {
- return fmt.Errorf("encoder (indent): opcode %s has not been implemented", op)
-}
-
-func load(base uintptr, idx uint32) uintptr {
- addr := base + uintptr(idx)
- return **(**uintptr)(unsafe.Pointer(&addr))
-}
-
-func store(base uintptr, idx uint32, p uintptr) {
- addr := base + uintptr(idx)
- **(**uintptr)(unsafe.Pointer(&addr)) = p
-}
-
-func loadNPtr(base uintptr, idx uint32, ptrNum uint8) uintptr {
- addr := base + uintptr(idx)
- p := **(**uintptr)(unsafe.Pointer(&addr))
- for i := uint8(0); i < ptrNum; i++ {
- if p == 0 {
- return 0
- }
- p = ptrToPtr(p)
- }
- return p
-}
-
-func ptrToUint64(p uintptr, bitSize uint8) uint64 {
- switch bitSize {
- case 8:
- return (uint64)(**(**uint8)(unsafe.Pointer(&p)))
- case 16:
- return (uint64)(**(**uint16)(unsafe.Pointer(&p)))
- case 32:
- return (uint64)(**(**uint32)(unsafe.Pointer(&p)))
- case 64:
- return **(**uint64)(unsafe.Pointer(&p))
- }
- return 0
-}
-
-func ptrToFloat32(p uintptr) float32 { return **(**float32)(unsafe.Pointer(&p)) }
-func ptrToFloat64(p uintptr) float64 { return **(**float64)(unsafe.Pointer(&p)) }
-func ptrToBool(p uintptr) bool { return **(**bool)(unsafe.Pointer(&p)) }
-func ptrToBytes(p uintptr) []byte { return **(**[]byte)(unsafe.Pointer(&p)) }
-func ptrToNumber(p uintptr) json.Number { return **(**json.Number)(unsafe.Pointer(&p)) }
-func ptrToString(p uintptr) string { return **(**string)(unsafe.Pointer(&p)) }
-func ptrToSlice(p uintptr) *runtime.SliceHeader { return *(**runtime.SliceHeader)(unsafe.Pointer(&p)) }
-func ptrToPtr(p uintptr) uintptr {
- return uintptr(**(**unsafe.Pointer)(unsafe.Pointer(&p)))
-}
-func ptrToNPtr(p uintptr, ptrNum uint8) uintptr {
- for i := uint8(0); i < ptrNum; i++ {
- if p == 0 {
- return 0
- }
- p = ptrToPtr(p)
- }
- return p
-}
-
-func ptrToUnsafePtr(p uintptr) unsafe.Pointer {
- return *(*unsafe.Pointer)(unsafe.Pointer(&p))
-}
-func ptrToInterface(code *encoder.Opcode, p uintptr) interface{} {
- return *(*interface{})(unsafe.Pointer(&emptyInterface{
- typ: code.Type,
- ptr: *(*unsafe.Pointer)(unsafe.Pointer(&p)),
- }))
-}
-
-func appendInt(ctx *encoder.RuntimeContext, b []byte, p uintptr, code *encoder.Opcode) []byte {
- format := ctx.Option.ColorScheme.Int
- b = append(b, format.Header...)
- b = encoder.AppendInt(ctx, b, p, code)
- return append(b, format.Footer...)
-}
-
-func appendUint(ctx *encoder.RuntimeContext, b []byte, p uintptr, code *encoder.Opcode) []byte {
- format := ctx.Option.ColorScheme.Uint
- b = append(b, format.Header...)
- b = encoder.AppendUint(ctx, b, p, code)
- return append(b, format.Footer...)
-}
-
-func appendFloat32(ctx *encoder.RuntimeContext, b []byte, v float32) []byte {
- format := ctx.Option.ColorScheme.Float
- b = append(b, format.Header...)
- b = encoder.AppendFloat32(ctx, b, v)
- return append(b, format.Footer...)
-}
-
-func appendFloat64(ctx *encoder.RuntimeContext, b []byte, v float64) []byte {
- format := ctx.Option.ColorScheme.Float
- b = append(b, format.Header...)
- b = encoder.AppendFloat64(ctx, b, v)
- return append(b, format.Footer...)
-}
-
-func appendString(ctx *encoder.RuntimeContext, b []byte, v string) []byte {
- format := ctx.Option.ColorScheme.String
- b = append(b, format.Header...)
- b = encoder.AppendString(ctx, b, v)
- return append(b, format.Footer...)
-}
-
-func appendByteSlice(ctx *encoder.RuntimeContext, b []byte, src []byte) []byte {
- format := ctx.Option.ColorScheme.Binary
- b = append(b, format.Header...)
- b = encoder.AppendByteSlice(ctx, b, src)
- return append(b, format.Footer...)
-}
-
-func appendNumber(ctx *encoder.RuntimeContext, b []byte, n json.Number) ([]byte, error) {
- format := ctx.Option.ColorScheme.Int
- b = append(b, format.Header...)
- bb, err := encoder.AppendNumber(ctx, b, n)
- if err != nil {
- return nil, err
- }
- return append(bb, format.Footer...), nil
-}
-
-func appendBool(ctx *encoder.RuntimeContext, b []byte, v bool) []byte {
- format := ctx.Option.ColorScheme.Bool
- b = append(b, format.Header...)
- if v {
- b = append(b, "true"...)
- } else {
- b = append(b, "false"...)
- }
- return append(b, format.Footer...)
-}
-
-func appendNull(ctx *encoder.RuntimeContext, b []byte) []byte {
- format := ctx.Option.ColorScheme.Null
- b = append(b, format.Header...)
- b = append(b, "null"...)
- return append(b, format.Footer...)
-}
-
-func appendComma(_ *encoder.RuntimeContext, b []byte) []byte {
- return append(b, ',', '\n')
-}
-
-func appendNullComma(ctx *encoder.RuntimeContext, b []byte) []byte {
- format := ctx.Option.ColorScheme.Null
- b = append(b, format.Header...)
- b = append(b, "null"...)
- return append(append(b, format.Footer...), ',', '\n')
-}
-
-func appendColon(_ *encoder.RuntimeContext, b []byte) []byte {
- return append(b[:len(b)-2], ':', ' ')
-}
-
-func appendMapKeyValue(ctx *encoder.RuntimeContext, code *encoder.Opcode, b, key, value []byte) []byte {
- b = appendIndent(ctx, b, code.Indent+1)
- b = append(b, key...)
- b[len(b)-2] = ':'
- b[len(b)-1] = ' '
- return append(b, value...)
-}
-
-func appendMapEnd(ctx *encoder.RuntimeContext, code *encoder.Opcode, b []byte) []byte {
- b = b[:len(b)-2]
- b = append(b, '\n')
- b = appendIndent(ctx, b, code.Indent)
- return append(b, '}', ',', '\n')
-}
-
-func appendArrayHead(ctx *encoder.RuntimeContext, code *encoder.Opcode, b []byte) []byte {
- b = append(b, '[', '\n')
- return appendIndent(ctx, b, code.Indent+1)
-}
-
-func appendArrayEnd(ctx *encoder.RuntimeContext, code *encoder.Opcode, b []byte) []byte {
- b = b[:len(b)-2]
- b = append(b, '\n')
- b = appendIndent(ctx, b, code.Indent)
- return append(b, ']', ',', '\n')
-}
-
-func appendEmptyArray(_ *encoder.RuntimeContext, b []byte) []byte {
- return append(b, '[', ']', ',', '\n')
-}
-
-func appendEmptyObject(_ *encoder.RuntimeContext, b []byte) []byte {
- return append(b, '{', '}', ',', '\n')
-}
-
-func appendObjectEnd(ctx *encoder.RuntimeContext, code *encoder.Opcode, b []byte) []byte {
- last := len(b) - 1
- // replace comma to newline
- b[last-1] = '\n'
- b = appendIndent(ctx, b[:last], code.Indent)
- return append(b, '}', ',', '\n')
-}
-
-func appendMarshalJSON(ctx *encoder.RuntimeContext, code *encoder.Opcode, b []byte, v interface{}) ([]byte, error) {
- return encoder.AppendMarshalJSONIndent(ctx, code, b, v)
-}
-
-func appendMarshalText(ctx *encoder.RuntimeContext, code *encoder.Opcode, b []byte, v interface{}) ([]byte, error) {
- format := ctx.Option.ColorScheme.String
- b = append(b, format.Header...)
- bb, err := encoder.AppendMarshalTextIndent(ctx, code, b, v)
- if err != nil {
- return nil, err
- }
- return append(bb, format.Footer...), nil
-}
-
-func appendStructHead(_ *encoder.RuntimeContext, b []byte) []byte {
- return append(b, '{', '\n')
-}
-
-func appendStructKey(ctx *encoder.RuntimeContext, code *encoder.Opcode, b []byte) []byte {
- b = appendIndent(ctx, b, code.Indent)
-
- format := ctx.Option.ColorScheme.ObjectKey
- b = append(b, format.Header...)
- b = append(b, code.Key[:len(code.Key)-1]...)
- b = append(b, format.Footer...)
-
- return append(b, ':', ' ')
-}
-
-func appendStructEndSkipLast(ctx *encoder.RuntimeContext, code *encoder.Opcode, b []byte) []byte {
- last := len(b) - 1
- if b[last-1] == '{' {
- b[last] = '}'
- } else {
- if b[last] == '\n' {
- // to remove ',' and '\n' characters
- b = b[:len(b)-2]
- }
- b = append(b, '\n')
- b = appendIndent(ctx, b, code.Indent-1)
- b = append(b, '}')
- }
- return appendComma(ctx, b)
-}
-
-func restoreIndent(ctx *encoder.RuntimeContext, code *encoder.Opcode, ctxptr uintptr) {
- ctx.BaseIndent = uint32(load(ctxptr, code.Length))
-}
-
-func storeIndent(ctxptr uintptr, code *encoder.Opcode, indent uintptr) {
- store(ctxptr, code.Length, indent)
-}
-
-func appendArrayElemIndent(ctx *encoder.RuntimeContext, code *encoder.Opcode, b []byte) []byte {
- return appendIndent(ctx, b, code.Indent+1)
-}
-
-func appendMapKeyIndent(ctx *encoder.RuntimeContext, code *encoder.Opcode, b []byte) []byte {
- return appendIndent(ctx, b, code.Indent)
-}
diff --git a/vendor/github.com/goccy/go-json/internal/encoder/vm_color_indent/vm.go b/vendor/github.com/goccy/go-json/internal/encoder/vm_color_indent/vm.go
deleted file mode 100644
index 3b4e22e5..00000000
--- a/vendor/github.com/goccy/go-json/internal/encoder/vm_color_indent/vm.go
+++ /dev/null
@@ -1,4859 +0,0 @@
-// Code generated by internal/cmd/generator. DO NOT EDIT!
-package vm_color_indent
-
-import (
- "math"
- "reflect"
- "sort"
- "unsafe"
-
- "github.com/goccy/go-json/internal/encoder"
- "github.com/goccy/go-json/internal/runtime"
-)
-
-func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet) ([]byte, error) {
- recursiveLevel := 0
- ptrOffset := uintptr(0)
- ctxptr := ctx.Ptr()
- var code *encoder.Opcode
- if (ctx.Option.Flag & encoder.HTMLEscapeOption) != 0 {
- code = codeSet.EscapeKeyCode
- } else {
- code = codeSet.NoescapeKeyCode
- }
-
- for {
- switch code.Op {
- default:
- return nil, errUnimplementedOp(code.Op)
- case encoder.OpPtr:
- p := load(ctxptr, code.Idx)
- code = code.Next
- store(ctxptr, code.Idx, ptrToPtr(p))
- case encoder.OpIntPtr:
- p := loadNPtr(ctxptr, code.Idx, code.PtrNum)
- if p == 0 {
- b = appendNullComma(ctx, b)
- code = code.Next
- break
- }
- store(ctxptr, code.Idx, p)
- fallthrough
- case encoder.OpInt:
- b = appendInt(ctx, b, load(ctxptr, code.Idx), code)
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpUintPtr:
- p := loadNPtr(ctxptr, code.Idx, code.PtrNum)
- if p == 0 {
- b = appendNullComma(ctx, b)
- code = code.Next
- break
- }
- store(ctxptr, code.Idx, p)
- fallthrough
- case encoder.OpUint:
- b = appendUint(ctx, b, load(ctxptr, code.Idx), code)
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpIntString:
- b = append(b, '"')
- b = appendInt(ctx, b, load(ctxptr, code.Idx), code)
- b = append(b, '"')
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpUintString:
- b = append(b, '"')
- b = appendUint(ctx, b, load(ctxptr, code.Idx), code)
- b = append(b, '"')
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpFloat32Ptr:
- p := loadNPtr(ctxptr, code.Idx, code.PtrNum)
- if p == 0 {
- b = appendNull(ctx, b)
- b = appendComma(ctx, b)
- code = code.Next
- break
- }
- store(ctxptr, code.Idx, p)
- fallthrough
- case encoder.OpFloat32:
- b = appendFloat32(ctx, b, ptrToFloat32(load(ctxptr, code.Idx)))
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpFloat64Ptr:
- p := loadNPtr(ctxptr, code.Idx, code.PtrNum)
- if p == 0 {
- b = appendNullComma(ctx, b)
- code = code.Next
- break
- }
- store(ctxptr, code.Idx, p)
- fallthrough
- case encoder.OpFloat64:
- v := ptrToFloat64(load(ctxptr, code.Idx))
- if math.IsInf(v, 0) || math.IsNaN(v) {
- return nil, errUnsupportedFloat(v)
- }
- b = appendFloat64(ctx, b, v)
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStringPtr:
- p := loadNPtr(ctxptr, code.Idx, code.PtrNum)
- if p == 0 {
- b = appendNullComma(ctx, b)
- code = code.Next
- break
- }
- store(ctxptr, code.Idx, p)
- fallthrough
- case encoder.OpString:
- b = appendString(ctx, b, ptrToString(load(ctxptr, code.Idx)))
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpBoolPtr:
- p := loadNPtr(ctxptr, code.Idx, code.PtrNum)
- if p == 0 {
- b = appendNullComma(ctx, b)
- code = code.Next
- break
- }
- store(ctxptr, code.Idx, p)
- fallthrough
- case encoder.OpBool:
- b = appendBool(ctx, b, ptrToBool(load(ctxptr, code.Idx)))
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpBytesPtr:
- p := loadNPtr(ctxptr, code.Idx, code.PtrNum)
- if p == 0 {
- b = appendNullComma(ctx, b)
- code = code.Next
- break
- }
- store(ctxptr, code.Idx, p)
- fallthrough
- case encoder.OpBytes:
- b = appendByteSlice(ctx, b, ptrToBytes(load(ctxptr, code.Idx)))
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpNumberPtr:
- p := loadNPtr(ctxptr, code.Idx, code.PtrNum)
- if p == 0 {
- b = appendNullComma(ctx, b)
- code = code.Next
- break
- }
- store(ctxptr, code.Idx, p)
- fallthrough
- case encoder.OpNumber:
- bb, err := appendNumber(ctx, b, ptrToNumber(load(ctxptr, code.Idx)))
- if err != nil {
- return nil, err
- }
- b = appendComma(ctx, bb)
- code = code.Next
- case encoder.OpInterfacePtr:
- p := loadNPtr(ctxptr, code.Idx, code.PtrNum)
- if p == 0 {
- b = appendNullComma(ctx, b)
- code = code.Next
- break
- }
- store(ctxptr, code.Idx, p)
- fallthrough
- case encoder.OpInterface:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- b = appendNullComma(ctx, b)
- code = code.Next
- break
- }
- if recursiveLevel > encoder.StartDetectingCyclesAfter {
- for _, seen := range ctx.SeenPtr {
- if p == seen {
- return nil, errUnsupportedValue(code, p)
- }
- }
- }
- ctx.SeenPtr = append(ctx.SeenPtr, p)
- var (
- typ *runtime.Type
- ifacePtr unsafe.Pointer
- )
- up := ptrToUnsafePtr(p)
- if code.Flags&encoder.NonEmptyInterfaceFlags != 0 {
- iface := (*nonEmptyInterface)(up)
- ifacePtr = iface.ptr
- if iface.itab != nil {
- typ = iface.itab.typ
- }
- } else {
- iface := (*emptyInterface)(up)
- ifacePtr = iface.ptr
- typ = iface.typ
- }
- if ifacePtr == nil {
- isDirectedNil := typ != nil && typ.Kind() == reflect.Struct && !runtime.IfaceIndir(typ)
- if !isDirectedNil {
- b = appendNullComma(ctx, b)
- code = code.Next
- break
- }
- }
- ctx.KeepRefs = append(ctx.KeepRefs, up)
- ifaceCodeSet, err := encoder.CompileToGetCodeSet(ctx, uintptr(unsafe.Pointer(typ)))
- if err != nil {
- return nil, err
- }
-
- totalLength := uintptr(code.Length) + 3
- nextTotalLength := uintptr(ifaceCodeSet.CodeLength) + 3
-
- var c *encoder.Opcode
- if (ctx.Option.Flag & encoder.HTMLEscapeOption) != 0 {
- c = ifaceCodeSet.InterfaceEscapeKeyCode
- } else {
- c = ifaceCodeSet.InterfaceNoescapeKeyCode
- }
- curlen := uintptr(len(ctx.Ptrs))
- offsetNum := ptrOffset / uintptrSize
- oldOffset := ptrOffset
- ptrOffset += totalLength * uintptrSize
- oldBaseIndent := ctx.BaseIndent
- ctx.BaseIndent += code.Indent
-
- newLen := offsetNum + totalLength + nextTotalLength
- if curlen < newLen {
- ctx.Ptrs = append(ctx.Ptrs, make([]uintptr, newLen-curlen)...)
- }
- ctxptr = ctx.Ptr() + ptrOffset // assign new ctxptr
-
- end := ifaceCodeSet.EndCode
- store(ctxptr, c.Idx, uintptr(ifacePtr))
- store(ctxptr, end.Idx, oldOffset)
- store(ctxptr, end.ElemIdx, uintptr(unsafe.Pointer(code.Next)))
- storeIndent(ctxptr, end, uintptr(oldBaseIndent))
- code = c
- recursiveLevel++
- case encoder.OpInterfaceEnd:
- recursiveLevel--
-
- // restore ctxptr
- offset := load(ctxptr, code.Idx)
- restoreIndent(ctx, code, ctxptr)
- ctx.SeenPtr = ctx.SeenPtr[:len(ctx.SeenPtr)-1]
-
- codePtr := load(ctxptr, code.ElemIdx)
- code = (*encoder.Opcode)(ptrToUnsafePtr(codePtr))
- ctxptr = ctx.Ptr() + offset
- ptrOffset = offset
- case encoder.OpMarshalJSONPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- b = appendNullComma(ctx, b)
- code = code.Next
- break
- }
- store(ctxptr, code.Idx, ptrToPtr(p))
- fallthrough
- case encoder.OpMarshalJSON:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- b = appendNullComma(ctx, b)
- code = code.Next
- break
- }
- if (code.Flags&encoder.IsNilableTypeFlags) != 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- p = ptrToPtr(p)
- }
- bb, err := appendMarshalJSON(ctx, code, b, ptrToInterface(code, p))
- if err != nil {
- return nil, err
- }
- b = appendComma(ctx, bb)
- code = code.Next
- case encoder.OpMarshalTextPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- b = appendNullComma(ctx, b)
- code = code.Next
- break
- }
- store(ctxptr, code.Idx, ptrToPtr(p))
- fallthrough
- case encoder.OpMarshalText:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- b = append(b, `""`...)
- b = appendComma(ctx, b)
- code = code.Next
- break
- }
- if (code.Flags&encoder.IsNilableTypeFlags) != 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- p = ptrToPtr(p)
- }
- bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p))
- if err != nil {
- return nil, err
- }
- b = appendComma(ctx, bb)
- code = code.Next
- case encoder.OpSlicePtr:
- p := loadNPtr(ctxptr, code.Idx, code.PtrNum)
- if p == 0 {
- b = appendNullComma(ctx, b)
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, p)
- fallthrough
- case encoder.OpSlice:
- p := load(ctxptr, code.Idx)
- slice := ptrToSlice(p)
- if p == 0 || slice.Data == nil {
- b = appendNullComma(ctx, b)
- code = code.End.Next
- break
- }
- store(ctxptr, code.ElemIdx, 0)
- store(ctxptr, code.Length, uintptr(slice.Len))
- store(ctxptr, code.Idx, uintptr(slice.Data))
- if slice.Len > 0 {
- b = appendArrayHead(ctx, code, b)
- code = code.Next
- store(ctxptr, code.Idx, uintptr(slice.Data))
- } else {
- b = appendEmptyArray(ctx, b)
- code = code.End.Next
- }
- case encoder.OpSliceElem:
- idx := load(ctxptr, code.ElemIdx)
- length := load(ctxptr, code.Length)
- idx++
- if idx < length {
- b = appendArrayElemIndent(ctx, code, b)
- store(ctxptr, code.ElemIdx, idx)
- data := load(ctxptr, code.Idx)
- size := uintptr(code.Size)
- code = code.Next
- store(ctxptr, code.Idx, data+idx*size)
- } else {
- b = appendArrayEnd(ctx, code, b)
- code = code.End.Next
- }
- case encoder.OpArrayPtr:
- p := loadNPtr(ctxptr, code.Idx, code.PtrNum)
- if p == 0 {
- b = appendNullComma(ctx, b)
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, p)
- fallthrough
- case encoder.OpArray:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- b = appendNullComma(ctx, b)
- code = code.End.Next
- break
- }
- if code.Length > 0 {
- b = appendArrayHead(ctx, code, b)
- store(ctxptr, code.ElemIdx, 0)
- code = code.Next
- store(ctxptr, code.Idx, p)
- } else {
- b = appendEmptyArray(ctx, b)
- code = code.End.Next
- }
- case encoder.OpArrayElem:
- idx := load(ctxptr, code.ElemIdx)
- idx++
- if idx < uintptr(code.Length) {
- b = appendArrayElemIndent(ctx, code, b)
- store(ctxptr, code.ElemIdx, idx)
- p := load(ctxptr, code.Idx)
- size := uintptr(code.Size)
- code = code.Next
- store(ctxptr, code.Idx, p+idx*size)
- } else {
- b = appendArrayEnd(ctx, code, b)
- code = code.End.Next
- }
- case encoder.OpMapPtr:
- p := loadNPtr(ctxptr, code.Idx, code.PtrNum)
- if p == 0 {
- b = appendNullComma(ctx, b)
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, p)
- fallthrough
- case encoder.OpMap:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- b = appendNullComma(ctx, b)
- code = code.End.Next
- break
- }
- uptr := ptrToUnsafePtr(p)
- mlen := maplen(uptr)
- if mlen <= 0 {
- b = appendEmptyObject(ctx, b)
- code = code.End.Next
- break
- }
- b = appendStructHead(ctx, b)
- unorderedMap := (ctx.Option.Flag & encoder.UnorderedMapOption) != 0
- mapCtx := encoder.NewMapContext(mlen, unorderedMap)
- mapiterinit(code.Type, uptr, &mapCtx.Iter)
- store(ctxptr, code.Idx, uintptr(unsafe.Pointer(mapCtx)))
- ctx.KeepRefs = append(ctx.KeepRefs, unsafe.Pointer(mapCtx))
- if unorderedMap {
- b = appendMapKeyIndent(ctx, code.Next, b)
- } else {
- mapCtx.Start = len(b)
- mapCtx.First = len(b)
- }
- key := mapiterkey(&mapCtx.Iter)
- store(ctxptr, code.Next.Idx, uintptr(key))
- code = code.Next
- case encoder.OpMapKey:
- mapCtx := (*encoder.MapContext)(ptrToUnsafePtr(load(ctxptr, code.Idx)))
- idx := mapCtx.Idx
- idx++
- if (ctx.Option.Flag & encoder.UnorderedMapOption) != 0 {
- if idx < mapCtx.Len {
- b = appendMapKeyIndent(ctx, code, b)
- mapCtx.Idx = int(idx)
- key := mapiterkey(&mapCtx.Iter)
- store(ctxptr, code.Next.Idx, uintptr(key))
- code = code.Next
- } else {
- b = appendObjectEnd(ctx, code, b)
- encoder.ReleaseMapContext(mapCtx)
- code = code.End.Next
- }
- } else {
- mapCtx.Slice.Items[mapCtx.Idx].Value = b[mapCtx.Start:len(b)]
- if idx < mapCtx.Len {
- mapCtx.Idx = int(idx)
- mapCtx.Start = len(b)
- key := mapiterkey(&mapCtx.Iter)
- store(ctxptr, code.Next.Idx, uintptr(key))
- code = code.Next
- } else {
- code = code.End
- }
- }
- case encoder.OpMapValue:
- mapCtx := (*encoder.MapContext)(ptrToUnsafePtr(load(ctxptr, code.Idx)))
- if (ctx.Option.Flag & encoder.UnorderedMapOption) != 0 {
- b = appendColon(ctx, b)
- } else {
- mapCtx.Slice.Items[mapCtx.Idx].Key = b[mapCtx.Start:len(b)]
- mapCtx.Start = len(b)
- }
- value := mapitervalue(&mapCtx.Iter)
- store(ctxptr, code.Next.Idx, uintptr(value))
- mapiternext(&mapCtx.Iter)
- code = code.Next
- case encoder.OpMapEnd:
- // this operation only used by sorted map.
- mapCtx := (*encoder.MapContext)(ptrToUnsafePtr(load(ctxptr, code.Idx)))
- sort.Sort(mapCtx.Slice)
- buf := mapCtx.Buf
- for _, item := range mapCtx.Slice.Items {
- buf = appendMapKeyValue(ctx, code, buf, item.Key, item.Value)
- }
- buf = appendMapEnd(ctx, code, buf)
- b = b[:mapCtx.First]
- b = append(b, buf...)
- mapCtx.Buf = buf
- encoder.ReleaseMapContext(mapCtx)
- code = code.Next
- case encoder.OpRecursivePtr:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- code = code.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpRecursive:
- ptr := load(ctxptr, code.Idx)
- if ptr != 0 {
- if recursiveLevel > encoder.StartDetectingCyclesAfter {
- for _, seen := range ctx.SeenPtr {
- if ptr == seen {
- return nil, errUnsupportedValue(code, ptr)
- }
- }
- }
- }
- ctx.SeenPtr = append(ctx.SeenPtr, ptr)
- c := code.Jmp.Code
- curlen := uintptr(len(ctx.Ptrs))
- offsetNum := ptrOffset / uintptrSize
- oldOffset := ptrOffset
- ptrOffset += code.Jmp.CurLen * uintptrSize
- oldBaseIndent := ctx.BaseIndent
- indentDiffFromTop := c.Indent - 1
- ctx.BaseIndent += code.Indent - indentDiffFromTop
-
- newLen := offsetNum + code.Jmp.CurLen + code.Jmp.NextLen
- if curlen < newLen {
- ctx.Ptrs = append(ctx.Ptrs, make([]uintptr, newLen-curlen)...)
- }
- ctxptr = ctx.Ptr() + ptrOffset // assign new ctxptr
-
- store(ctxptr, c.Idx, ptr)
- store(ctxptr, c.End.Next.Idx, oldOffset)
- store(ctxptr, c.End.Next.ElemIdx, uintptr(unsafe.Pointer(code.Next)))
- storeIndent(ctxptr, c.End.Next, uintptr(oldBaseIndent))
- code = c
- recursiveLevel++
- case encoder.OpRecursiveEnd:
- recursiveLevel--
-
- // restore ctxptr
- restoreIndent(ctx, code, ctxptr)
- offset := load(ctxptr, code.Idx)
- ctx.SeenPtr = ctx.SeenPtr[:len(ctx.SeenPtr)-1]
-
- codePtr := load(ctxptr, code.ElemIdx)
- code = (*encoder.Opcode)(ptrToUnsafePtr(codePtr))
- ctxptr = ctx.Ptr() + offset
- ptrOffset = offset
- case encoder.OpStructPtrHead:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHead:
- p := load(ctxptr, code.Idx)
- if p == 0 && ((code.Flags&encoder.IndirectFlags) != 0 || code.Next.Op == encoder.OpStructEnd) {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- if len(code.Key) > 0 {
- if (code.Flags&encoder.IsTaggedKeyFlags) != 0 || code.Flags&encoder.AnonymousKeyFlags == 0 {
- b = appendStructKey(ctx, code, b)
- }
- }
- p += uintptr(code.Offset)
- code = code.Next
- store(ctxptr, code.Idx, p)
- case encoder.OpStructPtrHeadOmitEmpty:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadOmitEmpty:
- p := load(ctxptr, code.Idx)
- if p == 0 && ((code.Flags&encoder.IndirectFlags) != 0 || code.Next.Op == encoder.OpStructEnd) {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- p += uintptr(code.Offset)
- if p == 0 || (ptrToPtr(p) == 0 && (code.Flags&encoder.IsNextOpPtrTypeFlags) != 0) {
- code = code.NextField
- } else {
- b = appendStructKey(ctx, code, b)
- code = code.Next
- store(ctxptr, code.Idx, p)
- }
- case encoder.OpStructPtrHeadInt:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadInt:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- b = appendInt(ctx, b, p+uintptr(code.Offset), code)
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyInt:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadOmitEmptyInt:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- u64 := ptrToUint64(p+uintptr(code.Offset), code.NumBitSize)
- v := u64 & ((1 << code.NumBitSize) - 1)
- if v == 0 {
- code = code.NextField
- } else {
- b = appendStructKey(ctx, code, b)
- b = appendInt(ctx, b, p+uintptr(code.Offset), code)
- b = appendComma(ctx, b)
- code = code.Next
- }
- case encoder.OpStructPtrHeadIntString:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadIntString:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendInt(ctx, b, p+uintptr(code.Offset), code)
- b = append(b, '"')
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyIntString:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadOmitEmptyIntString:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- p += uintptr(code.Offset)
- u64 := ptrToUint64(p, code.NumBitSize)
- v := u64 & ((1 << code.NumBitSize) - 1)
- if v == 0 {
- code = code.NextField
- } else {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendInt(ctx, b, p, code)
- b = append(b, '"')
- b = appendComma(ctx, b)
- code = code.Next
- }
- case encoder.OpStructPtrHeadIntPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadIntPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = appendInt(ctx, b, p, code)
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyIntPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadOmitEmptyIntPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = appendInt(ctx, b, p, code)
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructPtrHeadIntPtrString:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadIntPtrString:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = append(b, '"')
- b = appendInt(ctx, b, p, code)
- b = append(b, '"')
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyIntPtrString:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadOmitEmptyIntPtrString:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendInt(ctx, b, p, code)
- b = append(b, '"')
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructPtrHeadUint:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadUint:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- b = appendUint(ctx, b, p+uintptr(code.Offset), code)
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyUint:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadOmitEmptyUint:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- u64 := ptrToUint64(p+uintptr(code.Offset), code.NumBitSize)
- v := u64 & ((1 << code.NumBitSize) - 1)
- if v == 0 {
- code = code.NextField
- } else {
- b = appendStructKey(ctx, code, b)
- b = appendUint(ctx, b, p+uintptr(code.Offset), code)
- b = appendComma(ctx, b)
- code = code.Next
- }
- case encoder.OpStructPtrHeadUintString:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadUintString:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendUint(ctx, b, p+uintptr(code.Offset), code)
- b = append(b, '"')
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyUintString:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadOmitEmptyUintString:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- u64 := ptrToUint64(p+uintptr(code.Offset), code.NumBitSize)
- v := u64 & ((1 << code.NumBitSize) - 1)
- if v == 0 {
- code = code.NextField
- } else {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendUint(ctx, b, p+uintptr(code.Offset), code)
- b = append(b, '"')
- b = appendComma(ctx, b)
- code = code.Next
- }
- case encoder.OpStructPtrHeadUintPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadUintPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = appendUint(ctx, b, p, code)
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyUintPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadOmitEmptyUintPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = appendUint(ctx, b, p, code)
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructPtrHeadUintPtrString:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadUintPtrString:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = append(b, '"')
- b = appendUint(ctx, b, p, code)
- b = append(b, '"')
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyUintPtrString:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadOmitEmptyUintPtrString:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendUint(ctx, b, p, code)
- b = append(b, '"')
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructPtrHeadFloat32:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadFloat32:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- b = appendFloat32(ctx, b, ptrToFloat32(p+uintptr(code.Offset)))
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyFloat32:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadOmitEmptyFloat32:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- v := ptrToFloat32(p + uintptr(code.Offset))
- if v == 0 {
- code = code.NextField
- } else {
- b = appendStructKey(ctx, code, b)
- b = appendFloat32(ctx, b, v)
- b = appendComma(ctx, b)
- code = code.Next
- }
- case encoder.OpStructPtrHeadFloat32String:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadFloat32String:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendFloat32(ctx, b, ptrToFloat32(p+uintptr(code.Offset)))
- b = append(b, '"')
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyFloat32String:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadOmitEmptyFloat32String:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- v := ptrToFloat32(p + uintptr(code.Offset))
- if v == 0 {
- code = code.NextField
- } else {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendFloat32(ctx, b, v)
- b = append(b, '"')
- b = appendComma(ctx, b)
- code = code.Next
- }
- case encoder.OpStructPtrHeadFloat32Ptr:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadFloat32Ptr:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = appendFloat32(ctx, b, ptrToFloat32(p))
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyFloat32Ptr:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadOmitEmptyFloat32Ptr:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = appendFloat32(ctx, b, ptrToFloat32(p))
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructPtrHeadFloat32PtrString:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadFloat32PtrString:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = append(b, '"')
- b = appendFloat32(ctx, b, ptrToFloat32(p))
- b = append(b, '"')
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyFloat32PtrString:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadOmitEmptyFloat32PtrString:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendFloat32(ctx, b, ptrToFloat32(p))
- b = append(b, '"')
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructPtrHeadFloat64:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadFloat64:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- v := ptrToFloat64(p + uintptr(code.Offset))
- if math.IsInf(v, 0) || math.IsNaN(v) {
- return nil, errUnsupportedFloat(v)
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- b = appendFloat64(ctx, b, v)
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyFloat64:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadOmitEmptyFloat64:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- v := ptrToFloat64(p + uintptr(code.Offset))
- if v == 0 {
- code = code.NextField
- } else {
- if math.IsInf(v, 0) || math.IsNaN(v) {
- return nil, errUnsupportedFloat(v)
- }
- b = appendStructKey(ctx, code, b)
- b = appendFloat64(ctx, b, v)
- b = appendComma(ctx, b)
- code = code.Next
- }
- case encoder.OpStructPtrHeadFloat64String:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadFloat64String:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- v := ptrToFloat64(p + uintptr(code.Offset))
- if math.IsInf(v, 0) || math.IsNaN(v) {
- return nil, errUnsupportedFloat(v)
- }
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendFloat64(ctx, b, v)
- b = append(b, '"')
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyFloat64String:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadOmitEmptyFloat64String:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- v := ptrToFloat64(p + uintptr(code.Offset))
- if v == 0 {
- code = code.NextField
- } else {
- if math.IsInf(v, 0) || math.IsNaN(v) {
- return nil, errUnsupportedFloat(v)
- }
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendFloat64(ctx, b, v)
- b = append(b, '"')
- b = appendComma(ctx, b)
- code = code.Next
- }
- case encoder.OpStructPtrHeadFloat64Ptr:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadFloat64Ptr:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- v := ptrToFloat64(p)
- if math.IsInf(v, 0) || math.IsNaN(v) {
- return nil, errUnsupportedFloat(v)
- }
- b = appendFloat64(ctx, b, v)
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyFloat64Ptr:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadOmitEmptyFloat64Ptr:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- v := ptrToFloat64(p)
- if math.IsInf(v, 0) || math.IsNaN(v) {
- return nil, errUnsupportedFloat(v)
- }
- b = appendFloat64(ctx, b, v)
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructPtrHeadFloat64PtrString:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadFloat64PtrString:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = append(b, '"')
- v := ptrToFloat64(p)
- if math.IsInf(v, 0) || math.IsNaN(v) {
- return nil, errUnsupportedFloat(v)
- }
- b = appendFloat64(ctx, b, v)
- b = append(b, '"')
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyFloat64PtrString:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadOmitEmptyFloat64PtrString:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- v := ptrToFloat64(p)
- if math.IsInf(v, 0) || math.IsNaN(v) {
- return nil, errUnsupportedFloat(v)
- }
- b = appendFloat64(ctx, b, v)
- b = append(b, '"')
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructPtrHeadString:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadString:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNull(ctx, b)
- b = appendComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- b = appendString(ctx, b, ptrToString(p+uintptr(code.Offset)))
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyString:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadOmitEmptyString:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- v := ptrToString(p + uintptr(code.Offset))
- if v == "" {
- code = code.NextField
- } else {
- b = appendStructKey(ctx, code, b)
- b = appendString(ctx, b, v)
- b = appendComma(ctx, b)
- code = code.Next
- }
- case encoder.OpStructPtrHeadStringString:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadStringString:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- b = appendString(ctx, b, string(appendString(ctx, []byte{}, ptrToString(p+uintptr(code.Offset)))))
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyStringString:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadOmitEmptyStringString:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- v := ptrToString(p + uintptr(code.Offset))
- if v == "" {
- code = code.NextField
- } else {
- b = appendStructKey(ctx, code, b)
- b = appendString(ctx, b, string(appendString(ctx, []byte{}, v)))
- b = appendComma(ctx, b)
- code = code.Next
- }
- case encoder.OpStructPtrHeadStringPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadStringPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = appendString(ctx, b, ptrToString(p))
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyStringPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadOmitEmptyStringPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = appendString(ctx, b, ptrToString(p))
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructPtrHeadStringPtrString:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadStringPtrString:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = appendString(ctx, b, string(appendString(ctx, []byte{}, ptrToString(p))))
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyStringPtrString:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadOmitEmptyStringPtrString:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = appendString(ctx, b, string(appendString(ctx, []byte{}, ptrToString(p))))
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructPtrHeadBool:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadBool:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- b = appendBool(ctx, b, ptrToBool(p+uintptr(code.Offset)))
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyBool:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadOmitEmptyBool:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- v := ptrToBool(p + uintptr(code.Offset))
- if v {
- b = appendStructKey(ctx, code, b)
- b = appendBool(ctx, b, v)
- b = appendComma(ctx, b)
- code = code.Next
- } else {
- code = code.NextField
- }
- case encoder.OpStructPtrHeadBoolString:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadBoolString:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendBool(ctx, b, ptrToBool(p+uintptr(code.Offset)))
- b = append(b, '"')
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyBoolString:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadOmitEmptyBoolString:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- v := ptrToBool(p + uintptr(code.Offset))
- if v {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendBool(ctx, b, v)
- b = append(b, '"')
- b = appendComma(ctx, b)
- code = code.Next
- } else {
- code = code.NextField
- }
- case encoder.OpStructPtrHeadBoolPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadBoolPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = appendBool(ctx, b, ptrToBool(p))
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyBoolPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadOmitEmptyBoolPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = appendBool(ctx, b, ptrToBool(p))
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructPtrHeadBoolPtrString:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadBoolPtrString:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = append(b, '"')
- b = appendBool(ctx, b, ptrToBool(p))
- b = append(b, '"')
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyBoolPtrString:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadOmitEmptyBoolPtrString:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendBool(ctx, b, ptrToBool(p))
- b = append(b, '"')
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructPtrHeadBytes:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadBytes:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- b = appendByteSlice(ctx, b, ptrToBytes(p+uintptr(code.Offset)))
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyBytes:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadOmitEmptyBytes:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- v := ptrToBytes(p + uintptr(code.Offset))
- if len(v) == 0 {
- code = code.NextField
- } else {
- b = appendStructKey(ctx, code, b)
- b = appendByteSlice(ctx, b, v)
- b = appendComma(ctx, b)
- code = code.Next
- }
- case encoder.OpStructPtrHeadBytesPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadBytesPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = appendByteSlice(ctx, b, ptrToBytes(p))
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyBytesPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadOmitEmptyBytesPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = appendByteSlice(ctx, b, ptrToBytes(p))
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructPtrHeadNumber:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadNumber:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- bb, err := appendNumber(ctx, b, ptrToNumber(p+uintptr(code.Offset)))
- if err != nil {
- return nil, err
- }
- b = appendComma(ctx, bb)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyNumber:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadOmitEmptyNumber:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- v := ptrToNumber(p + uintptr(code.Offset))
- if v == "" {
- code = code.NextField
- } else {
- b = appendStructKey(ctx, code, b)
- bb, err := appendNumber(ctx, b, v)
- if err != nil {
- return nil, err
- }
- b = appendComma(ctx, bb)
- code = code.Next
- }
- case encoder.OpStructPtrHeadNumberString:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadNumberString:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- bb, err := appendNumber(ctx, b, ptrToNumber(p+uintptr(code.Offset)))
- if err != nil {
- return nil, err
- }
- b = append(bb, '"')
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyNumberString:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadOmitEmptyNumberString:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- v := ptrToNumber(p + uintptr(code.Offset))
- if v == "" {
- code = code.NextField
- } else {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- bb, err := appendNumber(ctx, b, v)
- if err != nil {
- return nil, err
- }
- b = append(bb, '"')
- b = appendComma(ctx, b)
- code = code.Next
- }
- case encoder.OpStructPtrHeadNumberPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadNumberPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- bb, err := appendNumber(ctx, b, ptrToNumber(p))
- if err != nil {
- return nil, err
- }
- b = bb
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyNumberPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadOmitEmptyNumberPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- bb, err := appendNumber(ctx, b, ptrToNumber(p))
- if err != nil {
- return nil, err
- }
- b = appendComma(ctx, bb)
- }
- code = code.Next
- case encoder.OpStructPtrHeadNumberPtrString:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadNumberPtrString:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = append(b, '"')
- bb, err := appendNumber(ctx, b, ptrToNumber(p))
- if err != nil {
- return nil, err
- }
- b = append(bb, '"')
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyNumberPtrString:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadOmitEmptyNumberPtrString:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- bb, err := appendNumber(ctx, b, ptrToNumber(p))
- if err != nil {
- return nil, err
- }
- b = append(bb, '"')
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructPtrHeadArray, encoder.OpStructPtrHeadSlice:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadArray, encoder.OpStructHeadSlice:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- p += uintptr(code.Offset)
- code = code.Next
- store(ctxptr, code.Idx, p)
- case encoder.OpStructPtrHeadOmitEmptyArray:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadOmitEmptyArray:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- p += uintptr(code.Offset)
- b = appendStructKey(ctx, code, b)
- code = code.Next
- store(ctxptr, code.Idx, p)
- case encoder.OpStructPtrHeadOmitEmptySlice:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadOmitEmptySlice:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- p += uintptr(code.Offset)
- slice := ptrToSlice(p)
- if slice.Len == 0 {
- code = code.NextField
- } else {
- b = appendStructKey(ctx, code, b)
- code = code.Next
- store(ctxptr, code.Idx, p)
- }
- case encoder.OpStructPtrHeadArrayPtr, encoder.OpStructPtrHeadSlicePtr:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadArrayPtr, encoder.OpStructHeadSlicePtr:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p == 0 {
- b = appendNullComma(ctx, b)
- code = code.NextField
- } else {
- code = code.Next
- store(ctxptr, code.Idx, p)
- }
- case encoder.OpStructPtrHeadOmitEmptyArrayPtr, encoder.OpStructPtrHeadOmitEmptySlicePtr:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadOmitEmptyArrayPtr, encoder.OpStructHeadOmitEmptySlicePtr:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p == 0 {
- code = code.NextField
- } else {
- b = appendStructKey(ctx, code, b)
- code = code.Next
- store(ctxptr, code.Idx, p)
- }
- case encoder.OpStructPtrHeadMap:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadMap:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- if p != 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- p = ptrToPtr(p + uintptr(code.Offset))
- }
- code = code.Next
- store(ctxptr, code.Idx, p)
- case encoder.OpStructPtrHeadOmitEmptyMap:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadOmitEmptyMap:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- if p != 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- p = ptrToPtr(p + uintptr(code.Offset))
- }
- if maplen(ptrToUnsafePtr(p)) == 0 {
- code = code.NextField
- } else {
- b = appendStructKey(ctx, code, b)
- code = code.Next
- store(ctxptr, code.Idx, p)
- }
- case encoder.OpStructPtrHeadMapPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadMapPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- if p == 0 {
- b = appendNullComma(ctx, b)
- code = code.NextField
- break
- }
- p = ptrToPtr(p + uintptr(code.Offset))
- if p == 0 {
- b = appendNullComma(ctx, b)
- code = code.NextField
- } else {
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p, code.PtrNum)
- }
- code = code.Next
- store(ctxptr, code.Idx, p)
- }
- case encoder.OpStructPtrHeadOmitEmptyMapPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadOmitEmptyMapPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- if p == 0 {
- code = code.NextField
- break
- }
- p = ptrToPtr(p + uintptr(code.Offset))
- if p == 0 {
- code = code.NextField
- } else {
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p, code.PtrNum)
- }
- b = appendStructKey(ctx, code, b)
- code = code.Next
- store(ctxptr, code.Idx, p)
- }
- case encoder.OpStructPtrHeadMarshalJSON:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if (code.Flags & encoder.IndirectFlags) != 0 {
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadMarshalJSON:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- p += uintptr(code.Offset)
- if (code.Flags & encoder.IsNilableTypeFlags) != 0 {
- if (code.Flags&encoder.IndirectFlags) != 0 || code.Op == encoder.OpStructPtrHeadMarshalJSON {
- p = ptrToPtr(p)
- }
- }
- if p == 0 && (code.Flags&encoder.NilCheckFlags) != 0 {
- b = appendNull(ctx, b)
- } else {
- bb, err := appendMarshalJSON(ctx, code, b, ptrToInterface(code, p))
- if err != nil {
- return nil, err
- }
- b = bb
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyMarshalJSON:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if (code.Flags & encoder.IndirectFlags) != 0 {
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadOmitEmptyMarshalJSON:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- p += uintptr(code.Offset)
- if (code.Flags & encoder.IsNilableTypeFlags) != 0 {
- if (code.Flags&encoder.IndirectFlags) != 0 || code.Op == encoder.OpStructPtrHeadOmitEmptyMarshalJSON {
- p = ptrToPtr(p)
- }
- }
- iface := ptrToInterface(code, p)
- if (code.Flags&encoder.NilCheckFlags) != 0 && encoder.IsNilForMarshaler(iface) {
- code = code.NextField
- } else {
- b = appendStructKey(ctx, code, b)
- bb, err := appendMarshalJSON(ctx, code, b, iface)
- if err != nil {
- return nil, err
- }
- b = bb
- b = appendComma(ctx, b)
- code = code.Next
- }
- case encoder.OpStructPtrHeadMarshalJSONPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadMarshalJSONPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- bb, err := appendMarshalJSON(ctx, code, b, ptrToInterface(code, p))
- if err != nil {
- return nil, err
- }
- b = bb
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyMarshalJSONPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadOmitEmptyMarshalJSONPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- if p == 0 {
- code = code.NextField
- } else {
- b = appendStructKey(ctx, code, b)
- bb, err := appendMarshalJSON(ctx, code, b, ptrToInterface(code, p))
- if err != nil {
- return nil, err
- }
- b = bb
- b = appendComma(ctx, b)
- code = code.Next
- }
- case encoder.OpStructPtrHeadMarshalText:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if (code.Flags & encoder.IndirectFlags) != 0 {
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadMarshalText:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- p += uintptr(code.Offset)
- if (code.Flags & encoder.IsNilableTypeFlags) != 0 {
- if (code.Flags&encoder.IndirectFlags) != 0 || code.Op == encoder.OpStructPtrHeadMarshalText {
- p = ptrToPtr(p)
- }
- }
- if p == 0 && (code.Flags&encoder.NilCheckFlags) != 0 {
- b = appendNull(ctx, b)
- } else {
- bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p))
- if err != nil {
- return nil, err
- }
- b = bb
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyMarshalText:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if (code.Flags & encoder.IndirectFlags) != 0 {
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadOmitEmptyMarshalText:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- p += uintptr(code.Offset)
- if (code.Flags & encoder.IsNilableTypeFlags) != 0 {
- if (code.Flags&encoder.IndirectFlags) != 0 || code.Op == encoder.OpStructPtrHeadOmitEmptyMarshalText {
- p = ptrToPtr(p)
- }
- }
- if p == 0 && (code.Flags&encoder.NilCheckFlags) != 0 {
- code = code.NextField
- } else {
- b = appendStructKey(ctx, code, b)
- bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p))
- if err != nil {
- return nil, err
- }
- b = bb
- b = appendComma(ctx, b)
- code = code.Next
- }
- case encoder.OpStructPtrHeadMarshalTextPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadMarshalTextPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p))
- if err != nil {
- return nil, err
- }
- b = bb
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyMarshalTextPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadOmitEmptyMarshalTextPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- if p == 0 {
- code = code.NextField
- } else {
- b = appendStructKey(ctx, code, b)
- bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p))
- if err != nil {
- return nil, err
- }
- b = bb
- b = appendComma(ctx, b)
- code = code.Next
- }
- case encoder.OpStructField:
- if code.Flags&encoder.IsTaggedKeyFlags != 0 || code.Flags&encoder.AnonymousKeyFlags == 0 {
- b = appendStructKey(ctx, code, b)
- }
- p := load(ctxptr, code.Idx) + uintptr(code.Offset)
- code = code.Next
- store(ctxptr, code.Idx, p)
- case encoder.OpStructFieldOmitEmpty:
- p := load(ctxptr, code.Idx)
- p += uintptr(code.Offset)
- if ptrToPtr(p) == 0 && (code.Flags&encoder.IsNextOpPtrTypeFlags) != 0 {
- code = code.NextField
- } else {
- b = appendStructKey(ctx, code, b)
- code = code.Next
- store(ctxptr, code.Idx, p)
- }
- case encoder.OpStructFieldInt:
- p := load(ctxptr, code.Idx)
- b = appendStructKey(ctx, code, b)
- b = appendInt(ctx, b, p+uintptr(code.Offset), code)
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyInt:
- p := load(ctxptr, code.Idx)
- u64 := ptrToUint64(p+uintptr(code.Offset), code.NumBitSize)
- v := u64 & ((1 << code.NumBitSize) - 1)
- if v != 0 {
- b = appendStructKey(ctx, code, b)
- b = appendInt(ctx, b, p+uintptr(code.Offset), code)
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructFieldIntString:
- p := load(ctxptr, code.Idx)
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendInt(ctx, b, p+uintptr(code.Offset), code)
- b = append(b, '"')
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyIntString:
- p := load(ctxptr, code.Idx)
- u64 := ptrToUint64(p+uintptr(code.Offset), code.NumBitSize)
- v := u64 & ((1 << code.NumBitSize) - 1)
- if v != 0 {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendInt(ctx, b, p+uintptr(code.Offset), code)
- b = append(b, '"')
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructFieldIntPtr:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- b = appendStructKey(ctx, code, b)
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = appendInt(ctx, b, p, code)
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyIntPtr:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = appendInt(ctx, b, p, code)
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructFieldIntPtrString:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- b = appendStructKey(ctx, code, b)
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = append(b, '"')
- b = appendInt(ctx, b, p, code)
- b = append(b, '"')
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyIntPtrString:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendInt(ctx, b, p, code)
- b = append(b, '"')
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructFieldUint:
- p := load(ctxptr, code.Idx)
- b = appendStructKey(ctx, code, b)
- b = appendUint(ctx, b, p+uintptr(code.Offset), code)
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyUint:
- p := load(ctxptr, code.Idx)
- u64 := ptrToUint64(p+uintptr(code.Offset), code.NumBitSize)
- v := u64 & ((1 << code.NumBitSize) - 1)
- if v != 0 {
- b = appendStructKey(ctx, code, b)
- b = appendUint(ctx, b, p+uintptr(code.Offset), code)
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructFieldUintString:
- p := load(ctxptr, code.Idx)
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendUint(ctx, b, p+uintptr(code.Offset), code)
- b = append(b, '"')
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyUintString:
- p := load(ctxptr, code.Idx)
- u64 := ptrToUint64(p+uintptr(code.Offset), code.NumBitSize)
- v := u64 & ((1 << code.NumBitSize) - 1)
- if v != 0 {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendUint(ctx, b, p+uintptr(code.Offset), code)
- b = append(b, '"')
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructFieldUintPtr:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- b = appendStructKey(ctx, code, b)
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = appendUint(ctx, b, p, code)
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyUintPtr:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = appendUint(ctx, b, p, code)
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructFieldUintPtrString:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- b = appendStructKey(ctx, code, b)
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = append(b, '"')
- b = appendUint(ctx, b, p, code)
- b = append(b, '"')
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyUintPtrString:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendUint(ctx, b, p, code)
- b = append(b, '"')
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructFieldFloat32:
- p := load(ctxptr, code.Idx)
- b = appendStructKey(ctx, code, b)
- b = appendFloat32(ctx, b, ptrToFloat32(p+uintptr(code.Offset)))
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyFloat32:
- p := load(ctxptr, code.Idx)
- v := ptrToFloat32(p + uintptr(code.Offset))
- if v != 0 {
- b = appendStructKey(ctx, code, b)
- b = appendFloat32(ctx, b, v)
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructFieldFloat32String:
- p := load(ctxptr, code.Idx)
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendFloat32(ctx, b, ptrToFloat32(p+uintptr(code.Offset)))
- b = append(b, '"')
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyFloat32String:
- p := load(ctxptr, code.Idx)
- v := ptrToFloat32(p + uintptr(code.Offset))
- if v != 0 {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendFloat32(ctx, b, v)
- b = append(b, '"')
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructFieldFloat32Ptr:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- b = appendStructKey(ctx, code, b)
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = appendFloat32(ctx, b, ptrToFloat32(p))
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyFloat32Ptr:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = appendFloat32(ctx, b, ptrToFloat32(p))
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructFieldFloat32PtrString:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- b = appendStructKey(ctx, code, b)
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = append(b, '"')
- b = appendFloat32(ctx, b, ptrToFloat32(p))
- b = append(b, '"')
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyFloat32PtrString:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendFloat32(ctx, b, ptrToFloat32(p))
- b = append(b, '"')
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructFieldFloat64:
- p := load(ctxptr, code.Idx)
- b = appendStructKey(ctx, code, b)
- v := ptrToFloat64(p + uintptr(code.Offset))
- if math.IsInf(v, 0) || math.IsNaN(v) {
- return nil, errUnsupportedFloat(v)
- }
- b = appendFloat64(ctx, b, v)
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyFloat64:
- p := load(ctxptr, code.Idx)
- v := ptrToFloat64(p + uintptr(code.Offset))
- if v != 0 {
- if math.IsInf(v, 0) || math.IsNaN(v) {
- return nil, errUnsupportedFloat(v)
- }
- b = appendStructKey(ctx, code, b)
- b = appendFloat64(ctx, b, v)
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructFieldFloat64String:
- p := load(ctxptr, code.Idx)
- v := ptrToFloat64(p + uintptr(code.Offset))
- if math.IsInf(v, 0) || math.IsNaN(v) {
- return nil, errUnsupportedFloat(v)
- }
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendFloat64(ctx, b, v)
- b = append(b, '"')
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyFloat64String:
- p := load(ctxptr, code.Idx)
- v := ptrToFloat64(p + uintptr(code.Offset))
- if v != 0 {
- if math.IsInf(v, 0) || math.IsNaN(v) {
- return nil, errUnsupportedFloat(v)
- }
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendFloat64(ctx, b, v)
- b = append(b, '"')
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructFieldFloat64Ptr:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- b = appendStructKey(ctx, code, b)
- if p == 0 {
- b = appendNullComma(ctx, b)
- code = code.Next
- break
- }
- v := ptrToFloat64(p)
- if math.IsInf(v, 0) || math.IsNaN(v) {
- return nil, errUnsupportedFloat(v)
- }
- b = appendFloat64(ctx, b, v)
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyFloat64Ptr:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- v := ptrToFloat64(p)
- if math.IsInf(v, 0) || math.IsNaN(v) {
- return nil, errUnsupportedFloat(v)
- }
- b = appendFloat64(ctx, b, v)
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructFieldFloat64PtrString:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- b = appendStructKey(ctx, code, b)
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- v := ptrToFloat64(p)
- if math.IsInf(v, 0) || math.IsNaN(v) {
- return nil, errUnsupportedFloat(v)
- }
- b = append(b, '"')
- b = appendFloat64(ctx, b, v)
- b = append(b, '"')
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyFloat64PtrString:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- v := ptrToFloat64(p)
- if math.IsInf(v, 0) || math.IsNaN(v) {
- return nil, errUnsupportedFloat(v)
- }
- b = appendFloat64(ctx, b, v)
- b = append(b, '"')
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructFieldString:
- p := load(ctxptr, code.Idx)
- b = appendStructKey(ctx, code, b)
- b = appendString(ctx, b, ptrToString(p+uintptr(code.Offset)))
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyString:
- p := load(ctxptr, code.Idx)
- v := ptrToString(p + uintptr(code.Offset))
- if v != "" {
- b = appendStructKey(ctx, code, b)
- b = appendString(ctx, b, v)
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructFieldStringString:
- p := load(ctxptr, code.Idx)
- s := ptrToString(p + uintptr(code.Offset))
- b = appendStructKey(ctx, code, b)
- b = appendString(ctx, b, string(appendString(ctx, []byte{}, s)))
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyStringString:
- p := load(ctxptr, code.Idx)
- v := ptrToString(p + uintptr(code.Offset))
- if v != "" {
- b = appendStructKey(ctx, code, b)
- b = appendString(ctx, b, string(appendString(ctx, []byte{}, v)))
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructFieldStringPtr:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- b = appendStructKey(ctx, code, b)
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = appendString(ctx, b, ptrToString(p))
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyStringPtr:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = appendString(ctx, b, ptrToString(p))
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructFieldStringPtrString:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- b = appendStructKey(ctx, code, b)
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = appendString(ctx, b, string(appendString(ctx, []byte{}, ptrToString(p))))
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyStringPtrString:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = appendString(ctx, b, string(appendString(ctx, []byte{}, ptrToString(p))))
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructFieldBool:
- p := load(ctxptr, code.Idx)
- b = appendStructKey(ctx, code, b)
- b = appendBool(ctx, b, ptrToBool(p+uintptr(code.Offset)))
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyBool:
- p := load(ctxptr, code.Idx)
- v := ptrToBool(p + uintptr(code.Offset))
- if v {
- b = appendStructKey(ctx, code, b)
- b = appendBool(ctx, b, v)
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructFieldBoolString:
- p := load(ctxptr, code.Idx)
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendBool(ctx, b, ptrToBool(p+uintptr(code.Offset)))
- b = append(b, '"')
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyBoolString:
- p := load(ctxptr, code.Idx)
- v := ptrToBool(p + uintptr(code.Offset))
- if v {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendBool(ctx, b, v)
- b = append(b, '"')
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructFieldBoolPtr:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- b = appendStructKey(ctx, code, b)
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = appendBool(ctx, b, ptrToBool(p))
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyBoolPtr:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = appendBool(ctx, b, ptrToBool(p))
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructFieldBoolPtrString:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- b = appendStructKey(ctx, code, b)
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = append(b, '"')
- b = appendBool(ctx, b, ptrToBool(p))
- b = append(b, '"')
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyBoolPtrString:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendBool(ctx, b, ptrToBool(p))
- b = append(b, '"')
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructFieldBytes:
- p := load(ctxptr, code.Idx)
- b = appendStructKey(ctx, code, b)
- b = appendByteSlice(ctx, b, ptrToBytes(p+uintptr(code.Offset)))
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyBytes:
- p := load(ctxptr, code.Idx)
- v := ptrToBytes(p + uintptr(code.Offset))
- if len(v) > 0 {
- b = appendStructKey(ctx, code, b)
- b = appendByteSlice(ctx, b, v)
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructFieldBytesPtr:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- b = appendStructKey(ctx, code, b)
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = appendByteSlice(ctx, b, ptrToBytes(p))
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyBytesPtr:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = appendByteSlice(ctx, b, ptrToBytes(p))
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructFieldNumber:
- p := load(ctxptr, code.Idx)
- b = appendStructKey(ctx, code, b)
- bb, err := appendNumber(ctx, b, ptrToNumber(p+uintptr(code.Offset)))
- if err != nil {
- return nil, err
- }
- b = appendComma(ctx, bb)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyNumber:
- p := load(ctxptr, code.Idx)
- v := ptrToNumber(p + uintptr(code.Offset))
- if v != "" {
- b = appendStructKey(ctx, code, b)
- bb, err := appendNumber(ctx, b, v)
- if err != nil {
- return nil, err
- }
- b = appendComma(ctx, bb)
- }
- code = code.Next
- case encoder.OpStructFieldNumberString:
- p := load(ctxptr, code.Idx)
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- bb, err := appendNumber(ctx, b, ptrToNumber(p+uintptr(code.Offset)))
- if err != nil {
- return nil, err
- }
- b = append(bb, '"')
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyNumberString:
- p := load(ctxptr, code.Idx)
- v := ptrToNumber(p + uintptr(code.Offset))
- if v != "" {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- bb, err := appendNumber(ctx, b, v)
- if err != nil {
- return nil, err
- }
- b = append(bb, '"')
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructFieldNumberPtr:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- b = appendStructKey(ctx, code, b)
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- bb, err := appendNumber(ctx, b, ptrToNumber(p))
- if err != nil {
- return nil, err
- }
- b = bb
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyNumberPtr:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- bb, err := appendNumber(ctx, b, ptrToNumber(p))
- if err != nil {
- return nil, err
- }
- b = appendComma(ctx, bb)
- }
- code = code.Next
- case encoder.OpStructFieldNumberPtrString:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- b = appendStructKey(ctx, code, b)
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = append(b, '"')
- bb, err := appendNumber(ctx, b, ptrToNumber(p))
- if err != nil {
- return nil, err
- }
- b = append(bb, '"')
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyNumberPtrString:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- bb, err := appendNumber(ctx, b, ptrToNumber(p))
- if err != nil {
- return nil, err
- }
- b = append(bb, '"')
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructFieldMarshalJSON:
- p := load(ctxptr, code.Idx)
- b = appendStructKey(ctx, code, b)
- p += uintptr(code.Offset)
- if (code.Flags & encoder.IsNilableTypeFlags) != 0 {
- p = ptrToPtr(p)
- }
- if p == 0 && (code.Flags&encoder.NilCheckFlags) != 0 {
- b = appendNull(ctx, b)
- } else {
- bb, err := appendMarshalJSON(ctx, code, b, ptrToInterface(code, p))
- if err != nil {
- return nil, err
- }
- b = bb
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyMarshalJSON:
- p := load(ctxptr, code.Idx)
- p += uintptr(code.Offset)
- if (code.Flags & encoder.IsNilableTypeFlags) != 0 {
- p = ptrToPtr(p)
- }
- if p == 0 && (code.Flags&encoder.NilCheckFlags) != 0 {
- code = code.NextField
- break
- }
- iface := ptrToInterface(code, p)
- if (code.Flags&encoder.NilCheckFlags) != 0 && encoder.IsNilForMarshaler(iface) {
- code = code.NextField
- break
- }
- b = appendStructKey(ctx, code, b)
- bb, err := appendMarshalJSON(ctx, code, b, iface)
- if err != nil {
- return nil, err
- }
- b = appendComma(ctx, bb)
- code = code.Next
- case encoder.OpStructFieldMarshalJSONPtr:
- p := load(ctxptr, code.Idx)
- b = appendStructKey(ctx, code, b)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- bb, err := appendMarshalJSON(ctx, code, b, ptrToInterface(code, p))
- if err != nil {
- return nil, err
- }
- b = bb
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyMarshalJSONPtr:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- bb, err := appendMarshalJSON(ctx, code, b, ptrToInterface(code, p))
- if err != nil {
- return nil, err
- }
- b = appendComma(ctx, bb)
- }
- code = code.Next
- case encoder.OpStructFieldMarshalText:
- p := load(ctxptr, code.Idx)
- b = appendStructKey(ctx, code, b)
- p += uintptr(code.Offset)
- if (code.Flags & encoder.IsNilableTypeFlags) != 0 {
- p = ptrToPtr(p)
- }
- if p == 0 && (code.Flags&encoder.NilCheckFlags) != 0 {
- b = appendNull(ctx, b)
- } else {
- bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p))
- if err != nil {
- return nil, err
- }
- b = bb
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyMarshalText:
- p := load(ctxptr, code.Idx)
- p += uintptr(code.Offset)
- if (code.Flags & encoder.IsNilableTypeFlags) != 0 {
- p = ptrToPtr(p)
- }
- if p == 0 && (code.Flags&encoder.NilCheckFlags) != 0 {
- code = code.NextField
- break
- }
- b = appendStructKey(ctx, code, b)
- bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p))
- if err != nil {
- return nil, err
- }
- b = appendComma(ctx, bb)
- code = code.Next
- case encoder.OpStructFieldMarshalTextPtr:
- p := load(ctxptr, code.Idx)
- b = appendStructKey(ctx, code, b)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p))
- if err != nil {
- return nil, err
- }
- b = bb
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyMarshalTextPtr:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p))
- if err != nil {
- return nil, err
- }
- b = appendComma(ctx, bb)
- }
- code = code.Next
- case encoder.OpStructFieldArray:
- b = appendStructKey(ctx, code, b)
- p := load(ctxptr, code.Idx)
- p += uintptr(code.Offset)
- code = code.Next
- store(ctxptr, code.Idx, p)
- case encoder.OpStructFieldOmitEmptyArray:
- b = appendStructKey(ctx, code, b)
- p := load(ctxptr, code.Idx)
- p += uintptr(code.Offset)
- code = code.Next
- store(ctxptr, code.Idx, p)
- case encoder.OpStructFieldArrayPtr:
- b = appendStructKey(ctx, code, b)
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- code = code.Next
- store(ctxptr, code.Idx, p)
- case encoder.OpStructFieldOmitEmptyArrayPtr:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- code = code.Next
- store(ctxptr, code.Idx, p)
- } else {
- code = code.NextField
- }
- case encoder.OpStructFieldSlice:
- b = appendStructKey(ctx, code, b)
- p := load(ctxptr, code.Idx)
- p += uintptr(code.Offset)
- code = code.Next
- store(ctxptr, code.Idx, p)
- case encoder.OpStructFieldOmitEmptySlice:
- p := load(ctxptr, code.Idx)
- p += uintptr(code.Offset)
- slice := ptrToSlice(p)
- if slice.Len == 0 {
- code = code.NextField
- } else {
- b = appendStructKey(ctx, code, b)
- code = code.Next
- store(ctxptr, code.Idx, p)
- }
- case encoder.OpStructFieldSlicePtr:
- b = appendStructKey(ctx, code, b)
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- code = code.Next
- store(ctxptr, code.Idx, p)
- case encoder.OpStructFieldOmitEmptySlicePtr:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- code = code.Next
- store(ctxptr, code.Idx, p)
- } else {
- code = code.NextField
- }
- case encoder.OpStructFieldMap:
- b = appendStructKey(ctx, code, b)
- p := load(ctxptr, code.Idx)
- p = ptrToPtr(p + uintptr(code.Offset))
- code = code.Next
- store(ctxptr, code.Idx, p)
- case encoder.OpStructFieldOmitEmptyMap:
- p := load(ctxptr, code.Idx)
- p = ptrToPtr(p + uintptr(code.Offset))
- if p == 0 || maplen(ptrToUnsafePtr(p)) == 0 {
- code = code.NextField
- } else {
- b = appendStructKey(ctx, code, b)
- code = code.Next
- store(ctxptr, code.Idx, p)
- }
- case encoder.OpStructFieldMapPtr:
- b = appendStructKey(ctx, code, b)
- p := load(ctxptr, code.Idx)
- p = ptrToPtr(p + uintptr(code.Offset))
- if p != 0 {
- p = ptrToNPtr(p, code.PtrNum)
- }
- code = code.Next
- store(ctxptr, code.Idx, p)
- case encoder.OpStructFieldOmitEmptyMapPtr:
- p := load(ctxptr, code.Idx)
- p = ptrToPtr(p + uintptr(code.Offset))
- if p != 0 {
- p = ptrToNPtr(p, code.PtrNum)
- }
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- code = code.Next
- store(ctxptr, code.Idx, p)
- } else {
- code = code.NextField
- }
- case encoder.OpStructFieldStruct:
- b = appendStructKey(ctx, code, b)
- p := load(ctxptr, code.Idx)
- p += uintptr(code.Offset)
- code = code.Next
- store(ctxptr, code.Idx, p)
- case encoder.OpStructFieldOmitEmptyStruct:
- p := load(ctxptr, code.Idx)
- p += uintptr(code.Offset)
- if ptrToPtr(p) == 0 && (code.Flags&encoder.IsNextOpPtrTypeFlags) != 0 {
- code = code.NextField
- } else {
- b = appendStructKey(ctx, code, b)
- code = code.Next
- store(ctxptr, code.Idx, p)
- }
- case encoder.OpStructEnd:
- b = appendStructEndSkipLast(ctx, code, b)
- code = code.Next
- case encoder.OpStructEndInt:
- p := load(ctxptr, code.Idx)
- b = appendStructKey(ctx, code, b)
- b = appendInt(ctx, b, p+uintptr(code.Offset), code)
- b = appendStructEnd(ctx, code, b)
- code = code.Next
- case encoder.OpStructEndOmitEmptyInt:
- p := load(ctxptr, code.Idx)
- u64 := ptrToUint64(p+uintptr(code.Offset), code.NumBitSize)
- v := u64 & ((1 << code.NumBitSize) - 1)
- if v != 0 {
- b = appendStructKey(ctx, code, b)
- b = appendInt(ctx, b, p+uintptr(code.Offset), code)
- b = appendStructEnd(ctx, code, b)
- } else {
- b = appendStructEndSkipLast(ctx, code, b)
- }
- code = code.Next
- case encoder.OpStructEndIntString:
- p := load(ctxptr, code.Idx)
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendInt(ctx, b, p+uintptr(code.Offset), code)
- b = append(b, '"')
- b = appendStructEnd(ctx, code, b)
- code = code.Next
- case encoder.OpStructEndOmitEmptyIntString:
- p := load(ctxptr, code.Idx)
- u64 := ptrToUint64(p+uintptr(code.Offset), code.NumBitSize)
- v := u64 & ((1 << code.NumBitSize) - 1)
- if v != 0 {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendInt(ctx, b, p+uintptr(code.Offset), code)
- b = append(b, '"')
- b = appendStructEnd(ctx, code, b)
- } else {
- b = appendStructEndSkipLast(ctx, code, b)
- }
- code = code.Next
- case encoder.OpStructEndIntPtr:
- b = appendStructKey(ctx, code, b)
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = appendInt(ctx, b, p, code)
- }
- b = appendStructEnd(ctx, code, b)
- code = code.Next
- case encoder.OpStructEndOmitEmptyIntPtr:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = appendInt(ctx, b, p, code)
- b = appendStructEnd(ctx, code, b)
- } else {
- b = appendStructEndSkipLast(ctx, code, b)
- }
- code = code.Next
- case encoder.OpStructEndIntPtrString:
- b = appendStructKey(ctx, code, b)
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = append(b, '"')
- b = appendInt(ctx, b, p, code)
- b = append(b, '"')
- }
- b = appendStructEnd(ctx, code, b)
- code = code.Next
- case encoder.OpStructEndOmitEmptyIntPtrString:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendInt(ctx, b, p, code)
- b = append(b, '"')
- b = appendStructEnd(ctx, code, b)
- } else {
- b = appendStructEndSkipLast(ctx, code, b)
- }
- code = code.Next
- case encoder.OpStructEndUint:
- p := load(ctxptr, code.Idx)
- b = appendStructKey(ctx, code, b)
- b = appendUint(ctx, b, p+uintptr(code.Offset), code)
- b = appendStructEnd(ctx, code, b)
- code = code.Next
- case encoder.OpStructEndOmitEmptyUint:
- p := load(ctxptr, code.Idx)
- u64 := ptrToUint64(p+uintptr(code.Offset), code.NumBitSize)
- v := u64 & ((1 << code.NumBitSize) - 1)
- if v != 0 {
- b = appendStructKey(ctx, code, b)
- b = appendUint(ctx, b, p+uintptr(code.Offset), code)
- b = appendStructEnd(ctx, code, b)
- } else {
- b = appendStructEndSkipLast(ctx, code, b)
- }
- code = code.Next
- case encoder.OpStructEndUintString:
- p := load(ctxptr, code.Idx)
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendUint(ctx, b, p+uintptr(code.Offset), code)
- b = append(b, '"')
- b = appendStructEnd(ctx, code, b)
- code = code.Next
- case encoder.OpStructEndOmitEmptyUintString:
- p := load(ctxptr, code.Idx)
- u64 := ptrToUint64(p+uintptr(code.Offset), code.NumBitSize)
- v := u64 & ((1 << code.NumBitSize) - 1)
- if v != 0 {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendUint(ctx, b, p+uintptr(code.Offset), code)
- b = append(b, '"')
- b = appendStructEnd(ctx, code, b)
- } else {
- b = appendStructEndSkipLast(ctx, code, b)
- }
- code = code.Next
- case encoder.OpStructEndUintPtr:
- b = appendStructKey(ctx, code, b)
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = appendUint(ctx, b, p, code)
- }
- b = appendStructEnd(ctx, code, b)
- code = code.Next
- case encoder.OpStructEndOmitEmptyUintPtr:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = appendUint(ctx, b, p, code)
- b = appendStructEnd(ctx, code, b)
- } else {
- b = appendStructEndSkipLast(ctx, code, b)
- }
- code = code.Next
- case encoder.OpStructEndUintPtrString:
- b = appendStructKey(ctx, code, b)
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = append(b, '"')
- b = appendUint(ctx, b, p, code)
- b = append(b, '"')
- }
- b = appendStructEnd(ctx, code, b)
- code = code.Next
- case encoder.OpStructEndOmitEmptyUintPtrString:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendUint(ctx, b, p, code)
- b = append(b, '"')
- b = appendStructEnd(ctx, code, b)
- } else {
- b = appendStructEndSkipLast(ctx, code, b)
- }
- code = code.Next
- case encoder.OpStructEndFloat32:
- p := load(ctxptr, code.Idx)
- b = appendStructKey(ctx, code, b)
- b = appendFloat32(ctx, b, ptrToFloat32(p+uintptr(code.Offset)))
- b = appendStructEnd(ctx, code, b)
- code = code.Next
- case encoder.OpStructEndOmitEmptyFloat32:
- p := load(ctxptr, code.Idx)
- v := ptrToFloat32(p + uintptr(code.Offset))
- if v != 0 {
- b = appendStructKey(ctx, code, b)
- b = appendFloat32(ctx, b, v)
- b = appendStructEnd(ctx, code, b)
- } else {
- b = appendStructEndSkipLast(ctx, code, b)
- }
- code = code.Next
- case encoder.OpStructEndFloat32String:
- p := load(ctxptr, code.Idx)
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendFloat32(ctx, b, ptrToFloat32(p+uintptr(code.Offset)))
- b = append(b, '"')
- b = appendStructEnd(ctx, code, b)
- code = code.Next
- case encoder.OpStructEndOmitEmptyFloat32String:
- p := load(ctxptr, code.Idx)
- v := ptrToFloat32(p + uintptr(code.Offset))
- if v != 0 {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendFloat32(ctx, b, v)
- b = append(b, '"')
- b = appendStructEnd(ctx, code, b)
- } else {
- b = appendStructEndSkipLast(ctx, code, b)
- }
- code = code.Next
- case encoder.OpStructEndFloat32Ptr:
- b = appendStructKey(ctx, code, b)
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = appendFloat32(ctx, b, ptrToFloat32(p))
- }
- b = appendStructEnd(ctx, code, b)
- code = code.Next
- case encoder.OpStructEndOmitEmptyFloat32Ptr:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = appendFloat32(ctx, b, ptrToFloat32(p))
- b = appendStructEnd(ctx, code, b)
- } else {
- b = appendStructEndSkipLast(ctx, code, b)
- }
- code = code.Next
- case encoder.OpStructEndFloat32PtrString:
- b = appendStructKey(ctx, code, b)
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = append(b, '"')
- b = appendFloat32(ctx, b, ptrToFloat32(p))
- b = append(b, '"')
- }
- b = appendStructEnd(ctx, code, b)
- code = code.Next
- case encoder.OpStructEndOmitEmptyFloat32PtrString:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendFloat32(ctx, b, ptrToFloat32(p))
- b = append(b, '"')
- b = appendStructEnd(ctx, code, b)
- } else {
- b = appendStructEndSkipLast(ctx, code, b)
- }
- code = code.Next
- case encoder.OpStructEndFloat64:
- p := load(ctxptr, code.Idx)
- v := ptrToFloat64(p + uintptr(code.Offset))
- if math.IsInf(v, 0) || math.IsNaN(v) {
- return nil, errUnsupportedFloat(v)
- }
- b = appendStructKey(ctx, code, b)
- b = appendFloat64(ctx, b, v)
- b = appendStructEnd(ctx, code, b)
- code = code.Next
- case encoder.OpStructEndOmitEmptyFloat64:
- p := load(ctxptr, code.Idx)
- v := ptrToFloat64(p + uintptr(code.Offset))
- if v != 0 {
- if math.IsInf(v, 0) || math.IsNaN(v) {
- return nil, errUnsupportedFloat(v)
- }
- b = appendStructKey(ctx, code, b)
- b = appendFloat64(ctx, b, v)
- b = appendStructEnd(ctx, code, b)
- } else {
- b = appendStructEndSkipLast(ctx, code, b)
- }
- code = code.Next
- case encoder.OpStructEndFloat64String:
- p := load(ctxptr, code.Idx)
- v := ptrToFloat64(p + uintptr(code.Offset))
- if math.IsInf(v, 0) || math.IsNaN(v) {
- return nil, errUnsupportedFloat(v)
- }
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendFloat64(ctx, b, v)
- b = append(b, '"')
- b = appendStructEnd(ctx, code, b)
- code = code.Next
- case encoder.OpStructEndOmitEmptyFloat64String:
- p := load(ctxptr, code.Idx)
- v := ptrToFloat64(p + uintptr(code.Offset))
- if v != 0 {
- if math.IsInf(v, 0) || math.IsNaN(v) {
- return nil, errUnsupportedFloat(v)
- }
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendFloat64(ctx, b, v)
- b = append(b, '"')
- b = appendStructEnd(ctx, code, b)
- } else {
- b = appendStructEndSkipLast(ctx, code, b)
- }
- code = code.Next
- case encoder.OpStructEndFloat64Ptr:
- b = appendStructKey(ctx, code, b)
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p == 0 {
- b = appendNull(ctx, b)
- b = appendStructEnd(ctx, code, b)
- code = code.Next
- break
- }
- v := ptrToFloat64(p)
- if math.IsInf(v, 0) || math.IsNaN(v) {
- return nil, errUnsupportedFloat(v)
- }
- b = appendFloat64(ctx, b, v)
- b = appendStructEnd(ctx, code, b)
- code = code.Next
- case encoder.OpStructEndOmitEmptyFloat64Ptr:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- v := ptrToFloat64(p)
- if math.IsInf(v, 0) || math.IsNaN(v) {
- return nil, errUnsupportedFloat(v)
- }
- b = appendFloat64(ctx, b, v)
- b = appendStructEnd(ctx, code, b)
- } else {
- b = appendStructEndSkipLast(ctx, code, b)
- }
- code = code.Next
- case encoder.OpStructEndFloat64PtrString:
- b = appendStructKey(ctx, code, b)
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = append(b, '"')
- v := ptrToFloat64(p)
- if math.IsInf(v, 0) || math.IsNaN(v) {
- return nil, errUnsupportedFloat(v)
- }
- b = appendFloat64(ctx, b, v)
- b = append(b, '"')
- }
- b = appendStructEnd(ctx, code, b)
- code = code.Next
- case encoder.OpStructEndOmitEmptyFloat64PtrString:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- v := ptrToFloat64(p)
- if math.IsInf(v, 0) || math.IsNaN(v) {
- return nil, errUnsupportedFloat(v)
- }
- b = append(b, '"')
- b = appendFloat64(ctx, b, v)
- b = append(b, '"')
- b = appendStructEnd(ctx, code, b)
- } else {
- b = appendStructEndSkipLast(ctx, code, b)
- }
- code = code.Next
- case encoder.OpStructEndString:
- p := load(ctxptr, code.Idx)
- b = appendStructKey(ctx, code, b)
- b = appendString(ctx, b, ptrToString(p+uintptr(code.Offset)))
- b = appendStructEnd(ctx, code, b)
- code = code.Next
- case encoder.OpStructEndOmitEmptyString:
- p := load(ctxptr, code.Idx)
- v := ptrToString(p + uintptr(code.Offset))
- if v != "" {
- b = appendStructKey(ctx, code, b)
- b = appendString(ctx, b, v)
- b = appendStructEnd(ctx, code, b)
- } else {
- b = appendStructEndSkipLast(ctx, code, b)
- }
- code = code.Next
- case encoder.OpStructEndStringString:
- p := load(ctxptr, code.Idx)
- b = appendStructKey(ctx, code, b)
- s := ptrToString(p + uintptr(code.Offset))
- b = appendString(ctx, b, string(appendString(ctx, []byte{}, s)))
- b = appendStructEnd(ctx, code, b)
- code = code.Next
- case encoder.OpStructEndOmitEmptyStringString:
- p := load(ctxptr, code.Idx)
- v := ptrToString(p + uintptr(code.Offset))
- if v != "" {
- b = appendStructKey(ctx, code, b)
- b = appendString(ctx, b, string(appendString(ctx, []byte{}, v)))
- b = appendStructEnd(ctx, code, b)
- } else {
- b = appendStructEndSkipLast(ctx, code, b)
- }
- code = code.Next
- case encoder.OpStructEndStringPtr:
- b = appendStructKey(ctx, code, b)
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = appendString(ctx, b, ptrToString(p))
- }
- b = appendStructEnd(ctx, code, b)
- code = code.Next
- case encoder.OpStructEndOmitEmptyStringPtr:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = appendString(ctx, b, ptrToString(p))
- b = appendStructEnd(ctx, code, b)
- } else {
- b = appendStructEndSkipLast(ctx, code, b)
- }
- code = code.Next
- case encoder.OpStructEndStringPtrString:
- b = appendStructKey(ctx, code, b)
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = appendString(ctx, b, string(appendString(ctx, []byte{}, ptrToString(p))))
- }
- b = appendStructEnd(ctx, code, b)
- code = code.Next
- case encoder.OpStructEndOmitEmptyStringPtrString:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = appendString(ctx, b, string(appendString(ctx, []byte{}, ptrToString(p))))
- b = appendStructEnd(ctx, code, b)
- } else {
- b = appendStructEndSkipLast(ctx, code, b)
- }
- code = code.Next
- case encoder.OpStructEndBool:
- p := load(ctxptr, code.Idx)
- b = appendStructKey(ctx, code, b)
- b = appendBool(ctx, b, ptrToBool(p+uintptr(code.Offset)))
- b = appendStructEnd(ctx, code, b)
- code = code.Next
- case encoder.OpStructEndOmitEmptyBool:
- p := load(ctxptr, code.Idx)
- v := ptrToBool(p + uintptr(code.Offset))
- if v {
- b = appendStructKey(ctx, code, b)
- b = appendBool(ctx, b, v)
- b = appendStructEnd(ctx, code, b)
- } else {
- b = appendStructEndSkipLast(ctx, code, b)
- }
- code = code.Next
- case encoder.OpStructEndBoolString:
- p := load(ctxptr, code.Idx)
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendBool(ctx, b, ptrToBool(p+uintptr(code.Offset)))
- b = append(b, '"')
- b = appendStructEnd(ctx, code, b)
- code = code.Next
- case encoder.OpStructEndOmitEmptyBoolString:
- p := load(ctxptr, code.Idx)
- v := ptrToBool(p + uintptr(code.Offset))
- if v {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendBool(ctx, b, v)
- b = append(b, '"')
- b = appendStructEnd(ctx, code, b)
- } else {
- b = appendStructEndSkipLast(ctx, code, b)
- }
- code = code.Next
- case encoder.OpStructEndBoolPtr:
- b = appendStructKey(ctx, code, b)
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = appendBool(ctx, b, ptrToBool(p))
- }
- b = appendStructEnd(ctx, code, b)
- code = code.Next
- case encoder.OpStructEndOmitEmptyBoolPtr:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = appendBool(ctx, b, ptrToBool(p))
- b = appendStructEnd(ctx, code, b)
- } else {
- b = appendStructEndSkipLast(ctx, code, b)
- }
- code = code.Next
- case encoder.OpStructEndBoolPtrString:
- b = appendStructKey(ctx, code, b)
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = append(b, '"')
- b = appendBool(ctx, b, ptrToBool(p))
- b = append(b, '"')
- }
- b = appendStructEnd(ctx, code, b)
- code = code.Next
- case encoder.OpStructEndOmitEmptyBoolPtrString:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendBool(ctx, b, ptrToBool(p))
- b = append(b, '"')
- b = appendStructEnd(ctx, code, b)
- } else {
- b = appendStructEndSkipLast(ctx, code, b)
- }
- code = code.Next
- case encoder.OpStructEndBytes:
- p := load(ctxptr, code.Idx)
- b = appendStructKey(ctx, code, b)
- b = appendByteSlice(ctx, b, ptrToBytes(p+uintptr(code.Offset)))
- b = appendStructEnd(ctx, code, b)
- code = code.Next
- case encoder.OpStructEndOmitEmptyBytes:
- p := load(ctxptr, code.Idx)
- v := ptrToBytes(p + uintptr(code.Offset))
- if len(v) > 0 {
- b = appendStructKey(ctx, code, b)
- b = appendByteSlice(ctx, b, v)
- b = appendStructEnd(ctx, code, b)
- } else {
- b = appendStructEndSkipLast(ctx, code, b)
- }
- code = code.Next
- case encoder.OpStructEndBytesPtr:
- b = appendStructKey(ctx, code, b)
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = appendByteSlice(ctx, b, ptrToBytes(p))
- }
- b = appendStructEnd(ctx, code, b)
- code = code.Next
- case encoder.OpStructEndOmitEmptyBytesPtr:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = appendByteSlice(ctx, b, ptrToBytes(p))
- b = appendStructEnd(ctx, code, b)
- } else {
- b = appendStructEndSkipLast(ctx, code, b)
- }
- code = code.Next
- case encoder.OpStructEndNumber:
- p := load(ctxptr, code.Idx)
- b = appendStructKey(ctx, code, b)
- bb, err := appendNumber(ctx, b, ptrToNumber(p+uintptr(code.Offset)))
- if err != nil {
- return nil, err
- }
- b = appendStructEnd(ctx, code, bb)
- code = code.Next
- case encoder.OpStructEndOmitEmptyNumber:
- p := load(ctxptr, code.Idx)
- v := ptrToNumber(p + uintptr(code.Offset))
- if v != "" {
- b = appendStructKey(ctx, code, b)
- bb, err := appendNumber(ctx, b, v)
- if err != nil {
- return nil, err
- }
- b = appendStructEnd(ctx, code, bb)
- } else {
- b = appendStructEndSkipLast(ctx, code, b)
- }
- code = code.Next
- case encoder.OpStructEndNumberString:
- p := load(ctxptr, code.Idx)
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- bb, err := appendNumber(ctx, b, ptrToNumber(p+uintptr(code.Offset)))
- if err != nil {
- return nil, err
- }
- b = append(bb, '"')
- b = appendStructEnd(ctx, code, b)
- code = code.Next
- case encoder.OpStructEndOmitEmptyNumberString:
- p := load(ctxptr, code.Idx)
- v := ptrToNumber(p + uintptr(code.Offset))
- if v != "" {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- bb, err := appendNumber(ctx, b, v)
- if err != nil {
- return nil, err
- }
- b = append(bb, '"')
- b = appendStructEnd(ctx, code, b)
- } else {
- b = appendStructEndSkipLast(ctx, code, b)
- }
- code = code.Next
- case encoder.OpStructEndNumberPtr:
- b = appendStructKey(ctx, code, b)
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- bb, err := appendNumber(ctx, b, ptrToNumber(p))
- if err != nil {
- return nil, err
- }
- b = bb
- }
- b = appendStructEnd(ctx, code, b)
- code = code.Next
- case encoder.OpStructEndOmitEmptyNumberPtr:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- bb, err := appendNumber(ctx, b, ptrToNumber(p))
- if err != nil {
- return nil, err
- }
- b = appendStructEnd(ctx, code, bb)
- } else {
- b = appendStructEndSkipLast(ctx, code, b)
- }
- code = code.Next
- case encoder.OpStructEndNumberPtrString:
- b = appendStructKey(ctx, code, b)
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = append(b, '"')
- bb, err := appendNumber(ctx, b, ptrToNumber(p))
- if err != nil {
- return nil, err
- }
- b = append(bb, '"')
- }
- b = appendStructEnd(ctx, code, b)
- code = code.Next
- case encoder.OpStructEndOmitEmptyNumberPtrString:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- bb, err := appendNumber(ctx, b, ptrToNumber(p))
- if err != nil {
- return nil, err
- }
- b = append(bb, '"')
- b = appendStructEnd(ctx, code, b)
- } else {
- b = appendStructEndSkipLast(ctx, code, b)
- }
- code = code.Next
- case encoder.OpEnd:
- goto END
- }
- }
-END:
- return b, nil
-}
diff --git a/vendor/github.com/goccy/go-json/internal/encoder/vm_indent/debug_vm.go b/vendor/github.com/goccy/go-json/internal/encoder/vm_indent/debug_vm.go
deleted file mode 100644
index 99395388..00000000
--- a/vendor/github.com/goccy/go-json/internal/encoder/vm_indent/debug_vm.go
+++ /dev/null
@@ -1,35 +0,0 @@
-package vm_indent
-
-import (
- "fmt"
-
- "github.com/goccy/go-json/internal/encoder"
-)
-
-func DebugRun(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet) ([]byte, error) {
- var code *encoder.Opcode
- if (ctx.Option.Flag & encoder.HTMLEscapeOption) != 0 {
- code = codeSet.EscapeKeyCode
- } else {
- code = codeSet.NoescapeKeyCode
- }
-
- defer func() {
- if err := recover(); err != nil {
- w := ctx.Option.DebugOut
- fmt.Fprintln(w, "=============[DEBUG]===============")
- fmt.Fprintln(w, "* [TYPE]")
- fmt.Fprintln(w, codeSet.Type)
- fmt.Fprintf(w, "\n")
- fmt.Fprintln(w, "* [ALL OPCODE]")
- fmt.Fprintln(w, code.Dump())
- fmt.Fprintf(w, "\n")
- fmt.Fprintln(w, "* [CONTEXT]")
- fmt.Fprintf(w, "%+v\n", ctx)
- fmt.Fprintln(w, "===================================")
- panic(err)
- }
- }()
-
- return Run(ctx, b, codeSet)
-}
diff --git a/vendor/github.com/goccy/go-json/internal/encoder/vm_indent/hack.go b/vendor/github.com/goccy/go-json/internal/encoder/vm_indent/hack.go
deleted file mode 100644
index 9e245bfe..00000000
--- a/vendor/github.com/goccy/go-json/internal/encoder/vm_indent/hack.go
+++ /dev/null
@@ -1,9 +0,0 @@
-package vm_indent
-
-import (
- // HACK: compile order
- // `vm`, `vm_indent`, `vm_color`, `vm_color_indent` packages uses a lot of memory to compile,
- // so forcibly make dependencies and avoid compiling in concurrent.
- // dependency order: vm => vm_indent => vm_color => vm_color_indent
- _ "github.com/goccy/go-json/internal/encoder/vm_color"
-)
diff --git a/vendor/github.com/goccy/go-json/internal/encoder/vm_indent/util.go b/vendor/github.com/goccy/go-json/internal/encoder/vm_indent/util.go
deleted file mode 100644
index 6cb745e3..00000000
--- a/vendor/github.com/goccy/go-json/internal/encoder/vm_indent/util.go
+++ /dev/null
@@ -1,230 +0,0 @@
-package vm_indent
-
-import (
- "encoding/json"
- "fmt"
- "unsafe"
-
- "github.com/goccy/go-json/internal/encoder"
- "github.com/goccy/go-json/internal/runtime"
-)
-
-const uintptrSize = 4 << (^uintptr(0) >> 63)
-
-var (
- appendInt = encoder.AppendInt
- appendUint = encoder.AppendUint
- appendFloat32 = encoder.AppendFloat32
- appendFloat64 = encoder.AppendFloat64
- appendString = encoder.AppendString
- appendByteSlice = encoder.AppendByteSlice
- appendNumber = encoder.AppendNumber
- appendStructEnd = encoder.AppendStructEndIndent
- appendIndent = encoder.AppendIndent
- errUnsupportedValue = encoder.ErrUnsupportedValue
- errUnsupportedFloat = encoder.ErrUnsupportedFloat
- mapiterinit = encoder.MapIterInit
- mapiterkey = encoder.MapIterKey
- mapitervalue = encoder.MapIterValue
- mapiternext = encoder.MapIterNext
- maplen = encoder.MapLen
-)
-
-type emptyInterface struct {
- typ *runtime.Type
- ptr unsafe.Pointer
-}
-
-type nonEmptyInterface struct {
- itab *struct {
- ityp *runtime.Type // static interface type
- typ *runtime.Type // dynamic concrete type
- // unused fields...
- }
- ptr unsafe.Pointer
-}
-
-func errUnimplementedOp(op encoder.OpType) error {
- return fmt.Errorf("encoder (indent): opcode %s has not been implemented", op)
-}
-
-func load(base uintptr, idx uint32) uintptr {
- addr := base + uintptr(idx)
- return **(**uintptr)(unsafe.Pointer(&addr))
-}
-
-func store(base uintptr, idx uint32, p uintptr) {
- addr := base + uintptr(idx)
- **(**uintptr)(unsafe.Pointer(&addr)) = p
-}
-
-func loadNPtr(base uintptr, idx uint32, ptrNum uint8) uintptr {
- addr := base + uintptr(idx)
- p := **(**uintptr)(unsafe.Pointer(&addr))
- for i := uint8(0); i < ptrNum; i++ {
- if p == 0 {
- return 0
- }
- p = ptrToPtr(p)
- }
- return p
-}
-
-func ptrToUint64(p uintptr, bitSize uint8) uint64 {
- switch bitSize {
- case 8:
- return (uint64)(**(**uint8)(unsafe.Pointer(&p)))
- case 16:
- return (uint64)(**(**uint16)(unsafe.Pointer(&p)))
- case 32:
- return (uint64)(**(**uint32)(unsafe.Pointer(&p)))
- case 64:
- return **(**uint64)(unsafe.Pointer(&p))
- }
- return 0
-}
-func ptrToFloat32(p uintptr) float32 { return **(**float32)(unsafe.Pointer(&p)) }
-func ptrToFloat64(p uintptr) float64 { return **(**float64)(unsafe.Pointer(&p)) }
-func ptrToBool(p uintptr) bool { return **(**bool)(unsafe.Pointer(&p)) }
-func ptrToBytes(p uintptr) []byte { return **(**[]byte)(unsafe.Pointer(&p)) }
-func ptrToNumber(p uintptr) json.Number { return **(**json.Number)(unsafe.Pointer(&p)) }
-func ptrToString(p uintptr) string { return **(**string)(unsafe.Pointer(&p)) }
-func ptrToSlice(p uintptr) *runtime.SliceHeader { return *(**runtime.SliceHeader)(unsafe.Pointer(&p)) }
-func ptrToPtr(p uintptr) uintptr {
- return uintptr(**(**unsafe.Pointer)(unsafe.Pointer(&p)))
-}
-func ptrToNPtr(p uintptr, ptrNum uint8) uintptr {
- for i := uint8(0); i < ptrNum; i++ {
- if p == 0 {
- return 0
- }
- p = ptrToPtr(p)
- }
- return p
-}
-
-func ptrToUnsafePtr(p uintptr) unsafe.Pointer {
- return *(*unsafe.Pointer)(unsafe.Pointer(&p))
-}
-func ptrToInterface(code *encoder.Opcode, p uintptr) interface{} {
- return *(*interface{})(unsafe.Pointer(&emptyInterface{
- typ: code.Type,
- ptr: *(*unsafe.Pointer)(unsafe.Pointer(&p)),
- }))
-}
-
-func appendBool(_ *encoder.RuntimeContext, b []byte, v bool) []byte {
- if v {
- return append(b, "true"...)
- }
- return append(b, "false"...)
-}
-
-func appendNull(_ *encoder.RuntimeContext, b []byte) []byte {
- return append(b, "null"...)
-}
-
-func appendComma(_ *encoder.RuntimeContext, b []byte) []byte {
- return append(b, ',', '\n')
-}
-
-func appendNullComma(_ *encoder.RuntimeContext, b []byte) []byte {
- return append(b, "null,\n"...)
-}
-
-func appendColon(_ *encoder.RuntimeContext, b []byte) []byte {
- return append(b[:len(b)-2], ':', ' ')
-}
-
-func appendMapKeyValue(ctx *encoder.RuntimeContext, code *encoder.Opcode, b, key, value []byte) []byte {
- b = appendIndent(ctx, b, code.Indent+1)
- b = append(b, key...)
- b[len(b)-2] = ':'
- b[len(b)-1] = ' '
- return append(b, value...)
-}
-
-func appendMapEnd(ctx *encoder.RuntimeContext, code *encoder.Opcode, b []byte) []byte {
- b = b[:len(b)-2]
- b = append(b, '\n')
- b = appendIndent(ctx, b, code.Indent)
- return append(b, '}', ',', '\n')
-}
-
-func appendArrayHead(ctx *encoder.RuntimeContext, code *encoder.Opcode, b []byte) []byte {
- b = append(b, '[', '\n')
- return appendIndent(ctx, b, code.Indent+1)
-}
-
-func appendArrayEnd(ctx *encoder.RuntimeContext, code *encoder.Opcode, b []byte) []byte {
- b = b[:len(b)-2]
- b = append(b, '\n')
- b = appendIndent(ctx, b, code.Indent)
- return append(b, ']', ',', '\n')
-}
-
-func appendEmptyArray(_ *encoder.RuntimeContext, b []byte) []byte {
- return append(b, '[', ']', ',', '\n')
-}
-
-func appendEmptyObject(_ *encoder.RuntimeContext, b []byte) []byte {
- return append(b, '{', '}', ',', '\n')
-}
-
-func appendObjectEnd(ctx *encoder.RuntimeContext, code *encoder.Opcode, b []byte) []byte {
- last := len(b) - 1
- // replace comma to newline
- b[last-1] = '\n'
- b = appendIndent(ctx, b[:last], code.Indent)
- return append(b, '}', ',', '\n')
-}
-
-func appendMarshalJSON(ctx *encoder.RuntimeContext, code *encoder.Opcode, b []byte, v interface{}) ([]byte, error) {
- return encoder.AppendMarshalJSONIndent(ctx, code, b, v)
-}
-
-func appendMarshalText(ctx *encoder.RuntimeContext, code *encoder.Opcode, b []byte, v interface{}) ([]byte, error) {
- return encoder.AppendMarshalTextIndent(ctx, code, b, v)
-}
-
-func appendStructHead(_ *encoder.RuntimeContext, b []byte) []byte {
- return append(b, '{', '\n')
-}
-
-func appendStructKey(ctx *encoder.RuntimeContext, code *encoder.Opcode, b []byte) []byte {
- b = appendIndent(ctx, b, code.Indent)
- b = append(b, code.Key...)
- return append(b, ' ')
-}
-
-func appendStructEndSkipLast(ctx *encoder.RuntimeContext, code *encoder.Opcode, b []byte) []byte {
- last := len(b) - 1
- if b[last-1] == '{' {
- b[last] = '}'
- } else {
- if b[last] == '\n' {
- // to remove ',' and '\n' characters
- b = b[:len(b)-2]
- }
- b = append(b, '\n')
- b = appendIndent(ctx, b, code.Indent-1)
- b = append(b, '}')
- }
- return appendComma(ctx, b)
-}
-
-func restoreIndent(ctx *encoder.RuntimeContext, code *encoder.Opcode, ctxptr uintptr) {
- ctx.BaseIndent = uint32(load(ctxptr, code.Length))
-}
-
-func storeIndent(ctxptr uintptr, code *encoder.Opcode, indent uintptr) {
- store(ctxptr, code.Length, indent)
-}
-
-func appendArrayElemIndent(ctx *encoder.RuntimeContext, code *encoder.Opcode, b []byte) []byte {
- return appendIndent(ctx, b, code.Indent+1)
-}
-
-func appendMapKeyIndent(ctx *encoder.RuntimeContext, code *encoder.Opcode, b []byte) []byte {
- return appendIndent(ctx, b, code.Indent)
-}
diff --git a/vendor/github.com/goccy/go-json/internal/encoder/vm_indent/vm.go b/vendor/github.com/goccy/go-json/internal/encoder/vm_indent/vm.go
deleted file mode 100644
index 836c5c8a..00000000
--- a/vendor/github.com/goccy/go-json/internal/encoder/vm_indent/vm.go
+++ /dev/null
@@ -1,4859 +0,0 @@
-// Code generated by internal/cmd/generator. DO NOT EDIT!
-package vm_indent
-
-import (
- "math"
- "reflect"
- "sort"
- "unsafe"
-
- "github.com/goccy/go-json/internal/encoder"
- "github.com/goccy/go-json/internal/runtime"
-)
-
-func Run(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet) ([]byte, error) {
- recursiveLevel := 0
- ptrOffset := uintptr(0)
- ctxptr := ctx.Ptr()
- var code *encoder.Opcode
- if (ctx.Option.Flag & encoder.HTMLEscapeOption) != 0 {
- code = codeSet.EscapeKeyCode
- } else {
- code = codeSet.NoescapeKeyCode
- }
-
- for {
- switch code.Op {
- default:
- return nil, errUnimplementedOp(code.Op)
- case encoder.OpPtr:
- p := load(ctxptr, code.Idx)
- code = code.Next
- store(ctxptr, code.Idx, ptrToPtr(p))
- case encoder.OpIntPtr:
- p := loadNPtr(ctxptr, code.Idx, code.PtrNum)
- if p == 0 {
- b = appendNullComma(ctx, b)
- code = code.Next
- break
- }
- store(ctxptr, code.Idx, p)
- fallthrough
- case encoder.OpInt:
- b = appendInt(ctx, b, load(ctxptr, code.Idx), code)
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpUintPtr:
- p := loadNPtr(ctxptr, code.Idx, code.PtrNum)
- if p == 0 {
- b = appendNullComma(ctx, b)
- code = code.Next
- break
- }
- store(ctxptr, code.Idx, p)
- fallthrough
- case encoder.OpUint:
- b = appendUint(ctx, b, load(ctxptr, code.Idx), code)
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpIntString:
- b = append(b, '"')
- b = appendInt(ctx, b, load(ctxptr, code.Idx), code)
- b = append(b, '"')
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpUintString:
- b = append(b, '"')
- b = appendUint(ctx, b, load(ctxptr, code.Idx), code)
- b = append(b, '"')
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpFloat32Ptr:
- p := loadNPtr(ctxptr, code.Idx, code.PtrNum)
- if p == 0 {
- b = appendNull(ctx, b)
- b = appendComma(ctx, b)
- code = code.Next
- break
- }
- store(ctxptr, code.Idx, p)
- fallthrough
- case encoder.OpFloat32:
- b = appendFloat32(ctx, b, ptrToFloat32(load(ctxptr, code.Idx)))
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpFloat64Ptr:
- p := loadNPtr(ctxptr, code.Idx, code.PtrNum)
- if p == 0 {
- b = appendNullComma(ctx, b)
- code = code.Next
- break
- }
- store(ctxptr, code.Idx, p)
- fallthrough
- case encoder.OpFloat64:
- v := ptrToFloat64(load(ctxptr, code.Idx))
- if math.IsInf(v, 0) || math.IsNaN(v) {
- return nil, errUnsupportedFloat(v)
- }
- b = appendFloat64(ctx, b, v)
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStringPtr:
- p := loadNPtr(ctxptr, code.Idx, code.PtrNum)
- if p == 0 {
- b = appendNullComma(ctx, b)
- code = code.Next
- break
- }
- store(ctxptr, code.Idx, p)
- fallthrough
- case encoder.OpString:
- b = appendString(ctx, b, ptrToString(load(ctxptr, code.Idx)))
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpBoolPtr:
- p := loadNPtr(ctxptr, code.Idx, code.PtrNum)
- if p == 0 {
- b = appendNullComma(ctx, b)
- code = code.Next
- break
- }
- store(ctxptr, code.Idx, p)
- fallthrough
- case encoder.OpBool:
- b = appendBool(ctx, b, ptrToBool(load(ctxptr, code.Idx)))
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpBytesPtr:
- p := loadNPtr(ctxptr, code.Idx, code.PtrNum)
- if p == 0 {
- b = appendNullComma(ctx, b)
- code = code.Next
- break
- }
- store(ctxptr, code.Idx, p)
- fallthrough
- case encoder.OpBytes:
- b = appendByteSlice(ctx, b, ptrToBytes(load(ctxptr, code.Idx)))
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpNumberPtr:
- p := loadNPtr(ctxptr, code.Idx, code.PtrNum)
- if p == 0 {
- b = appendNullComma(ctx, b)
- code = code.Next
- break
- }
- store(ctxptr, code.Idx, p)
- fallthrough
- case encoder.OpNumber:
- bb, err := appendNumber(ctx, b, ptrToNumber(load(ctxptr, code.Idx)))
- if err != nil {
- return nil, err
- }
- b = appendComma(ctx, bb)
- code = code.Next
- case encoder.OpInterfacePtr:
- p := loadNPtr(ctxptr, code.Idx, code.PtrNum)
- if p == 0 {
- b = appendNullComma(ctx, b)
- code = code.Next
- break
- }
- store(ctxptr, code.Idx, p)
- fallthrough
- case encoder.OpInterface:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- b = appendNullComma(ctx, b)
- code = code.Next
- break
- }
- if recursiveLevel > encoder.StartDetectingCyclesAfter {
- for _, seen := range ctx.SeenPtr {
- if p == seen {
- return nil, errUnsupportedValue(code, p)
- }
- }
- }
- ctx.SeenPtr = append(ctx.SeenPtr, p)
- var (
- typ *runtime.Type
- ifacePtr unsafe.Pointer
- )
- up := ptrToUnsafePtr(p)
- if code.Flags&encoder.NonEmptyInterfaceFlags != 0 {
- iface := (*nonEmptyInterface)(up)
- ifacePtr = iface.ptr
- if iface.itab != nil {
- typ = iface.itab.typ
- }
- } else {
- iface := (*emptyInterface)(up)
- ifacePtr = iface.ptr
- typ = iface.typ
- }
- if ifacePtr == nil {
- isDirectedNil := typ != nil && typ.Kind() == reflect.Struct && !runtime.IfaceIndir(typ)
- if !isDirectedNil {
- b = appendNullComma(ctx, b)
- code = code.Next
- break
- }
- }
- ctx.KeepRefs = append(ctx.KeepRefs, up)
- ifaceCodeSet, err := encoder.CompileToGetCodeSet(ctx, uintptr(unsafe.Pointer(typ)))
- if err != nil {
- return nil, err
- }
-
- totalLength := uintptr(code.Length) + 3
- nextTotalLength := uintptr(ifaceCodeSet.CodeLength) + 3
-
- var c *encoder.Opcode
- if (ctx.Option.Flag & encoder.HTMLEscapeOption) != 0 {
- c = ifaceCodeSet.InterfaceEscapeKeyCode
- } else {
- c = ifaceCodeSet.InterfaceNoescapeKeyCode
- }
- curlen := uintptr(len(ctx.Ptrs))
- offsetNum := ptrOffset / uintptrSize
- oldOffset := ptrOffset
- ptrOffset += totalLength * uintptrSize
- oldBaseIndent := ctx.BaseIndent
- ctx.BaseIndent += code.Indent
-
- newLen := offsetNum + totalLength + nextTotalLength
- if curlen < newLen {
- ctx.Ptrs = append(ctx.Ptrs, make([]uintptr, newLen-curlen)...)
- }
- ctxptr = ctx.Ptr() + ptrOffset // assign new ctxptr
-
- end := ifaceCodeSet.EndCode
- store(ctxptr, c.Idx, uintptr(ifacePtr))
- store(ctxptr, end.Idx, oldOffset)
- store(ctxptr, end.ElemIdx, uintptr(unsafe.Pointer(code.Next)))
- storeIndent(ctxptr, end, uintptr(oldBaseIndent))
- code = c
- recursiveLevel++
- case encoder.OpInterfaceEnd:
- recursiveLevel--
-
- // restore ctxptr
- offset := load(ctxptr, code.Idx)
- restoreIndent(ctx, code, ctxptr)
- ctx.SeenPtr = ctx.SeenPtr[:len(ctx.SeenPtr)-1]
-
- codePtr := load(ctxptr, code.ElemIdx)
- code = (*encoder.Opcode)(ptrToUnsafePtr(codePtr))
- ctxptr = ctx.Ptr() + offset
- ptrOffset = offset
- case encoder.OpMarshalJSONPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- b = appendNullComma(ctx, b)
- code = code.Next
- break
- }
- store(ctxptr, code.Idx, ptrToPtr(p))
- fallthrough
- case encoder.OpMarshalJSON:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- b = appendNullComma(ctx, b)
- code = code.Next
- break
- }
- if (code.Flags&encoder.IsNilableTypeFlags) != 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- p = ptrToPtr(p)
- }
- bb, err := appendMarshalJSON(ctx, code, b, ptrToInterface(code, p))
- if err != nil {
- return nil, err
- }
- b = appendComma(ctx, bb)
- code = code.Next
- case encoder.OpMarshalTextPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- b = appendNullComma(ctx, b)
- code = code.Next
- break
- }
- store(ctxptr, code.Idx, ptrToPtr(p))
- fallthrough
- case encoder.OpMarshalText:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- b = append(b, `""`...)
- b = appendComma(ctx, b)
- code = code.Next
- break
- }
- if (code.Flags&encoder.IsNilableTypeFlags) != 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- p = ptrToPtr(p)
- }
- bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p))
- if err != nil {
- return nil, err
- }
- b = appendComma(ctx, bb)
- code = code.Next
- case encoder.OpSlicePtr:
- p := loadNPtr(ctxptr, code.Idx, code.PtrNum)
- if p == 0 {
- b = appendNullComma(ctx, b)
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, p)
- fallthrough
- case encoder.OpSlice:
- p := load(ctxptr, code.Idx)
- slice := ptrToSlice(p)
- if p == 0 || slice.Data == nil {
- b = appendNullComma(ctx, b)
- code = code.End.Next
- break
- }
- store(ctxptr, code.ElemIdx, 0)
- store(ctxptr, code.Length, uintptr(slice.Len))
- store(ctxptr, code.Idx, uintptr(slice.Data))
- if slice.Len > 0 {
- b = appendArrayHead(ctx, code, b)
- code = code.Next
- store(ctxptr, code.Idx, uintptr(slice.Data))
- } else {
- b = appendEmptyArray(ctx, b)
- code = code.End.Next
- }
- case encoder.OpSliceElem:
- idx := load(ctxptr, code.ElemIdx)
- length := load(ctxptr, code.Length)
- idx++
- if idx < length {
- b = appendArrayElemIndent(ctx, code, b)
- store(ctxptr, code.ElemIdx, idx)
- data := load(ctxptr, code.Idx)
- size := uintptr(code.Size)
- code = code.Next
- store(ctxptr, code.Idx, data+idx*size)
- } else {
- b = appendArrayEnd(ctx, code, b)
- code = code.End.Next
- }
- case encoder.OpArrayPtr:
- p := loadNPtr(ctxptr, code.Idx, code.PtrNum)
- if p == 0 {
- b = appendNullComma(ctx, b)
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, p)
- fallthrough
- case encoder.OpArray:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- b = appendNullComma(ctx, b)
- code = code.End.Next
- break
- }
- if code.Length > 0 {
- b = appendArrayHead(ctx, code, b)
- store(ctxptr, code.ElemIdx, 0)
- code = code.Next
- store(ctxptr, code.Idx, p)
- } else {
- b = appendEmptyArray(ctx, b)
- code = code.End.Next
- }
- case encoder.OpArrayElem:
- idx := load(ctxptr, code.ElemIdx)
- idx++
- if idx < uintptr(code.Length) {
- b = appendArrayElemIndent(ctx, code, b)
- store(ctxptr, code.ElemIdx, idx)
- p := load(ctxptr, code.Idx)
- size := uintptr(code.Size)
- code = code.Next
- store(ctxptr, code.Idx, p+idx*size)
- } else {
- b = appendArrayEnd(ctx, code, b)
- code = code.End.Next
- }
- case encoder.OpMapPtr:
- p := loadNPtr(ctxptr, code.Idx, code.PtrNum)
- if p == 0 {
- b = appendNullComma(ctx, b)
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, p)
- fallthrough
- case encoder.OpMap:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- b = appendNullComma(ctx, b)
- code = code.End.Next
- break
- }
- uptr := ptrToUnsafePtr(p)
- mlen := maplen(uptr)
- if mlen <= 0 {
- b = appendEmptyObject(ctx, b)
- code = code.End.Next
- break
- }
- b = appendStructHead(ctx, b)
- unorderedMap := (ctx.Option.Flag & encoder.UnorderedMapOption) != 0
- mapCtx := encoder.NewMapContext(mlen, unorderedMap)
- mapiterinit(code.Type, uptr, &mapCtx.Iter)
- store(ctxptr, code.Idx, uintptr(unsafe.Pointer(mapCtx)))
- ctx.KeepRefs = append(ctx.KeepRefs, unsafe.Pointer(mapCtx))
- if unorderedMap {
- b = appendMapKeyIndent(ctx, code.Next, b)
- } else {
- mapCtx.Start = len(b)
- mapCtx.First = len(b)
- }
- key := mapiterkey(&mapCtx.Iter)
- store(ctxptr, code.Next.Idx, uintptr(key))
- code = code.Next
- case encoder.OpMapKey:
- mapCtx := (*encoder.MapContext)(ptrToUnsafePtr(load(ctxptr, code.Idx)))
- idx := mapCtx.Idx
- idx++
- if (ctx.Option.Flag & encoder.UnorderedMapOption) != 0 {
- if idx < mapCtx.Len {
- b = appendMapKeyIndent(ctx, code, b)
- mapCtx.Idx = int(idx)
- key := mapiterkey(&mapCtx.Iter)
- store(ctxptr, code.Next.Idx, uintptr(key))
- code = code.Next
- } else {
- b = appendObjectEnd(ctx, code, b)
- encoder.ReleaseMapContext(mapCtx)
- code = code.End.Next
- }
- } else {
- mapCtx.Slice.Items[mapCtx.Idx].Value = b[mapCtx.Start:len(b)]
- if idx < mapCtx.Len {
- mapCtx.Idx = int(idx)
- mapCtx.Start = len(b)
- key := mapiterkey(&mapCtx.Iter)
- store(ctxptr, code.Next.Idx, uintptr(key))
- code = code.Next
- } else {
- code = code.End
- }
- }
- case encoder.OpMapValue:
- mapCtx := (*encoder.MapContext)(ptrToUnsafePtr(load(ctxptr, code.Idx)))
- if (ctx.Option.Flag & encoder.UnorderedMapOption) != 0 {
- b = appendColon(ctx, b)
- } else {
- mapCtx.Slice.Items[mapCtx.Idx].Key = b[mapCtx.Start:len(b)]
- mapCtx.Start = len(b)
- }
- value := mapitervalue(&mapCtx.Iter)
- store(ctxptr, code.Next.Idx, uintptr(value))
- mapiternext(&mapCtx.Iter)
- code = code.Next
- case encoder.OpMapEnd:
- // this operation only used by sorted map.
- mapCtx := (*encoder.MapContext)(ptrToUnsafePtr(load(ctxptr, code.Idx)))
- sort.Sort(mapCtx.Slice)
- buf := mapCtx.Buf
- for _, item := range mapCtx.Slice.Items {
- buf = appendMapKeyValue(ctx, code, buf, item.Key, item.Value)
- }
- buf = appendMapEnd(ctx, code, buf)
- b = b[:mapCtx.First]
- b = append(b, buf...)
- mapCtx.Buf = buf
- encoder.ReleaseMapContext(mapCtx)
- code = code.Next
- case encoder.OpRecursivePtr:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- code = code.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpRecursive:
- ptr := load(ctxptr, code.Idx)
- if ptr != 0 {
- if recursiveLevel > encoder.StartDetectingCyclesAfter {
- for _, seen := range ctx.SeenPtr {
- if ptr == seen {
- return nil, errUnsupportedValue(code, ptr)
- }
- }
- }
- }
- ctx.SeenPtr = append(ctx.SeenPtr, ptr)
- c := code.Jmp.Code
- curlen := uintptr(len(ctx.Ptrs))
- offsetNum := ptrOffset / uintptrSize
- oldOffset := ptrOffset
- ptrOffset += code.Jmp.CurLen * uintptrSize
- oldBaseIndent := ctx.BaseIndent
- indentDiffFromTop := c.Indent - 1
- ctx.BaseIndent += code.Indent - indentDiffFromTop
-
- newLen := offsetNum + code.Jmp.CurLen + code.Jmp.NextLen
- if curlen < newLen {
- ctx.Ptrs = append(ctx.Ptrs, make([]uintptr, newLen-curlen)...)
- }
- ctxptr = ctx.Ptr() + ptrOffset // assign new ctxptr
-
- store(ctxptr, c.Idx, ptr)
- store(ctxptr, c.End.Next.Idx, oldOffset)
- store(ctxptr, c.End.Next.ElemIdx, uintptr(unsafe.Pointer(code.Next)))
- storeIndent(ctxptr, c.End.Next, uintptr(oldBaseIndent))
- code = c
- recursiveLevel++
- case encoder.OpRecursiveEnd:
- recursiveLevel--
-
- // restore ctxptr
- restoreIndent(ctx, code, ctxptr)
- offset := load(ctxptr, code.Idx)
- ctx.SeenPtr = ctx.SeenPtr[:len(ctx.SeenPtr)-1]
-
- codePtr := load(ctxptr, code.ElemIdx)
- code = (*encoder.Opcode)(ptrToUnsafePtr(codePtr))
- ctxptr = ctx.Ptr() + offset
- ptrOffset = offset
- case encoder.OpStructPtrHead:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHead:
- p := load(ctxptr, code.Idx)
- if p == 0 && ((code.Flags&encoder.IndirectFlags) != 0 || code.Next.Op == encoder.OpStructEnd) {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- if len(code.Key) > 0 {
- if (code.Flags&encoder.IsTaggedKeyFlags) != 0 || code.Flags&encoder.AnonymousKeyFlags == 0 {
- b = appendStructKey(ctx, code, b)
- }
- }
- p += uintptr(code.Offset)
- code = code.Next
- store(ctxptr, code.Idx, p)
- case encoder.OpStructPtrHeadOmitEmpty:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadOmitEmpty:
- p := load(ctxptr, code.Idx)
- if p == 0 && ((code.Flags&encoder.IndirectFlags) != 0 || code.Next.Op == encoder.OpStructEnd) {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- p += uintptr(code.Offset)
- if p == 0 || (ptrToPtr(p) == 0 && (code.Flags&encoder.IsNextOpPtrTypeFlags) != 0) {
- code = code.NextField
- } else {
- b = appendStructKey(ctx, code, b)
- code = code.Next
- store(ctxptr, code.Idx, p)
- }
- case encoder.OpStructPtrHeadInt:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadInt:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- b = appendInt(ctx, b, p+uintptr(code.Offset), code)
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyInt:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadOmitEmptyInt:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- u64 := ptrToUint64(p+uintptr(code.Offset), code.NumBitSize)
- v := u64 & ((1 << code.NumBitSize) - 1)
- if v == 0 {
- code = code.NextField
- } else {
- b = appendStructKey(ctx, code, b)
- b = appendInt(ctx, b, p+uintptr(code.Offset), code)
- b = appendComma(ctx, b)
- code = code.Next
- }
- case encoder.OpStructPtrHeadIntString:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadIntString:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendInt(ctx, b, p+uintptr(code.Offset), code)
- b = append(b, '"')
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyIntString:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadOmitEmptyIntString:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- p += uintptr(code.Offset)
- u64 := ptrToUint64(p, code.NumBitSize)
- v := u64 & ((1 << code.NumBitSize) - 1)
- if v == 0 {
- code = code.NextField
- } else {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendInt(ctx, b, p, code)
- b = append(b, '"')
- b = appendComma(ctx, b)
- code = code.Next
- }
- case encoder.OpStructPtrHeadIntPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadIntPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = appendInt(ctx, b, p, code)
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyIntPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadOmitEmptyIntPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = appendInt(ctx, b, p, code)
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructPtrHeadIntPtrString:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadIntPtrString:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = append(b, '"')
- b = appendInt(ctx, b, p, code)
- b = append(b, '"')
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyIntPtrString:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadOmitEmptyIntPtrString:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendInt(ctx, b, p, code)
- b = append(b, '"')
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructPtrHeadUint:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadUint:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- b = appendUint(ctx, b, p+uintptr(code.Offset), code)
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyUint:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadOmitEmptyUint:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- u64 := ptrToUint64(p+uintptr(code.Offset), code.NumBitSize)
- v := u64 & ((1 << code.NumBitSize) - 1)
- if v == 0 {
- code = code.NextField
- } else {
- b = appendStructKey(ctx, code, b)
- b = appendUint(ctx, b, p+uintptr(code.Offset), code)
- b = appendComma(ctx, b)
- code = code.Next
- }
- case encoder.OpStructPtrHeadUintString:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadUintString:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendUint(ctx, b, p+uintptr(code.Offset), code)
- b = append(b, '"')
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyUintString:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadOmitEmptyUintString:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- u64 := ptrToUint64(p+uintptr(code.Offset), code.NumBitSize)
- v := u64 & ((1 << code.NumBitSize) - 1)
- if v == 0 {
- code = code.NextField
- } else {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendUint(ctx, b, p+uintptr(code.Offset), code)
- b = append(b, '"')
- b = appendComma(ctx, b)
- code = code.Next
- }
- case encoder.OpStructPtrHeadUintPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadUintPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = appendUint(ctx, b, p, code)
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyUintPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadOmitEmptyUintPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = appendUint(ctx, b, p, code)
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructPtrHeadUintPtrString:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadUintPtrString:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = append(b, '"')
- b = appendUint(ctx, b, p, code)
- b = append(b, '"')
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyUintPtrString:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadOmitEmptyUintPtrString:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendUint(ctx, b, p, code)
- b = append(b, '"')
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructPtrHeadFloat32:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadFloat32:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- b = appendFloat32(ctx, b, ptrToFloat32(p+uintptr(code.Offset)))
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyFloat32:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadOmitEmptyFloat32:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- v := ptrToFloat32(p + uintptr(code.Offset))
- if v == 0 {
- code = code.NextField
- } else {
- b = appendStructKey(ctx, code, b)
- b = appendFloat32(ctx, b, v)
- b = appendComma(ctx, b)
- code = code.Next
- }
- case encoder.OpStructPtrHeadFloat32String:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadFloat32String:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendFloat32(ctx, b, ptrToFloat32(p+uintptr(code.Offset)))
- b = append(b, '"')
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyFloat32String:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadOmitEmptyFloat32String:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- v := ptrToFloat32(p + uintptr(code.Offset))
- if v == 0 {
- code = code.NextField
- } else {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendFloat32(ctx, b, v)
- b = append(b, '"')
- b = appendComma(ctx, b)
- code = code.Next
- }
- case encoder.OpStructPtrHeadFloat32Ptr:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadFloat32Ptr:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = appendFloat32(ctx, b, ptrToFloat32(p))
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyFloat32Ptr:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadOmitEmptyFloat32Ptr:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = appendFloat32(ctx, b, ptrToFloat32(p))
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructPtrHeadFloat32PtrString:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadFloat32PtrString:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = append(b, '"')
- b = appendFloat32(ctx, b, ptrToFloat32(p))
- b = append(b, '"')
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyFloat32PtrString:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadOmitEmptyFloat32PtrString:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendFloat32(ctx, b, ptrToFloat32(p))
- b = append(b, '"')
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructPtrHeadFloat64:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadFloat64:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- v := ptrToFloat64(p + uintptr(code.Offset))
- if math.IsInf(v, 0) || math.IsNaN(v) {
- return nil, errUnsupportedFloat(v)
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- b = appendFloat64(ctx, b, v)
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyFloat64:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadOmitEmptyFloat64:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- v := ptrToFloat64(p + uintptr(code.Offset))
- if v == 0 {
- code = code.NextField
- } else {
- if math.IsInf(v, 0) || math.IsNaN(v) {
- return nil, errUnsupportedFloat(v)
- }
- b = appendStructKey(ctx, code, b)
- b = appendFloat64(ctx, b, v)
- b = appendComma(ctx, b)
- code = code.Next
- }
- case encoder.OpStructPtrHeadFloat64String:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadFloat64String:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- v := ptrToFloat64(p + uintptr(code.Offset))
- if math.IsInf(v, 0) || math.IsNaN(v) {
- return nil, errUnsupportedFloat(v)
- }
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendFloat64(ctx, b, v)
- b = append(b, '"')
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyFloat64String:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadOmitEmptyFloat64String:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- v := ptrToFloat64(p + uintptr(code.Offset))
- if v == 0 {
- code = code.NextField
- } else {
- if math.IsInf(v, 0) || math.IsNaN(v) {
- return nil, errUnsupportedFloat(v)
- }
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendFloat64(ctx, b, v)
- b = append(b, '"')
- b = appendComma(ctx, b)
- code = code.Next
- }
- case encoder.OpStructPtrHeadFloat64Ptr:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadFloat64Ptr:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- v := ptrToFloat64(p)
- if math.IsInf(v, 0) || math.IsNaN(v) {
- return nil, errUnsupportedFloat(v)
- }
- b = appendFloat64(ctx, b, v)
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyFloat64Ptr:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadOmitEmptyFloat64Ptr:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- v := ptrToFloat64(p)
- if math.IsInf(v, 0) || math.IsNaN(v) {
- return nil, errUnsupportedFloat(v)
- }
- b = appendFloat64(ctx, b, v)
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructPtrHeadFloat64PtrString:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadFloat64PtrString:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = append(b, '"')
- v := ptrToFloat64(p)
- if math.IsInf(v, 0) || math.IsNaN(v) {
- return nil, errUnsupportedFloat(v)
- }
- b = appendFloat64(ctx, b, v)
- b = append(b, '"')
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyFloat64PtrString:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadOmitEmptyFloat64PtrString:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- v := ptrToFloat64(p)
- if math.IsInf(v, 0) || math.IsNaN(v) {
- return nil, errUnsupportedFloat(v)
- }
- b = appendFloat64(ctx, b, v)
- b = append(b, '"')
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructPtrHeadString:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadString:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNull(ctx, b)
- b = appendComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- b = appendString(ctx, b, ptrToString(p+uintptr(code.Offset)))
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyString:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadOmitEmptyString:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- v := ptrToString(p + uintptr(code.Offset))
- if v == "" {
- code = code.NextField
- } else {
- b = appendStructKey(ctx, code, b)
- b = appendString(ctx, b, v)
- b = appendComma(ctx, b)
- code = code.Next
- }
- case encoder.OpStructPtrHeadStringString:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadStringString:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- b = appendString(ctx, b, string(appendString(ctx, []byte{}, ptrToString(p+uintptr(code.Offset)))))
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyStringString:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadOmitEmptyStringString:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- v := ptrToString(p + uintptr(code.Offset))
- if v == "" {
- code = code.NextField
- } else {
- b = appendStructKey(ctx, code, b)
- b = appendString(ctx, b, string(appendString(ctx, []byte{}, v)))
- b = appendComma(ctx, b)
- code = code.Next
- }
- case encoder.OpStructPtrHeadStringPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadStringPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = appendString(ctx, b, ptrToString(p))
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyStringPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadOmitEmptyStringPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = appendString(ctx, b, ptrToString(p))
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructPtrHeadStringPtrString:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadStringPtrString:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = appendString(ctx, b, string(appendString(ctx, []byte{}, ptrToString(p))))
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyStringPtrString:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadOmitEmptyStringPtrString:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = appendString(ctx, b, string(appendString(ctx, []byte{}, ptrToString(p))))
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructPtrHeadBool:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadBool:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- b = appendBool(ctx, b, ptrToBool(p+uintptr(code.Offset)))
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyBool:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadOmitEmptyBool:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- v := ptrToBool(p + uintptr(code.Offset))
- if v {
- b = appendStructKey(ctx, code, b)
- b = appendBool(ctx, b, v)
- b = appendComma(ctx, b)
- code = code.Next
- } else {
- code = code.NextField
- }
- case encoder.OpStructPtrHeadBoolString:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadBoolString:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendBool(ctx, b, ptrToBool(p+uintptr(code.Offset)))
- b = append(b, '"')
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyBoolString:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadOmitEmptyBoolString:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- v := ptrToBool(p + uintptr(code.Offset))
- if v {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendBool(ctx, b, v)
- b = append(b, '"')
- b = appendComma(ctx, b)
- code = code.Next
- } else {
- code = code.NextField
- }
- case encoder.OpStructPtrHeadBoolPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadBoolPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = appendBool(ctx, b, ptrToBool(p))
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyBoolPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadOmitEmptyBoolPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = appendBool(ctx, b, ptrToBool(p))
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructPtrHeadBoolPtrString:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadBoolPtrString:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = append(b, '"')
- b = appendBool(ctx, b, ptrToBool(p))
- b = append(b, '"')
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyBoolPtrString:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadOmitEmptyBoolPtrString:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendBool(ctx, b, ptrToBool(p))
- b = append(b, '"')
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructPtrHeadBytes:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadBytes:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- b = appendByteSlice(ctx, b, ptrToBytes(p+uintptr(code.Offset)))
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyBytes:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadOmitEmptyBytes:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- v := ptrToBytes(p + uintptr(code.Offset))
- if len(v) == 0 {
- code = code.NextField
- } else {
- b = appendStructKey(ctx, code, b)
- b = appendByteSlice(ctx, b, v)
- b = appendComma(ctx, b)
- code = code.Next
- }
- case encoder.OpStructPtrHeadBytesPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadBytesPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = appendByteSlice(ctx, b, ptrToBytes(p))
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyBytesPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadOmitEmptyBytesPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = appendByteSlice(ctx, b, ptrToBytes(p))
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructPtrHeadNumber:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadNumber:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- bb, err := appendNumber(ctx, b, ptrToNumber(p+uintptr(code.Offset)))
- if err != nil {
- return nil, err
- }
- b = appendComma(ctx, bb)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyNumber:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadOmitEmptyNumber:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- v := ptrToNumber(p + uintptr(code.Offset))
- if v == "" {
- code = code.NextField
- } else {
- b = appendStructKey(ctx, code, b)
- bb, err := appendNumber(ctx, b, v)
- if err != nil {
- return nil, err
- }
- b = appendComma(ctx, bb)
- code = code.Next
- }
- case encoder.OpStructPtrHeadNumberString:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadNumberString:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- bb, err := appendNumber(ctx, b, ptrToNumber(p+uintptr(code.Offset)))
- if err != nil {
- return nil, err
- }
- b = append(bb, '"')
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyNumberString:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadOmitEmptyNumberString:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- v := ptrToNumber(p + uintptr(code.Offset))
- if v == "" {
- code = code.NextField
- } else {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- bb, err := appendNumber(ctx, b, v)
- if err != nil {
- return nil, err
- }
- b = append(bb, '"')
- b = appendComma(ctx, b)
- code = code.Next
- }
- case encoder.OpStructPtrHeadNumberPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadNumberPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- bb, err := appendNumber(ctx, b, ptrToNumber(p))
- if err != nil {
- return nil, err
- }
- b = bb
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyNumberPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadOmitEmptyNumberPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- bb, err := appendNumber(ctx, b, ptrToNumber(p))
- if err != nil {
- return nil, err
- }
- b = appendComma(ctx, bb)
- }
- code = code.Next
- case encoder.OpStructPtrHeadNumberPtrString:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadNumberPtrString:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = append(b, '"')
- bb, err := appendNumber(ctx, b, ptrToNumber(p))
- if err != nil {
- return nil, err
- }
- b = append(bb, '"')
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyNumberPtrString:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadOmitEmptyNumberPtrString:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- bb, err := appendNumber(ctx, b, ptrToNumber(p))
- if err != nil {
- return nil, err
- }
- b = append(bb, '"')
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructPtrHeadArray, encoder.OpStructPtrHeadSlice:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadArray, encoder.OpStructHeadSlice:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- p += uintptr(code.Offset)
- code = code.Next
- store(ctxptr, code.Idx, p)
- case encoder.OpStructPtrHeadOmitEmptyArray:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadOmitEmptyArray:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- p += uintptr(code.Offset)
- b = appendStructKey(ctx, code, b)
- code = code.Next
- store(ctxptr, code.Idx, p)
- case encoder.OpStructPtrHeadOmitEmptySlice:
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadOmitEmptySlice:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- p += uintptr(code.Offset)
- slice := ptrToSlice(p)
- if slice.Len == 0 {
- code = code.NextField
- } else {
- b = appendStructKey(ctx, code, b)
- code = code.Next
- store(ctxptr, code.Idx, p)
- }
- case encoder.OpStructPtrHeadArrayPtr, encoder.OpStructPtrHeadSlicePtr:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadArrayPtr, encoder.OpStructHeadSlicePtr:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p == 0 {
- b = appendNullComma(ctx, b)
- code = code.NextField
- } else {
- code = code.Next
- store(ctxptr, code.Idx, p)
- }
- case encoder.OpStructPtrHeadOmitEmptyArrayPtr, encoder.OpStructPtrHeadOmitEmptySlicePtr:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadOmitEmptyArrayPtr, encoder.OpStructHeadOmitEmptySlicePtr:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p == 0 {
- code = code.NextField
- } else {
- b = appendStructKey(ctx, code, b)
- code = code.Next
- store(ctxptr, code.Idx, p)
- }
- case encoder.OpStructPtrHeadMap:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadMap:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- if p != 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- p = ptrToPtr(p + uintptr(code.Offset))
- }
- code = code.Next
- store(ctxptr, code.Idx, p)
- case encoder.OpStructPtrHeadOmitEmptyMap:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadOmitEmptyMap:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- if p != 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- p = ptrToPtr(p + uintptr(code.Offset))
- }
- if maplen(ptrToUnsafePtr(p)) == 0 {
- code = code.NextField
- } else {
- b = appendStructKey(ctx, code, b)
- code = code.Next
- store(ctxptr, code.Idx, p)
- }
- case encoder.OpStructPtrHeadMapPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadMapPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- if p == 0 {
- b = appendNullComma(ctx, b)
- code = code.NextField
- break
- }
- p = ptrToPtr(p + uintptr(code.Offset))
- if p == 0 {
- b = appendNullComma(ctx, b)
- code = code.NextField
- } else {
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p, code.PtrNum)
- }
- code = code.Next
- store(ctxptr, code.Idx, p)
- }
- case encoder.OpStructPtrHeadOmitEmptyMapPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadOmitEmptyMapPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- if p == 0 {
- code = code.NextField
- break
- }
- p = ptrToPtr(p + uintptr(code.Offset))
- if p == 0 {
- code = code.NextField
- } else {
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p, code.PtrNum)
- }
- b = appendStructKey(ctx, code, b)
- code = code.Next
- store(ctxptr, code.Idx, p)
- }
- case encoder.OpStructPtrHeadMarshalJSON:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if (code.Flags & encoder.IndirectFlags) != 0 {
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadMarshalJSON:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- p += uintptr(code.Offset)
- if (code.Flags & encoder.IsNilableTypeFlags) != 0 {
- if (code.Flags&encoder.IndirectFlags) != 0 || code.Op == encoder.OpStructPtrHeadMarshalJSON {
- p = ptrToPtr(p)
- }
- }
- if p == 0 && (code.Flags&encoder.NilCheckFlags) != 0 {
- b = appendNull(ctx, b)
- } else {
- bb, err := appendMarshalJSON(ctx, code, b, ptrToInterface(code, p))
- if err != nil {
- return nil, err
- }
- b = bb
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyMarshalJSON:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if (code.Flags & encoder.IndirectFlags) != 0 {
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadOmitEmptyMarshalJSON:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- p += uintptr(code.Offset)
- if (code.Flags & encoder.IsNilableTypeFlags) != 0 {
- if (code.Flags&encoder.IndirectFlags) != 0 || code.Op == encoder.OpStructPtrHeadOmitEmptyMarshalJSON {
- p = ptrToPtr(p)
- }
- }
- iface := ptrToInterface(code, p)
- if (code.Flags&encoder.NilCheckFlags) != 0 && encoder.IsNilForMarshaler(iface) {
- code = code.NextField
- } else {
- b = appendStructKey(ctx, code, b)
- bb, err := appendMarshalJSON(ctx, code, b, iface)
- if err != nil {
- return nil, err
- }
- b = bb
- b = appendComma(ctx, b)
- code = code.Next
- }
- case encoder.OpStructPtrHeadMarshalJSONPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadMarshalJSONPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- bb, err := appendMarshalJSON(ctx, code, b, ptrToInterface(code, p))
- if err != nil {
- return nil, err
- }
- b = bb
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyMarshalJSONPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadOmitEmptyMarshalJSONPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- if p == 0 {
- code = code.NextField
- } else {
- b = appendStructKey(ctx, code, b)
- bb, err := appendMarshalJSON(ctx, code, b, ptrToInterface(code, p))
- if err != nil {
- return nil, err
- }
- b = bb
- b = appendComma(ctx, b)
- code = code.Next
- }
- case encoder.OpStructPtrHeadMarshalText:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if (code.Flags & encoder.IndirectFlags) != 0 {
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadMarshalText:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- p += uintptr(code.Offset)
- if (code.Flags & encoder.IsNilableTypeFlags) != 0 {
- if (code.Flags&encoder.IndirectFlags) != 0 || code.Op == encoder.OpStructPtrHeadMarshalText {
- p = ptrToPtr(p)
- }
- }
- if p == 0 && (code.Flags&encoder.NilCheckFlags) != 0 {
- b = appendNull(ctx, b)
- } else {
- bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p))
- if err != nil {
- return nil, err
- }
- b = bb
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyMarshalText:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if (code.Flags & encoder.IndirectFlags) != 0 {
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- }
- fallthrough
- case encoder.OpStructHeadOmitEmptyMarshalText:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- p += uintptr(code.Offset)
- if (code.Flags & encoder.IsNilableTypeFlags) != 0 {
- if (code.Flags&encoder.IndirectFlags) != 0 || code.Op == encoder.OpStructPtrHeadOmitEmptyMarshalText {
- p = ptrToPtr(p)
- }
- }
- if p == 0 && (code.Flags&encoder.NilCheckFlags) != 0 {
- code = code.NextField
- } else {
- b = appendStructKey(ctx, code, b)
- bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p))
- if err != nil {
- return nil, err
- }
- b = bb
- b = appendComma(ctx, b)
- code = code.Next
- }
- case encoder.OpStructPtrHeadMarshalTextPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadMarshalTextPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- b = appendStructKey(ctx, code, b)
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p))
- if err != nil {
- return nil, err
- }
- b = bb
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructPtrHeadOmitEmptyMarshalTextPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- store(ctxptr, code.Idx, ptrToNPtr(p, code.PtrNum))
- fallthrough
- case encoder.OpStructHeadOmitEmptyMarshalTextPtr:
- p := load(ctxptr, code.Idx)
- if p == 0 && (code.Flags&encoder.IndirectFlags) != 0 {
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendNullComma(ctx, b)
- }
- code = code.End.Next
- break
- }
- if (code.Flags & encoder.IndirectFlags) != 0 {
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- }
- if code.Flags&encoder.AnonymousHeadFlags == 0 {
- b = appendStructHead(ctx, b)
- }
- if p == 0 {
- code = code.NextField
- } else {
- b = appendStructKey(ctx, code, b)
- bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p))
- if err != nil {
- return nil, err
- }
- b = bb
- b = appendComma(ctx, b)
- code = code.Next
- }
- case encoder.OpStructField:
- if code.Flags&encoder.IsTaggedKeyFlags != 0 || code.Flags&encoder.AnonymousKeyFlags == 0 {
- b = appendStructKey(ctx, code, b)
- }
- p := load(ctxptr, code.Idx) + uintptr(code.Offset)
- code = code.Next
- store(ctxptr, code.Idx, p)
- case encoder.OpStructFieldOmitEmpty:
- p := load(ctxptr, code.Idx)
- p += uintptr(code.Offset)
- if ptrToPtr(p) == 0 && (code.Flags&encoder.IsNextOpPtrTypeFlags) != 0 {
- code = code.NextField
- } else {
- b = appendStructKey(ctx, code, b)
- code = code.Next
- store(ctxptr, code.Idx, p)
- }
- case encoder.OpStructFieldInt:
- p := load(ctxptr, code.Idx)
- b = appendStructKey(ctx, code, b)
- b = appendInt(ctx, b, p+uintptr(code.Offset), code)
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyInt:
- p := load(ctxptr, code.Idx)
- u64 := ptrToUint64(p+uintptr(code.Offset), code.NumBitSize)
- v := u64 & ((1 << code.NumBitSize) - 1)
- if v != 0 {
- b = appendStructKey(ctx, code, b)
- b = appendInt(ctx, b, p+uintptr(code.Offset), code)
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructFieldIntString:
- p := load(ctxptr, code.Idx)
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendInt(ctx, b, p+uintptr(code.Offset), code)
- b = append(b, '"')
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyIntString:
- p := load(ctxptr, code.Idx)
- u64 := ptrToUint64(p+uintptr(code.Offset), code.NumBitSize)
- v := u64 & ((1 << code.NumBitSize) - 1)
- if v != 0 {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendInt(ctx, b, p+uintptr(code.Offset), code)
- b = append(b, '"')
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructFieldIntPtr:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- b = appendStructKey(ctx, code, b)
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = appendInt(ctx, b, p, code)
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyIntPtr:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = appendInt(ctx, b, p, code)
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructFieldIntPtrString:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- b = appendStructKey(ctx, code, b)
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = append(b, '"')
- b = appendInt(ctx, b, p, code)
- b = append(b, '"')
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyIntPtrString:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendInt(ctx, b, p, code)
- b = append(b, '"')
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructFieldUint:
- p := load(ctxptr, code.Idx)
- b = appendStructKey(ctx, code, b)
- b = appendUint(ctx, b, p+uintptr(code.Offset), code)
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyUint:
- p := load(ctxptr, code.Idx)
- u64 := ptrToUint64(p+uintptr(code.Offset), code.NumBitSize)
- v := u64 & ((1 << code.NumBitSize) - 1)
- if v != 0 {
- b = appendStructKey(ctx, code, b)
- b = appendUint(ctx, b, p+uintptr(code.Offset), code)
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructFieldUintString:
- p := load(ctxptr, code.Idx)
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendUint(ctx, b, p+uintptr(code.Offset), code)
- b = append(b, '"')
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyUintString:
- p := load(ctxptr, code.Idx)
- u64 := ptrToUint64(p+uintptr(code.Offset), code.NumBitSize)
- v := u64 & ((1 << code.NumBitSize) - 1)
- if v != 0 {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendUint(ctx, b, p+uintptr(code.Offset), code)
- b = append(b, '"')
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructFieldUintPtr:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- b = appendStructKey(ctx, code, b)
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = appendUint(ctx, b, p, code)
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyUintPtr:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = appendUint(ctx, b, p, code)
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructFieldUintPtrString:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- b = appendStructKey(ctx, code, b)
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = append(b, '"')
- b = appendUint(ctx, b, p, code)
- b = append(b, '"')
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyUintPtrString:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendUint(ctx, b, p, code)
- b = append(b, '"')
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructFieldFloat32:
- p := load(ctxptr, code.Idx)
- b = appendStructKey(ctx, code, b)
- b = appendFloat32(ctx, b, ptrToFloat32(p+uintptr(code.Offset)))
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyFloat32:
- p := load(ctxptr, code.Idx)
- v := ptrToFloat32(p + uintptr(code.Offset))
- if v != 0 {
- b = appendStructKey(ctx, code, b)
- b = appendFloat32(ctx, b, v)
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructFieldFloat32String:
- p := load(ctxptr, code.Idx)
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendFloat32(ctx, b, ptrToFloat32(p+uintptr(code.Offset)))
- b = append(b, '"')
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyFloat32String:
- p := load(ctxptr, code.Idx)
- v := ptrToFloat32(p + uintptr(code.Offset))
- if v != 0 {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendFloat32(ctx, b, v)
- b = append(b, '"')
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructFieldFloat32Ptr:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- b = appendStructKey(ctx, code, b)
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = appendFloat32(ctx, b, ptrToFloat32(p))
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyFloat32Ptr:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = appendFloat32(ctx, b, ptrToFloat32(p))
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructFieldFloat32PtrString:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- b = appendStructKey(ctx, code, b)
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = append(b, '"')
- b = appendFloat32(ctx, b, ptrToFloat32(p))
- b = append(b, '"')
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyFloat32PtrString:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendFloat32(ctx, b, ptrToFloat32(p))
- b = append(b, '"')
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructFieldFloat64:
- p := load(ctxptr, code.Idx)
- b = appendStructKey(ctx, code, b)
- v := ptrToFloat64(p + uintptr(code.Offset))
- if math.IsInf(v, 0) || math.IsNaN(v) {
- return nil, errUnsupportedFloat(v)
- }
- b = appendFloat64(ctx, b, v)
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyFloat64:
- p := load(ctxptr, code.Idx)
- v := ptrToFloat64(p + uintptr(code.Offset))
- if v != 0 {
- if math.IsInf(v, 0) || math.IsNaN(v) {
- return nil, errUnsupportedFloat(v)
- }
- b = appendStructKey(ctx, code, b)
- b = appendFloat64(ctx, b, v)
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructFieldFloat64String:
- p := load(ctxptr, code.Idx)
- v := ptrToFloat64(p + uintptr(code.Offset))
- if math.IsInf(v, 0) || math.IsNaN(v) {
- return nil, errUnsupportedFloat(v)
- }
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendFloat64(ctx, b, v)
- b = append(b, '"')
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyFloat64String:
- p := load(ctxptr, code.Idx)
- v := ptrToFloat64(p + uintptr(code.Offset))
- if v != 0 {
- if math.IsInf(v, 0) || math.IsNaN(v) {
- return nil, errUnsupportedFloat(v)
- }
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendFloat64(ctx, b, v)
- b = append(b, '"')
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructFieldFloat64Ptr:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- b = appendStructKey(ctx, code, b)
- if p == 0 {
- b = appendNullComma(ctx, b)
- code = code.Next
- break
- }
- v := ptrToFloat64(p)
- if math.IsInf(v, 0) || math.IsNaN(v) {
- return nil, errUnsupportedFloat(v)
- }
- b = appendFloat64(ctx, b, v)
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyFloat64Ptr:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- v := ptrToFloat64(p)
- if math.IsInf(v, 0) || math.IsNaN(v) {
- return nil, errUnsupportedFloat(v)
- }
- b = appendFloat64(ctx, b, v)
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructFieldFloat64PtrString:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- b = appendStructKey(ctx, code, b)
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- v := ptrToFloat64(p)
- if math.IsInf(v, 0) || math.IsNaN(v) {
- return nil, errUnsupportedFloat(v)
- }
- b = append(b, '"')
- b = appendFloat64(ctx, b, v)
- b = append(b, '"')
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyFloat64PtrString:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- v := ptrToFloat64(p)
- if math.IsInf(v, 0) || math.IsNaN(v) {
- return nil, errUnsupportedFloat(v)
- }
- b = appendFloat64(ctx, b, v)
- b = append(b, '"')
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructFieldString:
- p := load(ctxptr, code.Idx)
- b = appendStructKey(ctx, code, b)
- b = appendString(ctx, b, ptrToString(p+uintptr(code.Offset)))
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyString:
- p := load(ctxptr, code.Idx)
- v := ptrToString(p + uintptr(code.Offset))
- if v != "" {
- b = appendStructKey(ctx, code, b)
- b = appendString(ctx, b, v)
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructFieldStringString:
- p := load(ctxptr, code.Idx)
- s := ptrToString(p + uintptr(code.Offset))
- b = appendStructKey(ctx, code, b)
- b = appendString(ctx, b, string(appendString(ctx, []byte{}, s)))
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyStringString:
- p := load(ctxptr, code.Idx)
- v := ptrToString(p + uintptr(code.Offset))
- if v != "" {
- b = appendStructKey(ctx, code, b)
- b = appendString(ctx, b, string(appendString(ctx, []byte{}, v)))
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructFieldStringPtr:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- b = appendStructKey(ctx, code, b)
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = appendString(ctx, b, ptrToString(p))
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyStringPtr:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = appendString(ctx, b, ptrToString(p))
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructFieldStringPtrString:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- b = appendStructKey(ctx, code, b)
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = appendString(ctx, b, string(appendString(ctx, []byte{}, ptrToString(p))))
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyStringPtrString:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = appendString(ctx, b, string(appendString(ctx, []byte{}, ptrToString(p))))
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructFieldBool:
- p := load(ctxptr, code.Idx)
- b = appendStructKey(ctx, code, b)
- b = appendBool(ctx, b, ptrToBool(p+uintptr(code.Offset)))
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyBool:
- p := load(ctxptr, code.Idx)
- v := ptrToBool(p + uintptr(code.Offset))
- if v {
- b = appendStructKey(ctx, code, b)
- b = appendBool(ctx, b, v)
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructFieldBoolString:
- p := load(ctxptr, code.Idx)
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendBool(ctx, b, ptrToBool(p+uintptr(code.Offset)))
- b = append(b, '"')
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyBoolString:
- p := load(ctxptr, code.Idx)
- v := ptrToBool(p + uintptr(code.Offset))
- if v {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendBool(ctx, b, v)
- b = append(b, '"')
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructFieldBoolPtr:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- b = appendStructKey(ctx, code, b)
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = appendBool(ctx, b, ptrToBool(p))
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyBoolPtr:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = appendBool(ctx, b, ptrToBool(p))
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructFieldBoolPtrString:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- b = appendStructKey(ctx, code, b)
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = append(b, '"')
- b = appendBool(ctx, b, ptrToBool(p))
- b = append(b, '"')
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyBoolPtrString:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendBool(ctx, b, ptrToBool(p))
- b = append(b, '"')
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructFieldBytes:
- p := load(ctxptr, code.Idx)
- b = appendStructKey(ctx, code, b)
- b = appendByteSlice(ctx, b, ptrToBytes(p+uintptr(code.Offset)))
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyBytes:
- p := load(ctxptr, code.Idx)
- v := ptrToBytes(p + uintptr(code.Offset))
- if len(v) > 0 {
- b = appendStructKey(ctx, code, b)
- b = appendByteSlice(ctx, b, v)
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructFieldBytesPtr:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- b = appendStructKey(ctx, code, b)
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = appendByteSlice(ctx, b, ptrToBytes(p))
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyBytesPtr:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = appendByteSlice(ctx, b, ptrToBytes(p))
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructFieldNumber:
- p := load(ctxptr, code.Idx)
- b = appendStructKey(ctx, code, b)
- bb, err := appendNumber(ctx, b, ptrToNumber(p+uintptr(code.Offset)))
- if err != nil {
- return nil, err
- }
- b = appendComma(ctx, bb)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyNumber:
- p := load(ctxptr, code.Idx)
- v := ptrToNumber(p + uintptr(code.Offset))
- if v != "" {
- b = appendStructKey(ctx, code, b)
- bb, err := appendNumber(ctx, b, v)
- if err != nil {
- return nil, err
- }
- b = appendComma(ctx, bb)
- }
- code = code.Next
- case encoder.OpStructFieldNumberString:
- p := load(ctxptr, code.Idx)
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- bb, err := appendNumber(ctx, b, ptrToNumber(p+uintptr(code.Offset)))
- if err != nil {
- return nil, err
- }
- b = append(bb, '"')
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyNumberString:
- p := load(ctxptr, code.Idx)
- v := ptrToNumber(p + uintptr(code.Offset))
- if v != "" {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- bb, err := appendNumber(ctx, b, v)
- if err != nil {
- return nil, err
- }
- b = append(bb, '"')
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructFieldNumberPtr:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- b = appendStructKey(ctx, code, b)
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- bb, err := appendNumber(ctx, b, ptrToNumber(p))
- if err != nil {
- return nil, err
- }
- b = bb
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyNumberPtr:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- bb, err := appendNumber(ctx, b, ptrToNumber(p))
- if err != nil {
- return nil, err
- }
- b = appendComma(ctx, bb)
- }
- code = code.Next
- case encoder.OpStructFieldNumberPtrString:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- b = appendStructKey(ctx, code, b)
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = append(b, '"')
- bb, err := appendNumber(ctx, b, ptrToNumber(p))
- if err != nil {
- return nil, err
- }
- b = append(bb, '"')
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyNumberPtrString:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- bb, err := appendNumber(ctx, b, ptrToNumber(p))
- if err != nil {
- return nil, err
- }
- b = append(bb, '"')
- b = appendComma(ctx, b)
- }
- code = code.Next
- case encoder.OpStructFieldMarshalJSON:
- p := load(ctxptr, code.Idx)
- b = appendStructKey(ctx, code, b)
- p += uintptr(code.Offset)
- if (code.Flags & encoder.IsNilableTypeFlags) != 0 {
- p = ptrToPtr(p)
- }
- if p == 0 && (code.Flags&encoder.NilCheckFlags) != 0 {
- b = appendNull(ctx, b)
- } else {
- bb, err := appendMarshalJSON(ctx, code, b, ptrToInterface(code, p))
- if err != nil {
- return nil, err
- }
- b = bb
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyMarshalJSON:
- p := load(ctxptr, code.Idx)
- p += uintptr(code.Offset)
- if (code.Flags & encoder.IsNilableTypeFlags) != 0 {
- p = ptrToPtr(p)
- }
- if p == 0 && (code.Flags&encoder.NilCheckFlags) != 0 {
- code = code.NextField
- break
- }
- iface := ptrToInterface(code, p)
- if (code.Flags&encoder.NilCheckFlags) != 0 && encoder.IsNilForMarshaler(iface) {
- code = code.NextField
- break
- }
- b = appendStructKey(ctx, code, b)
- bb, err := appendMarshalJSON(ctx, code, b, iface)
- if err != nil {
- return nil, err
- }
- b = appendComma(ctx, bb)
- code = code.Next
- case encoder.OpStructFieldMarshalJSONPtr:
- p := load(ctxptr, code.Idx)
- b = appendStructKey(ctx, code, b)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- bb, err := appendMarshalJSON(ctx, code, b, ptrToInterface(code, p))
- if err != nil {
- return nil, err
- }
- b = bb
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyMarshalJSONPtr:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- bb, err := appendMarshalJSON(ctx, code, b, ptrToInterface(code, p))
- if err != nil {
- return nil, err
- }
- b = appendComma(ctx, bb)
- }
- code = code.Next
- case encoder.OpStructFieldMarshalText:
- p := load(ctxptr, code.Idx)
- b = appendStructKey(ctx, code, b)
- p += uintptr(code.Offset)
- if (code.Flags & encoder.IsNilableTypeFlags) != 0 {
- p = ptrToPtr(p)
- }
- if p == 0 && (code.Flags&encoder.NilCheckFlags) != 0 {
- b = appendNull(ctx, b)
- } else {
- bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p))
- if err != nil {
- return nil, err
- }
- b = bb
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyMarshalText:
- p := load(ctxptr, code.Idx)
- p += uintptr(code.Offset)
- if (code.Flags & encoder.IsNilableTypeFlags) != 0 {
- p = ptrToPtr(p)
- }
- if p == 0 && (code.Flags&encoder.NilCheckFlags) != 0 {
- code = code.NextField
- break
- }
- b = appendStructKey(ctx, code, b)
- bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p))
- if err != nil {
- return nil, err
- }
- b = appendComma(ctx, bb)
- code = code.Next
- case encoder.OpStructFieldMarshalTextPtr:
- p := load(ctxptr, code.Idx)
- b = appendStructKey(ctx, code, b)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p))
- if err != nil {
- return nil, err
- }
- b = bb
- }
- b = appendComma(ctx, b)
- code = code.Next
- case encoder.OpStructFieldOmitEmptyMarshalTextPtr:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- bb, err := appendMarshalText(ctx, code, b, ptrToInterface(code, p))
- if err != nil {
- return nil, err
- }
- b = appendComma(ctx, bb)
- }
- code = code.Next
- case encoder.OpStructFieldArray:
- b = appendStructKey(ctx, code, b)
- p := load(ctxptr, code.Idx)
- p += uintptr(code.Offset)
- code = code.Next
- store(ctxptr, code.Idx, p)
- case encoder.OpStructFieldOmitEmptyArray:
- b = appendStructKey(ctx, code, b)
- p := load(ctxptr, code.Idx)
- p += uintptr(code.Offset)
- code = code.Next
- store(ctxptr, code.Idx, p)
- case encoder.OpStructFieldArrayPtr:
- b = appendStructKey(ctx, code, b)
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- code = code.Next
- store(ctxptr, code.Idx, p)
- case encoder.OpStructFieldOmitEmptyArrayPtr:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- code = code.Next
- store(ctxptr, code.Idx, p)
- } else {
- code = code.NextField
- }
- case encoder.OpStructFieldSlice:
- b = appendStructKey(ctx, code, b)
- p := load(ctxptr, code.Idx)
- p += uintptr(code.Offset)
- code = code.Next
- store(ctxptr, code.Idx, p)
- case encoder.OpStructFieldOmitEmptySlice:
- p := load(ctxptr, code.Idx)
- p += uintptr(code.Offset)
- slice := ptrToSlice(p)
- if slice.Len == 0 {
- code = code.NextField
- } else {
- b = appendStructKey(ctx, code, b)
- code = code.Next
- store(ctxptr, code.Idx, p)
- }
- case encoder.OpStructFieldSlicePtr:
- b = appendStructKey(ctx, code, b)
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- code = code.Next
- store(ctxptr, code.Idx, p)
- case encoder.OpStructFieldOmitEmptySlicePtr:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- code = code.Next
- store(ctxptr, code.Idx, p)
- } else {
- code = code.NextField
- }
- case encoder.OpStructFieldMap:
- b = appendStructKey(ctx, code, b)
- p := load(ctxptr, code.Idx)
- p = ptrToPtr(p + uintptr(code.Offset))
- code = code.Next
- store(ctxptr, code.Idx, p)
- case encoder.OpStructFieldOmitEmptyMap:
- p := load(ctxptr, code.Idx)
- p = ptrToPtr(p + uintptr(code.Offset))
- if p == 0 || maplen(ptrToUnsafePtr(p)) == 0 {
- code = code.NextField
- } else {
- b = appendStructKey(ctx, code, b)
- code = code.Next
- store(ctxptr, code.Idx, p)
- }
- case encoder.OpStructFieldMapPtr:
- b = appendStructKey(ctx, code, b)
- p := load(ctxptr, code.Idx)
- p = ptrToPtr(p + uintptr(code.Offset))
- if p != 0 {
- p = ptrToNPtr(p, code.PtrNum)
- }
- code = code.Next
- store(ctxptr, code.Idx, p)
- case encoder.OpStructFieldOmitEmptyMapPtr:
- p := load(ctxptr, code.Idx)
- p = ptrToPtr(p + uintptr(code.Offset))
- if p != 0 {
- p = ptrToNPtr(p, code.PtrNum)
- }
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- code = code.Next
- store(ctxptr, code.Idx, p)
- } else {
- code = code.NextField
- }
- case encoder.OpStructFieldStruct:
- b = appendStructKey(ctx, code, b)
- p := load(ctxptr, code.Idx)
- p += uintptr(code.Offset)
- code = code.Next
- store(ctxptr, code.Idx, p)
- case encoder.OpStructFieldOmitEmptyStruct:
- p := load(ctxptr, code.Idx)
- p += uintptr(code.Offset)
- if ptrToPtr(p) == 0 && (code.Flags&encoder.IsNextOpPtrTypeFlags) != 0 {
- code = code.NextField
- } else {
- b = appendStructKey(ctx, code, b)
- code = code.Next
- store(ctxptr, code.Idx, p)
- }
- case encoder.OpStructEnd:
- b = appendStructEndSkipLast(ctx, code, b)
- code = code.Next
- case encoder.OpStructEndInt:
- p := load(ctxptr, code.Idx)
- b = appendStructKey(ctx, code, b)
- b = appendInt(ctx, b, p+uintptr(code.Offset), code)
- b = appendStructEnd(ctx, code, b)
- code = code.Next
- case encoder.OpStructEndOmitEmptyInt:
- p := load(ctxptr, code.Idx)
- u64 := ptrToUint64(p+uintptr(code.Offset), code.NumBitSize)
- v := u64 & ((1 << code.NumBitSize) - 1)
- if v != 0 {
- b = appendStructKey(ctx, code, b)
- b = appendInt(ctx, b, p+uintptr(code.Offset), code)
- b = appendStructEnd(ctx, code, b)
- } else {
- b = appendStructEndSkipLast(ctx, code, b)
- }
- code = code.Next
- case encoder.OpStructEndIntString:
- p := load(ctxptr, code.Idx)
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendInt(ctx, b, p+uintptr(code.Offset), code)
- b = append(b, '"')
- b = appendStructEnd(ctx, code, b)
- code = code.Next
- case encoder.OpStructEndOmitEmptyIntString:
- p := load(ctxptr, code.Idx)
- u64 := ptrToUint64(p+uintptr(code.Offset), code.NumBitSize)
- v := u64 & ((1 << code.NumBitSize) - 1)
- if v != 0 {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendInt(ctx, b, p+uintptr(code.Offset), code)
- b = append(b, '"')
- b = appendStructEnd(ctx, code, b)
- } else {
- b = appendStructEndSkipLast(ctx, code, b)
- }
- code = code.Next
- case encoder.OpStructEndIntPtr:
- b = appendStructKey(ctx, code, b)
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = appendInt(ctx, b, p, code)
- }
- b = appendStructEnd(ctx, code, b)
- code = code.Next
- case encoder.OpStructEndOmitEmptyIntPtr:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = appendInt(ctx, b, p, code)
- b = appendStructEnd(ctx, code, b)
- } else {
- b = appendStructEndSkipLast(ctx, code, b)
- }
- code = code.Next
- case encoder.OpStructEndIntPtrString:
- b = appendStructKey(ctx, code, b)
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = append(b, '"')
- b = appendInt(ctx, b, p, code)
- b = append(b, '"')
- }
- b = appendStructEnd(ctx, code, b)
- code = code.Next
- case encoder.OpStructEndOmitEmptyIntPtrString:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendInt(ctx, b, p, code)
- b = append(b, '"')
- b = appendStructEnd(ctx, code, b)
- } else {
- b = appendStructEndSkipLast(ctx, code, b)
- }
- code = code.Next
- case encoder.OpStructEndUint:
- p := load(ctxptr, code.Idx)
- b = appendStructKey(ctx, code, b)
- b = appendUint(ctx, b, p+uintptr(code.Offset), code)
- b = appendStructEnd(ctx, code, b)
- code = code.Next
- case encoder.OpStructEndOmitEmptyUint:
- p := load(ctxptr, code.Idx)
- u64 := ptrToUint64(p+uintptr(code.Offset), code.NumBitSize)
- v := u64 & ((1 << code.NumBitSize) - 1)
- if v != 0 {
- b = appendStructKey(ctx, code, b)
- b = appendUint(ctx, b, p+uintptr(code.Offset), code)
- b = appendStructEnd(ctx, code, b)
- } else {
- b = appendStructEndSkipLast(ctx, code, b)
- }
- code = code.Next
- case encoder.OpStructEndUintString:
- p := load(ctxptr, code.Idx)
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendUint(ctx, b, p+uintptr(code.Offset), code)
- b = append(b, '"')
- b = appendStructEnd(ctx, code, b)
- code = code.Next
- case encoder.OpStructEndOmitEmptyUintString:
- p := load(ctxptr, code.Idx)
- u64 := ptrToUint64(p+uintptr(code.Offset), code.NumBitSize)
- v := u64 & ((1 << code.NumBitSize) - 1)
- if v != 0 {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendUint(ctx, b, p+uintptr(code.Offset), code)
- b = append(b, '"')
- b = appendStructEnd(ctx, code, b)
- } else {
- b = appendStructEndSkipLast(ctx, code, b)
- }
- code = code.Next
- case encoder.OpStructEndUintPtr:
- b = appendStructKey(ctx, code, b)
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = appendUint(ctx, b, p, code)
- }
- b = appendStructEnd(ctx, code, b)
- code = code.Next
- case encoder.OpStructEndOmitEmptyUintPtr:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = appendUint(ctx, b, p, code)
- b = appendStructEnd(ctx, code, b)
- } else {
- b = appendStructEndSkipLast(ctx, code, b)
- }
- code = code.Next
- case encoder.OpStructEndUintPtrString:
- b = appendStructKey(ctx, code, b)
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = append(b, '"')
- b = appendUint(ctx, b, p, code)
- b = append(b, '"')
- }
- b = appendStructEnd(ctx, code, b)
- code = code.Next
- case encoder.OpStructEndOmitEmptyUintPtrString:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendUint(ctx, b, p, code)
- b = append(b, '"')
- b = appendStructEnd(ctx, code, b)
- } else {
- b = appendStructEndSkipLast(ctx, code, b)
- }
- code = code.Next
- case encoder.OpStructEndFloat32:
- p := load(ctxptr, code.Idx)
- b = appendStructKey(ctx, code, b)
- b = appendFloat32(ctx, b, ptrToFloat32(p+uintptr(code.Offset)))
- b = appendStructEnd(ctx, code, b)
- code = code.Next
- case encoder.OpStructEndOmitEmptyFloat32:
- p := load(ctxptr, code.Idx)
- v := ptrToFloat32(p + uintptr(code.Offset))
- if v != 0 {
- b = appendStructKey(ctx, code, b)
- b = appendFloat32(ctx, b, v)
- b = appendStructEnd(ctx, code, b)
- } else {
- b = appendStructEndSkipLast(ctx, code, b)
- }
- code = code.Next
- case encoder.OpStructEndFloat32String:
- p := load(ctxptr, code.Idx)
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendFloat32(ctx, b, ptrToFloat32(p+uintptr(code.Offset)))
- b = append(b, '"')
- b = appendStructEnd(ctx, code, b)
- code = code.Next
- case encoder.OpStructEndOmitEmptyFloat32String:
- p := load(ctxptr, code.Idx)
- v := ptrToFloat32(p + uintptr(code.Offset))
- if v != 0 {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendFloat32(ctx, b, v)
- b = append(b, '"')
- b = appendStructEnd(ctx, code, b)
- } else {
- b = appendStructEndSkipLast(ctx, code, b)
- }
- code = code.Next
- case encoder.OpStructEndFloat32Ptr:
- b = appendStructKey(ctx, code, b)
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = appendFloat32(ctx, b, ptrToFloat32(p))
- }
- b = appendStructEnd(ctx, code, b)
- code = code.Next
- case encoder.OpStructEndOmitEmptyFloat32Ptr:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = appendFloat32(ctx, b, ptrToFloat32(p))
- b = appendStructEnd(ctx, code, b)
- } else {
- b = appendStructEndSkipLast(ctx, code, b)
- }
- code = code.Next
- case encoder.OpStructEndFloat32PtrString:
- b = appendStructKey(ctx, code, b)
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = append(b, '"')
- b = appendFloat32(ctx, b, ptrToFloat32(p))
- b = append(b, '"')
- }
- b = appendStructEnd(ctx, code, b)
- code = code.Next
- case encoder.OpStructEndOmitEmptyFloat32PtrString:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendFloat32(ctx, b, ptrToFloat32(p))
- b = append(b, '"')
- b = appendStructEnd(ctx, code, b)
- } else {
- b = appendStructEndSkipLast(ctx, code, b)
- }
- code = code.Next
- case encoder.OpStructEndFloat64:
- p := load(ctxptr, code.Idx)
- v := ptrToFloat64(p + uintptr(code.Offset))
- if math.IsInf(v, 0) || math.IsNaN(v) {
- return nil, errUnsupportedFloat(v)
- }
- b = appendStructKey(ctx, code, b)
- b = appendFloat64(ctx, b, v)
- b = appendStructEnd(ctx, code, b)
- code = code.Next
- case encoder.OpStructEndOmitEmptyFloat64:
- p := load(ctxptr, code.Idx)
- v := ptrToFloat64(p + uintptr(code.Offset))
- if v != 0 {
- if math.IsInf(v, 0) || math.IsNaN(v) {
- return nil, errUnsupportedFloat(v)
- }
- b = appendStructKey(ctx, code, b)
- b = appendFloat64(ctx, b, v)
- b = appendStructEnd(ctx, code, b)
- } else {
- b = appendStructEndSkipLast(ctx, code, b)
- }
- code = code.Next
- case encoder.OpStructEndFloat64String:
- p := load(ctxptr, code.Idx)
- v := ptrToFloat64(p + uintptr(code.Offset))
- if math.IsInf(v, 0) || math.IsNaN(v) {
- return nil, errUnsupportedFloat(v)
- }
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendFloat64(ctx, b, v)
- b = append(b, '"')
- b = appendStructEnd(ctx, code, b)
- code = code.Next
- case encoder.OpStructEndOmitEmptyFloat64String:
- p := load(ctxptr, code.Idx)
- v := ptrToFloat64(p + uintptr(code.Offset))
- if v != 0 {
- if math.IsInf(v, 0) || math.IsNaN(v) {
- return nil, errUnsupportedFloat(v)
- }
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendFloat64(ctx, b, v)
- b = append(b, '"')
- b = appendStructEnd(ctx, code, b)
- } else {
- b = appendStructEndSkipLast(ctx, code, b)
- }
- code = code.Next
- case encoder.OpStructEndFloat64Ptr:
- b = appendStructKey(ctx, code, b)
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p == 0 {
- b = appendNull(ctx, b)
- b = appendStructEnd(ctx, code, b)
- code = code.Next
- break
- }
- v := ptrToFloat64(p)
- if math.IsInf(v, 0) || math.IsNaN(v) {
- return nil, errUnsupportedFloat(v)
- }
- b = appendFloat64(ctx, b, v)
- b = appendStructEnd(ctx, code, b)
- code = code.Next
- case encoder.OpStructEndOmitEmptyFloat64Ptr:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- v := ptrToFloat64(p)
- if math.IsInf(v, 0) || math.IsNaN(v) {
- return nil, errUnsupportedFloat(v)
- }
- b = appendFloat64(ctx, b, v)
- b = appendStructEnd(ctx, code, b)
- } else {
- b = appendStructEndSkipLast(ctx, code, b)
- }
- code = code.Next
- case encoder.OpStructEndFloat64PtrString:
- b = appendStructKey(ctx, code, b)
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = append(b, '"')
- v := ptrToFloat64(p)
- if math.IsInf(v, 0) || math.IsNaN(v) {
- return nil, errUnsupportedFloat(v)
- }
- b = appendFloat64(ctx, b, v)
- b = append(b, '"')
- }
- b = appendStructEnd(ctx, code, b)
- code = code.Next
- case encoder.OpStructEndOmitEmptyFloat64PtrString:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- v := ptrToFloat64(p)
- if math.IsInf(v, 0) || math.IsNaN(v) {
- return nil, errUnsupportedFloat(v)
- }
- b = append(b, '"')
- b = appendFloat64(ctx, b, v)
- b = append(b, '"')
- b = appendStructEnd(ctx, code, b)
- } else {
- b = appendStructEndSkipLast(ctx, code, b)
- }
- code = code.Next
- case encoder.OpStructEndString:
- p := load(ctxptr, code.Idx)
- b = appendStructKey(ctx, code, b)
- b = appendString(ctx, b, ptrToString(p+uintptr(code.Offset)))
- b = appendStructEnd(ctx, code, b)
- code = code.Next
- case encoder.OpStructEndOmitEmptyString:
- p := load(ctxptr, code.Idx)
- v := ptrToString(p + uintptr(code.Offset))
- if v != "" {
- b = appendStructKey(ctx, code, b)
- b = appendString(ctx, b, v)
- b = appendStructEnd(ctx, code, b)
- } else {
- b = appendStructEndSkipLast(ctx, code, b)
- }
- code = code.Next
- case encoder.OpStructEndStringString:
- p := load(ctxptr, code.Idx)
- b = appendStructKey(ctx, code, b)
- s := ptrToString(p + uintptr(code.Offset))
- b = appendString(ctx, b, string(appendString(ctx, []byte{}, s)))
- b = appendStructEnd(ctx, code, b)
- code = code.Next
- case encoder.OpStructEndOmitEmptyStringString:
- p := load(ctxptr, code.Idx)
- v := ptrToString(p + uintptr(code.Offset))
- if v != "" {
- b = appendStructKey(ctx, code, b)
- b = appendString(ctx, b, string(appendString(ctx, []byte{}, v)))
- b = appendStructEnd(ctx, code, b)
- } else {
- b = appendStructEndSkipLast(ctx, code, b)
- }
- code = code.Next
- case encoder.OpStructEndStringPtr:
- b = appendStructKey(ctx, code, b)
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = appendString(ctx, b, ptrToString(p))
- }
- b = appendStructEnd(ctx, code, b)
- code = code.Next
- case encoder.OpStructEndOmitEmptyStringPtr:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = appendString(ctx, b, ptrToString(p))
- b = appendStructEnd(ctx, code, b)
- } else {
- b = appendStructEndSkipLast(ctx, code, b)
- }
- code = code.Next
- case encoder.OpStructEndStringPtrString:
- b = appendStructKey(ctx, code, b)
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = appendString(ctx, b, string(appendString(ctx, []byte{}, ptrToString(p))))
- }
- b = appendStructEnd(ctx, code, b)
- code = code.Next
- case encoder.OpStructEndOmitEmptyStringPtrString:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = appendString(ctx, b, string(appendString(ctx, []byte{}, ptrToString(p))))
- b = appendStructEnd(ctx, code, b)
- } else {
- b = appendStructEndSkipLast(ctx, code, b)
- }
- code = code.Next
- case encoder.OpStructEndBool:
- p := load(ctxptr, code.Idx)
- b = appendStructKey(ctx, code, b)
- b = appendBool(ctx, b, ptrToBool(p+uintptr(code.Offset)))
- b = appendStructEnd(ctx, code, b)
- code = code.Next
- case encoder.OpStructEndOmitEmptyBool:
- p := load(ctxptr, code.Idx)
- v := ptrToBool(p + uintptr(code.Offset))
- if v {
- b = appendStructKey(ctx, code, b)
- b = appendBool(ctx, b, v)
- b = appendStructEnd(ctx, code, b)
- } else {
- b = appendStructEndSkipLast(ctx, code, b)
- }
- code = code.Next
- case encoder.OpStructEndBoolString:
- p := load(ctxptr, code.Idx)
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendBool(ctx, b, ptrToBool(p+uintptr(code.Offset)))
- b = append(b, '"')
- b = appendStructEnd(ctx, code, b)
- code = code.Next
- case encoder.OpStructEndOmitEmptyBoolString:
- p := load(ctxptr, code.Idx)
- v := ptrToBool(p + uintptr(code.Offset))
- if v {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendBool(ctx, b, v)
- b = append(b, '"')
- b = appendStructEnd(ctx, code, b)
- } else {
- b = appendStructEndSkipLast(ctx, code, b)
- }
- code = code.Next
- case encoder.OpStructEndBoolPtr:
- b = appendStructKey(ctx, code, b)
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = appendBool(ctx, b, ptrToBool(p))
- }
- b = appendStructEnd(ctx, code, b)
- code = code.Next
- case encoder.OpStructEndOmitEmptyBoolPtr:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = appendBool(ctx, b, ptrToBool(p))
- b = appendStructEnd(ctx, code, b)
- } else {
- b = appendStructEndSkipLast(ctx, code, b)
- }
- code = code.Next
- case encoder.OpStructEndBoolPtrString:
- b = appendStructKey(ctx, code, b)
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = append(b, '"')
- b = appendBool(ctx, b, ptrToBool(p))
- b = append(b, '"')
- }
- b = appendStructEnd(ctx, code, b)
- code = code.Next
- case encoder.OpStructEndOmitEmptyBoolPtrString:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- b = appendBool(ctx, b, ptrToBool(p))
- b = append(b, '"')
- b = appendStructEnd(ctx, code, b)
- } else {
- b = appendStructEndSkipLast(ctx, code, b)
- }
- code = code.Next
- case encoder.OpStructEndBytes:
- p := load(ctxptr, code.Idx)
- b = appendStructKey(ctx, code, b)
- b = appendByteSlice(ctx, b, ptrToBytes(p+uintptr(code.Offset)))
- b = appendStructEnd(ctx, code, b)
- code = code.Next
- case encoder.OpStructEndOmitEmptyBytes:
- p := load(ctxptr, code.Idx)
- v := ptrToBytes(p + uintptr(code.Offset))
- if len(v) > 0 {
- b = appendStructKey(ctx, code, b)
- b = appendByteSlice(ctx, b, v)
- b = appendStructEnd(ctx, code, b)
- } else {
- b = appendStructEndSkipLast(ctx, code, b)
- }
- code = code.Next
- case encoder.OpStructEndBytesPtr:
- b = appendStructKey(ctx, code, b)
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = appendByteSlice(ctx, b, ptrToBytes(p))
- }
- b = appendStructEnd(ctx, code, b)
- code = code.Next
- case encoder.OpStructEndOmitEmptyBytesPtr:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = appendByteSlice(ctx, b, ptrToBytes(p))
- b = appendStructEnd(ctx, code, b)
- } else {
- b = appendStructEndSkipLast(ctx, code, b)
- }
- code = code.Next
- case encoder.OpStructEndNumber:
- p := load(ctxptr, code.Idx)
- b = appendStructKey(ctx, code, b)
- bb, err := appendNumber(ctx, b, ptrToNumber(p+uintptr(code.Offset)))
- if err != nil {
- return nil, err
- }
- b = appendStructEnd(ctx, code, bb)
- code = code.Next
- case encoder.OpStructEndOmitEmptyNumber:
- p := load(ctxptr, code.Idx)
- v := ptrToNumber(p + uintptr(code.Offset))
- if v != "" {
- b = appendStructKey(ctx, code, b)
- bb, err := appendNumber(ctx, b, v)
- if err != nil {
- return nil, err
- }
- b = appendStructEnd(ctx, code, bb)
- } else {
- b = appendStructEndSkipLast(ctx, code, b)
- }
- code = code.Next
- case encoder.OpStructEndNumberString:
- p := load(ctxptr, code.Idx)
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- bb, err := appendNumber(ctx, b, ptrToNumber(p+uintptr(code.Offset)))
- if err != nil {
- return nil, err
- }
- b = append(bb, '"')
- b = appendStructEnd(ctx, code, b)
- code = code.Next
- case encoder.OpStructEndOmitEmptyNumberString:
- p := load(ctxptr, code.Idx)
- v := ptrToNumber(p + uintptr(code.Offset))
- if v != "" {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- bb, err := appendNumber(ctx, b, v)
- if err != nil {
- return nil, err
- }
- b = append(bb, '"')
- b = appendStructEnd(ctx, code, b)
- } else {
- b = appendStructEndSkipLast(ctx, code, b)
- }
- code = code.Next
- case encoder.OpStructEndNumberPtr:
- b = appendStructKey(ctx, code, b)
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- bb, err := appendNumber(ctx, b, ptrToNumber(p))
- if err != nil {
- return nil, err
- }
- b = bb
- }
- b = appendStructEnd(ctx, code, b)
- code = code.Next
- case encoder.OpStructEndOmitEmptyNumberPtr:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- bb, err := appendNumber(ctx, b, ptrToNumber(p))
- if err != nil {
- return nil, err
- }
- b = appendStructEnd(ctx, code, bb)
- } else {
- b = appendStructEndSkipLast(ctx, code, b)
- }
- code = code.Next
- case encoder.OpStructEndNumberPtrString:
- b = appendStructKey(ctx, code, b)
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p == 0 {
- b = appendNull(ctx, b)
- } else {
- b = append(b, '"')
- bb, err := appendNumber(ctx, b, ptrToNumber(p))
- if err != nil {
- return nil, err
- }
- b = append(bb, '"')
- }
- b = appendStructEnd(ctx, code, b)
- code = code.Next
- case encoder.OpStructEndOmitEmptyNumberPtrString:
- p := load(ctxptr, code.Idx)
- p = ptrToNPtr(p+uintptr(code.Offset), code.PtrNum)
- if p != 0 {
- b = appendStructKey(ctx, code, b)
- b = append(b, '"')
- bb, err := appendNumber(ctx, b, ptrToNumber(p))
- if err != nil {
- return nil, err
- }
- b = append(bb, '"')
- b = appendStructEnd(ctx, code, b)
- } else {
- b = appendStructEndSkipLast(ctx, code, b)
- }
- code = code.Next
- case encoder.OpEnd:
- goto END
- }
- }
-END:
- return b, nil
-}
diff --git a/vendor/github.com/goccy/go-json/internal/errors/error.go b/vendor/github.com/goccy/go-json/internal/errors/error.go
deleted file mode 100644
index 9207d0ff..00000000
--- a/vendor/github.com/goccy/go-json/internal/errors/error.go
+++ /dev/null
@@ -1,183 +0,0 @@
-package errors
-
-import (
- "fmt"
- "reflect"
- "strconv"
-)
-
-type InvalidUTF8Error struct {
- S string // the whole string value that caused the error
-}
-
-func (e *InvalidUTF8Error) Error() string {
- return fmt.Sprintf("json: invalid UTF-8 in string: %s", strconv.Quote(e.S))
-}
-
-type InvalidUnmarshalError struct {
- Type reflect.Type
-}
-
-func (e *InvalidUnmarshalError) Error() string {
- if e.Type == nil {
- return "json: Unmarshal(nil)"
- }
-
- if e.Type.Kind() != reflect.Ptr {
- return fmt.Sprintf("json: Unmarshal(non-pointer %s)", e.Type)
- }
- return fmt.Sprintf("json: Unmarshal(nil %s)", e.Type)
-}
-
-// A MarshalerError represents an error from calling a MarshalJSON or MarshalText method.
-type MarshalerError struct {
- Type reflect.Type
- Err error
- sourceFunc string
-}
-
-func (e *MarshalerError) Error() string {
- srcFunc := e.sourceFunc
- if srcFunc == "" {
- srcFunc = "MarshalJSON"
- }
- return fmt.Sprintf("json: error calling %s for type %s: %s", srcFunc, e.Type, e.Err.Error())
-}
-
-// Unwrap returns the underlying error.
-func (e *MarshalerError) Unwrap() error { return e.Err }
-
-// A SyntaxError is a description of a JSON syntax error.
-type SyntaxError struct {
- msg string // description of error
- Offset int64 // error occurred after reading Offset bytes
-}
-
-func (e *SyntaxError) Error() string { return e.msg }
-
-// An UnmarshalFieldError describes a JSON object key that
-// led to an unexported (and therefore unwritable) struct field.
-//
-// Deprecated: No longer used; kept for compatibility.
-type UnmarshalFieldError struct {
- Key string
- Type reflect.Type
- Field reflect.StructField
-}
-
-func (e *UnmarshalFieldError) Error() string {
- return fmt.Sprintf("json: cannot unmarshal object key %s into unexported field %s of type %s",
- strconv.Quote(e.Key), e.Field.Name, e.Type.String(),
- )
-}
-
-// An UnmarshalTypeError describes a JSON value that was
-// not appropriate for a value of a specific Go type.
-type UnmarshalTypeError struct {
- Value string // description of JSON value - "bool", "array", "number -5"
- Type reflect.Type // type of Go value it could not be assigned to
- Offset int64 // error occurred after reading Offset bytes
- Struct string // name of the struct type containing the field
- Field string // the full path from root node to the field
-}
-
-func (e *UnmarshalTypeError) Error() string {
- if e.Struct != "" || e.Field != "" {
- return fmt.Sprintf("json: cannot unmarshal %s into Go struct field %s.%s of type %s",
- e.Value, e.Struct, e.Field, e.Type,
- )
- }
- return fmt.Sprintf("json: cannot unmarshal %s into Go value of type %s", e.Value, e.Type)
-}
-
-// An UnsupportedTypeError is returned by Marshal when attempting
-// to encode an unsupported value type.
-type UnsupportedTypeError struct {
- Type reflect.Type
-}
-
-func (e *UnsupportedTypeError) Error() string {
- return fmt.Sprintf("json: unsupported type: %s", e.Type)
-}
-
-type UnsupportedValueError struct {
- Value reflect.Value
- Str string
-}
-
-func (e *UnsupportedValueError) Error() string {
- return fmt.Sprintf("json: unsupported value: %s", e.Str)
-}
-
-func ErrSyntax(msg string, offset int64) *SyntaxError {
- return &SyntaxError{msg: msg, Offset: offset}
-}
-
-func ErrMarshaler(typ reflect.Type, err error, msg string) *MarshalerError {
- return &MarshalerError{
- Type: typ,
- Err: err,
- sourceFunc: msg,
- }
-}
-
-func ErrExceededMaxDepth(c byte, cursor int64) *SyntaxError {
- return &SyntaxError{
- msg: fmt.Sprintf(`invalid character "%c" exceeded max depth`, c),
- Offset: cursor,
- }
-}
-
-func ErrNotAtBeginningOfValue(cursor int64) *SyntaxError {
- return &SyntaxError{msg: "not at beginning of value", Offset: cursor}
-}
-
-func ErrUnexpectedEndOfJSON(msg string, cursor int64) *SyntaxError {
- return &SyntaxError{
- msg: fmt.Sprintf("json: %s unexpected end of JSON input", msg),
- Offset: cursor,
- }
-}
-
-func ErrExpected(msg string, cursor int64) *SyntaxError {
- return &SyntaxError{msg: fmt.Sprintf("expected %s", msg), Offset: cursor}
-}
-
-func ErrInvalidCharacter(c byte, context string, cursor int64) *SyntaxError {
- if c == 0 {
- return &SyntaxError{
- msg: fmt.Sprintf("json: invalid character as %s", context),
- Offset: cursor,
- }
- }
- return &SyntaxError{
- msg: fmt.Sprintf("json: invalid character %c as %s", c, context),
- Offset: cursor,
- }
-}
-
-func ErrInvalidBeginningOfValue(c byte, cursor int64) *SyntaxError {
- return &SyntaxError{
- msg: fmt.Sprintf("invalid character '%c' looking for beginning of value", c),
- Offset: cursor,
- }
-}
-
-type PathError struct {
- msg string
-}
-
-func (e *PathError) Error() string {
- return fmt.Sprintf("json: invalid path format: %s", e.msg)
-}
-
-func ErrInvalidPath(msg string, args ...interface{}) *PathError {
- if len(args) != 0 {
- return &PathError{msg: fmt.Sprintf(msg, args...)}
- }
- return &PathError{msg: msg}
-}
-
-func ErrEmptyPath() *PathError {
- return &PathError{msg: "path is empty"}
-}
diff --git a/vendor/github.com/goccy/go-json/internal/runtime/rtype.go b/vendor/github.com/goccy/go-json/internal/runtime/rtype.go
deleted file mode 100644
index 37cfe35a..00000000
--- a/vendor/github.com/goccy/go-json/internal/runtime/rtype.go
+++ /dev/null
@@ -1,262 +0,0 @@
-package runtime
-
-import (
- "reflect"
- "unsafe"
-)
-
-// Type representing reflect.rtype for noescape trick
-type Type struct{}
-
-//go:linkname rtype_Align reflect.(*rtype).Align
-//go:noescape
-func rtype_Align(*Type) int
-
-func (t *Type) Align() int {
- return rtype_Align(t)
-}
-
-//go:linkname rtype_FieldAlign reflect.(*rtype).FieldAlign
-//go:noescape
-func rtype_FieldAlign(*Type) int
-
-func (t *Type) FieldAlign() int {
- return rtype_FieldAlign(t)
-}
-
-//go:linkname rtype_Method reflect.(*rtype).Method
-//go:noescape
-func rtype_Method(*Type, int) reflect.Method
-
-func (t *Type) Method(a0 int) reflect.Method {
- return rtype_Method(t, a0)
-}
-
-//go:linkname rtype_MethodByName reflect.(*rtype).MethodByName
-//go:noescape
-func rtype_MethodByName(*Type, string) (reflect.Method, bool)
-
-func (t *Type) MethodByName(a0 string) (reflect.Method, bool) {
- return rtype_MethodByName(t, a0)
-}
-
-//go:linkname rtype_NumMethod reflect.(*rtype).NumMethod
-//go:noescape
-func rtype_NumMethod(*Type) int
-
-func (t *Type) NumMethod() int {
- return rtype_NumMethod(t)
-}
-
-//go:linkname rtype_Name reflect.(*rtype).Name
-//go:noescape
-func rtype_Name(*Type) string
-
-func (t *Type) Name() string {
- return rtype_Name(t)
-}
-
-//go:linkname rtype_PkgPath reflect.(*rtype).PkgPath
-//go:noescape
-func rtype_PkgPath(*Type) string
-
-func (t *Type) PkgPath() string {
- return rtype_PkgPath(t)
-}
-
-//go:linkname rtype_Size reflect.(*rtype).Size
-//go:noescape
-func rtype_Size(*Type) uintptr
-
-func (t *Type) Size() uintptr {
- return rtype_Size(t)
-}
-
-//go:linkname rtype_String reflect.(*rtype).String
-//go:noescape
-func rtype_String(*Type) string
-
-func (t *Type) String() string {
- return rtype_String(t)
-}
-
-//go:linkname rtype_Kind reflect.(*rtype).Kind
-//go:noescape
-func rtype_Kind(*Type) reflect.Kind
-
-func (t *Type) Kind() reflect.Kind {
- return rtype_Kind(t)
-}
-
-//go:linkname rtype_Implements reflect.(*rtype).Implements
-//go:noescape
-func rtype_Implements(*Type, reflect.Type) bool
-
-func (t *Type) Implements(u reflect.Type) bool {
- return rtype_Implements(t, u)
-}
-
-//go:linkname rtype_AssignableTo reflect.(*rtype).AssignableTo
-//go:noescape
-func rtype_AssignableTo(*Type, reflect.Type) bool
-
-func (t *Type) AssignableTo(u reflect.Type) bool {
- return rtype_AssignableTo(t, u)
-}
-
-//go:linkname rtype_ConvertibleTo reflect.(*rtype).ConvertibleTo
-//go:noescape
-func rtype_ConvertibleTo(*Type, reflect.Type) bool
-
-func (t *Type) ConvertibleTo(u reflect.Type) bool {
- return rtype_ConvertibleTo(t, u)
-}
-
-//go:linkname rtype_Comparable reflect.(*rtype).Comparable
-//go:noescape
-func rtype_Comparable(*Type) bool
-
-func (t *Type) Comparable() bool {
- return rtype_Comparable(t)
-}
-
-//go:linkname rtype_Bits reflect.(*rtype).Bits
-//go:noescape
-func rtype_Bits(*Type) int
-
-func (t *Type) Bits() int {
- return rtype_Bits(t)
-}
-
-//go:linkname rtype_ChanDir reflect.(*rtype).ChanDir
-//go:noescape
-func rtype_ChanDir(*Type) reflect.ChanDir
-
-func (t *Type) ChanDir() reflect.ChanDir {
- return rtype_ChanDir(t)
-}
-
-//go:linkname rtype_IsVariadic reflect.(*rtype).IsVariadic
-//go:noescape
-func rtype_IsVariadic(*Type) bool
-
-func (t *Type) IsVariadic() bool {
- return rtype_IsVariadic(t)
-}
-
-//go:linkname rtype_Elem reflect.(*rtype).Elem
-//go:noescape
-func rtype_Elem(*Type) reflect.Type
-
-func (t *Type) Elem() *Type {
- return Type2RType(rtype_Elem(t))
-}
-
-//go:linkname rtype_Field reflect.(*rtype).Field
-//go:noescape
-func rtype_Field(*Type, int) reflect.StructField
-
-func (t *Type) Field(i int) reflect.StructField {
- return rtype_Field(t, i)
-}
-
-//go:linkname rtype_FieldByIndex reflect.(*rtype).FieldByIndex
-//go:noescape
-func rtype_FieldByIndex(*Type, []int) reflect.StructField
-
-func (t *Type) FieldByIndex(index []int) reflect.StructField {
- return rtype_FieldByIndex(t, index)
-}
-
-//go:linkname rtype_FieldByName reflect.(*rtype).FieldByName
-//go:noescape
-func rtype_FieldByName(*Type, string) (reflect.StructField, bool)
-
-func (t *Type) FieldByName(name string) (reflect.StructField, bool) {
- return rtype_FieldByName(t, name)
-}
-
-//go:linkname rtype_FieldByNameFunc reflect.(*rtype).FieldByNameFunc
-//go:noescape
-func rtype_FieldByNameFunc(*Type, func(string) bool) (reflect.StructField, bool)
-
-func (t *Type) FieldByNameFunc(match func(string) bool) (reflect.StructField, bool) {
- return rtype_FieldByNameFunc(t, match)
-}
-
-//go:linkname rtype_In reflect.(*rtype).In
-//go:noescape
-func rtype_In(*Type, int) reflect.Type
-
-func (t *Type) In(i int) reflect.Type {
- return rtype_In(t, i)
-}
-
-//go:linkname rtype_Key reflect.(*rtype).Key
-//go:noescape
-func rtype_Key(*Type) reflect.Type
-
-func (t *Type) Key() *Type {
- return Type2RType(rtype_Key(t))
-}
-
-//go:linkname rtype_Len reflect.(*rtype).Len
-//go:noescape
-func rtype_Len(*Type) int
-
-func (t *Type) Len() int {
- return rtype_Len(t)
-}
-
-//go:linkname rtype_NumField reflect.(*rtype).NumField
-//go:noescape
-func rtype_NumField(*Type) int
-
-func (t *Type) NumField() int {
- return rtype_NumField(t)
-}
-
-//go:linkname rtype_NumIn reflect.(*rtype).NumIn
-//go:noescape
-func rtype_NumIn(*Type) int
-
-func (t *Type) NumIn() int {
- return rtype_NumIn(t)
-}
-
-//go:linkname rtype_NumOut reflect.(*rtype).NumOut
-//go:noescape
-func rtype_NumOut(*Type) int
-
-func (t *Type) NumOut() int {
- return rtype_NumOut(t)
-}
-
-//go:linkname rtype_Out reflect.(*rtype).Out
-//go:noescape
-func rtype_Out(*Type, int) reflect.Type
-
-//go:linkname PtrTo reflect.(*rtype).ptrTo
-//go:noescape
-func PtrTo(*Type) *Type
-
-func (t *Type) Out(i int) reflect.Type {
- return rtype_Out(t, i)
-}
-
-//go:linkname IfaceIndir reflect.ifaceIndir
-//go:noescape
-func IfaceIndir(*Type) bool
-
-//go:linkname RType2Type reflect.toType
-//go:noescape
-func RType2Type(t *Type) reflect.Type
-
-type emptyInterface struct {
- _ *Type
- ptr unsafe.Pointer
-}
-
-func Type2RType(t reflect.Type) *Type {
- return (*Type)(((*emptyInterface)(unsafe.Pointer(&t))).ptr)
-}
diff --git a/vendor/github.com/goccy/go-json/internal/runtime/struct_field.go b/vendor/github.com/goccy/go-json/internal/runtime/struct_field.go
deleted file mode 100644
index baab0c59..00000000
--- a/vendor/github.com/goccy/go-json/internal/runtime/struct_field.go
+++ /dev/null
@@ -1,91 +0,0 @@
-package runtime
-
-import (
- "reflect"
- "strings"
- "unicode"
-)
-
-func getTag(field reflect.StructField) string {
- return field.Tag.Get("json")
-}
-
-func IsIgnoredStructField(field reflect.StructField) bool {
- if field.PkgPath != "" {
- if field.Anonymous {
- t := field.Type
- if t.Kind() == reflect.Ptr {
- t = t.Elem()
- }
- if t.Kind() != reflect.Struct {
- return true
- }
- } else {
- // private field
- return true
- }
- }
- tag := getTag(field)
- return tag == "-"
-}
-
-type StructTag struct {
- Key string
- IsTaggedKey bool
- IsOmitEmpty bool
- IsString bool
- Field reflect.StructField
-}
-
-type StructTags []*StructTag
-
-func (t StructTags) ExistsKey(key string) bool {
- for _, tt := range t {
- if tt.Key == key {
- return true
- }
- }
- return false
-}
-
-func isValidTag(s string) bool {
- if s == "" {
- return false
- }
- for _, c := range s {
- switch {
- case strings.ContainsRune("!#$%&()*+-./:<=>?@[]^_{|}~ ", c):
- // Backslash and quote chars are reserved, but
- // otherwise any punctuation chars are allowed
- // in a tag name.
- case !unicode.IsLetter(c) && !unicode.IsDigit(c):
- return false
- }
- }
- return true
-}
-
-func StructTagFromField(field reflect.StructField) *StructTag {
- keyName := field.Name
- tag := getTag(field)
- st := &StructTag{Field: field}
- opts := strings.Split(tag, ",")
- if len(opts) > 0 {
- if opts[0] != "" && isValidTag(opts[0]) {
- keyName = opts[0]
- st.IsTaggedKey = true
- }
- }
- st.Key = keyName
- if len(opts) > 1 {
- for _, opt := range opts[1:] {
- switch opt {
- case "omitempty":
- st.IsOmitEmpty = true
- case "string":
- st.IsString = true
- }
- }
- }
- return st
-}
diff --git a/vendor/github.com/goccy/go-json/internal/runtime/type.go b/vendor/github.com/goccy/go-json/internal/runtime/type.go
deleted file mode 100644
index 4b693cb0..00000000
--- a/vendor/github.com/goccy/go-json/internal/runtime/type.go
+++ /dev/null
@@ -1,98 +0,0 @@
-package runtime
-
-import (
- "reflect"
- "sync"
- "unsafe"
-)
-
-type SliceHeader struct {
- Data unsafe.Pointer
- Len int
- Cap int
-}
-
-const (
- maxAcceptableTypeAddrRange = 1024 * 1024 * 2 // 2 Mib
-)
-
-type TypeAddr struct {
- BaseTypeAddr uintptr
- MaxTypeAddr uintptr
- AddrRange uintptr
- AddrShift uintptr
-}
-
-var (
- typeAddr *TypeAddr
- once sync.Once
-)
-
-//go:linkname typelinks reflect.typelinks
-func typelinks() ([]unsafe.Pointer, [][]int32)
-
-//go:linkname rtypeOff reflect.rtypeOff
-func rtypeOff(unsafe.Pointer, int32) unsafe.Pointer
-
-func AnalyzeTypeAddr() *TypeAddr {
- once.Do(func() {
- sections, offsets := typelinks()
- if len(sections) != 1 {
- return
- }
- if len(offsets) != 1 {
- return
- }
- section := sections[0]
- offset := offsets[0]
- var (
- min uintptr = uintptr(^uint(0))
- max uintptr = 0
- isAligned64 = true
- isAligned32 = true
- )
- for i := 0; i < len(offset); i++ {
- typ := (*Type)(rtypeOff(section, offset[i]))
- addr := uintptr(unsafe.Pointer(typ))
- if min > addr {
- min = addr
- }
- if max < addr {
- max = addr
- }
- if typ.Kind() == reflect.Ptr {
- addr = uintptr(unsafe.Pointer(typ.Elem()))
- if min > addr {
- min = addr
- }
- if max < addr {
- max = addr
- }
- }
- isAligned64 = isAligned64 && (addr-min)&63 == 0
- isAligned32 = isAligned32 && (addr-min)&31 == 0
- }
- addrRange := max - min
- if addrRange == 0 {
- return
- }
- var addrShift uintptr
- if isAligned64 {
- addrShift = 6
- } else if isAligned32 {
- addrShift = 5
- }
- cacheSize := addrRange >> addrShift
- if cacheSize > maxAcceptableTypeAddrRange {
- return
- }
- typeAddr = &TypeAddr{
- BaseTypeAddr: min,
- MaxTypeAddr: max,
- AddrRange: addrRange,
- AddrShift: addrShift,
- }
- })
-
- return typeAddr
-}
diff --git a/vendor/github.com/goccy/go-json/json.go b/vendor/github.com/goccy/go-json/json.go
deleted file mode 100644
index fb18065a..00000000
--- a/vendor/github.com/goccy/go-json/json.go
+++ /dev/null
@@ -1,368 +0,0 @@
-package json
-
-import (
- "bytes"
- "context"
- "encoding/json"
-
- "github.com/goccy/go-json/internal/encoder"
-)
-
-// Marshaler is the interface implemented by types that
-// can marshal themselves into valid JSON.
-type Marshaler interface {
- MarshalJSON() ([]byte, error)
-}
-
-// MarshalerContext is the interface implemented by types that
-// can marshal themselves into valid JSON with context.Context.
-type MarshalerContext interface {
- MarshalJSON(context.Context) ([]byte, error)
-}
-
-// Unmarshaler is the interface implemented by types
-// that can unmarshal a JSON description of themselves.
-// The input can be assumed to be a valid encoding of
-// a JSON value. UnmarshalJSON must copy the JSON data
-// if it wishes to retain the data after returning.
-//
-// By convention, to approximate the behavior of Unmarshal itself,
-// Unmarshalers implement UnmarshalJSON([]byte("null")) as a no-op.
-type Unmarshaler interface {
- UnmarshalJSON([]byte) error
-}
-
-// UnmarshalerContext is the interface implemented by types
-// that can unmarshal with context.Context a JSON description of themselves.
-type UnmarshalerContext interface {
- UnmarshalJSON(context.Context, []byte) error
-}
-
-// Marshal returns the JSON encoding of v.
-//
-// Marshal traverses the value v recursively.
-// If an encountered value implements the Marshaler interface
-// and is not a nil pointer, Marshal calls its MarshalJSON method
-// to produce JSON. If no MarshalJSON method is present but the
-// value implements encoding.TextMarshaler instead, Marshal calls
-// its MarshalText method and encodes the result as a JSON string.
-// The nil pointer exception is not strictly necessary
-// but mimics a similar, necessary exception in the behavior of
-// UnmarshalJSON.
-//
-// Otherwise, Marshal uses the following type-dependent default encodings:
-//
-// Boolean values encode as JSON booleans.
-//
-// Floating point, integer, and Number values encode as JSON numbers.
-//
-// String values encode as JSON strings coerced to valid UTF-8,
-// replacing invalid bytes with the Unicode replacement rune.
-// The angle brackets "<" and ">" are escaped to "\u003c" and "\u003e"
-// to keep some browsers from misinterpreting JSON output as HTML.
-// Ampersand "&" is also escaped to "\u0026" for the same reason.
-// This escaping can be disabled using an Encoder that had SetEscapeHTML(false)
-// called on it.
-//
-// Array and slice values encode as JSON arrays, except that
-// []byte encodes as a base64-encoded string, and a nil slice
-// encodes as the null JSON value.
-//
-// Struct values encode as JSON objects.
-// Each exported struct field becomes a member of the object, using the
-// field name as the object key, unless the field is omitted for one of the
-// reasons given below.
-//
-// The encoding of each struct field can be customized by the format string
-// stored under the "json" key in the struct field's tag.
-// The format string gives the name of the field, possibly followed by a
-// comma-separated list of options. The name may be empty in order to
-// specify options without overriding the default field name.
-//
-// The "omitempty" option specifies that the field should be omitted
-// from the encoding if the field has an empty value, defined as
-// false, 0, a nil pointer, a nil interface value, and any empty array,
-// slice, map, or string.
-//
-// As a special case, if the field tag is "-", the field is always omitted.
-// Note that a field with name "-" can still be generated using the tag "-,".
-//
-// Examples of struct field tags and their meanings:
-//
-// // Field appears in JSON as key "myName".
-// Field int `json:"myName"`
-//
-// // Field appears in JSON as key "myName" and
-// // the field is omitted from the object if its value is empty,
-// // as defined above.
-// Field int `json:"myName,omitempty"`
-//
-// // Field appears in JSON as key "Field" (the default), but
-// // the field is skipped if empty.
-// // Note the leading comma.
-// Field int `json:",omitempty"`
-//
-// // Field is ignored by this package.
-// Field int `json:"-"`
-//
-// // Field appears in JSON as key "-".
-// Field int `json:"-,"`
-//
-// The "string" option signals that a field is stored as JSON inside a
-// JSON-encoded string. It applies only to fields of string, floating point,
-// integer, or boolean types. This extra level of encoding is sometimes used
-// when communicating with JavaScript programs:
-//
-// Int64String int64 `json:",string"`
-//
-// The key name will be used if it's a non-empty string consisting of
-// only Unicode letters, digits, and ASCII punctuation except quotation
-// marks, backslash, and comma.
-//
-// Anonymous struct fields are usually marshaled as if their inner exported fields
-// were fields in the outer struct, subject to the usual Go visibility rules amended
-// as described in the next paragraph.
-// An anonymous struct field with a name given in its JSON tag is treated as
-// having that name, rather than being anonymous.
-// An anonymous struct field of interface type is treated the same as having
-// that type as its name, rather than being anonymous.
-//
-// The Go visibility rules for struct fields are amended for JSON when
-// deciding which field to marshal or unmarshal. If there are
-// multiple fields at the same level, and that level is the least
-// nested (and would therefore be the nesting level selected by the
-// usual Go rules), the following extra rules apply:
-//
-// 1) Of those fields, if any are JSON-tagged, only tagged fields are considered,
-// even if there are multiple untagged fields that would otherwise conflict.
-//
-// 2) If there is exactly one field (tagged or not according to the first rule), that is selected.
-//
-// 3) Otherwise there are multiple fields, and all are ignored; no error occurs.
-//
-// Handling of anonymous struct fields is new in Go 1.1.
-// Prior to Go 1.1, anonymous struct fields were ignored. To force ignoring of
-// an anonymous struct field in both current and earlier versions, give the field
-// a JSON tag of "-".
-//
-// Map values encode as JSON objects. The map's key type must either be a
-// string, an integer type, or implement encoding.TextMarshaler. The map keys
-// are sorted and used as JSON object keys by applying the following rules,
-// subject to the UTF-8 coercion described for string values above:
-// - string keys are used directly
-// - encoding.TextMarshalers are marshaled
-// - integer keys are converted to strings
-//
-// Pointer values encode as the value pointed to.
-// A nil pointer encodes as the null JSON value.
-//
-// Interface values encode as the value contained in the interface.
-// A nil interface value encodes as the null JSON value.
-//
-// Channel, complex, and function values cannot be encoded in JSON.
-// Attempting to encode such a value causes Marshal to return
-// an UnsupportedTypeError.
-//
-// JSON cannot represent cyclic data structures and Marshal does not
-// handle them. Passing cyclic structures to Marshal will result in
-// an infinite recursion.
-func Marshal(v interface{}) ([]byte, error) {
- return MarshalWithOption(v)
-}
-
-// MarshalNoEscape returns the JSON encoding of v and doesn't escape v.
-func MarshalNoEscape(v interface{}) ([]byte, error) {
- return marshalNoEscape(v)
-}
-
-// MarshalContext returns the JSON encoding of v with context.Context and EncodeOption.
-func MarshalContext(ctx context.Context, v interface{}, optFuncs ...EncodeOptionFunc) ([]byte, error) {
- return marshalContext(ctx, v, optFuncs...)
-}
-
-// MarshalWithOption returns the JSON encoding of v with EncodeOption.
-func MarshalWithOption(v interface{}, optFuncs ...EncodeOptionFunc) ([]byte, error) {
- return marshal(v, optFuncs...)
-}
-
-// MarshalIndent is like Marshal but applies Indent to format the output.
-// Each JSON element in the output will begin on a new line beginning with prefix
-// followed by one or more copies of indent according to the indentation nesting.
-func MarshalIndent(v interface{}, prefix, indent string) ([]byte, error) {
- return MarshalIndentWithOption(v, prefix, indent)
-}
-
-// MarshalIndentWithOption is like Marshal but applies Indent to format the output with EncodeOption.
-func MarshalIndentWithOption(v interface{}, prefix, indent string, optFuncs ...EncodeOptionFunc) ([]byte, error) {
- return marshalIndent(v, prefix, indent, optFuncs...)
-}
-
-// Unmarshal parses the JSON-encoded data and stores the result
-// in the value pointed to by v. If v is nil or not a pointer,
-// Unmarshal returns an InvalidUnmarshalError.
-//
-// Unmarshal uses the inverse of the encodings that
-// Marshal uses, allocating maps, slices, and pointers as necessary,
-// with the following additional rules:
-//
-// To unmarshal JSON into a pointer, Unmarshal first handles the case of
-// the JSON being the JSON literal null. In that case, Unmarshal sets
-// the pointer to nil. Otherwise, Unmarshal unmarshals the JSON into
-// the value pointed at by the pointer. If the pointer is nil, Unmarshal
-// allocates a new value for it to point to.
-//
-// To unmarshal JSON into a value implementing the Unmarshaler interface,
-// Unmarshal calls that value's UnmarshalJSON method, including
-// when the input is a JSON null.
-// Otherwise, if the value implements encoding.TextUnmarshaler
-// and the input is a JSON quoted string, Unmarshal calls that value's
-// UnmarshalText method with the unquoted form of the string.
-//
-// To unmarshal JSON into a struct, Unmarshal matches incoming object
-// keys to the keys used by Marshal (either the struct field name or its tag),
-// preferring an exact match but also accepting a case-insensitive match. By
-// default, object keys which don't have a corresponding struct field are
-// ignored (see Decoder.DisallowUnknownFields for an alternative).
-//
-// To unmarshal JSON into an interface value,
-// Unmarshal stores one of these in the interface value:
-//
-// bool, for JSON booleans
-// float64, for JSON numbers
-// string, for JSON strings
-// []interface{}, for JSON arrays
-// map[string]interface{}, for JSON objects
-// nil for JSON null
-//
-// To unmarshal a JSON array into a slice, Unmarshal resets the slice length
-// to zero and then appends each element to the slice.
-// As a special case, to unmarshal an empty JSON array into a slice,
-// Unmarshal replaces the slice with a new empty slice.
-//
-// To unmarshal a JSON array into a Go array, Unmarshal decodes
-// JSON array elements into corresponding Go array elements.
-// If the Go array is smaller than the JSON array,
-// the additional JSON array elements are discarded.
-// If the JSON array is smaller than the Go array,
-// the additional Go array elements are set to zero values.
-//
-// To unmarshal a JSON object into a map, Unmarshal first establishes a map to
-// use. If the map is nil, Unmarshal allocates a new map. Otherwise Unmarshal
-// reuses the existing map, keeping existing entries. Unmarshal then stores
-// key-value pairs from the JSON object into the map. The map's key type must
-// either be any string type, an integer, implement json.Unmarshaler, or
-// implement encoding.TextUnmarshaler.
-//
-// If a JSON value is not appropriate for a given target type,
-// or if a JSON number overflows the target type, Unmarshal
-// skips that field and completes the unmarshaling as best it can.
-// If no more serious errors are encountered, Unmarshal returns
-// an UnmarshalTypeError describing the earliest such error. In any
-// case, it's not guaranteed that all the remaining fields following
-// the problematic one will be unmarshaled into the target object.
-//
-// The JSON null value unmarshals into an interface, map, pointer, or slice
-// by setting that Go value to nil. Because null is often used in JSON to mean
-// “not present,” unmarshaling a JSON null into any other Go type has no effect
-// on the value and produces no error.
-//
-// When unmarshaling quoted strings, invalid UTF-8 or
-// invalid UTF-16 surrogate pairs are not treated as an error.
-// Instead, they are replaced by the Unicode replacement
-// character U+FFFD.
-func Unmarshal(data []byte, v interface{}) error {
- return unmarshal(data, v)
-}
-
-// UnmarshalContext parses the JSON-encoded data and stores the result
-// in the value pointed to by v. If you implement the UnmarshalerContext interface,
-// call it with ctx as an argument.
-func UnmarshalContext(ctx context.Context, data []byte, v interface{}, optFuncs ...DecodeOptionFunc) error {
- return unmarshalContext(ctx, data, v)
-}
-
-func UnmarshalWithOption(data []byte, v interface{}, optFuncs ...DecodeOptionFunc) error {
- return unmarshal(data, v, optFuncs...)
-}
-
-func UnmarshalNoEscape(data []byte, v interface{}, optFuncs ...DecodeOptionFunc) error {
- return unmarshalNoEscape(data, v, optFuncs...)
-}
-
-// A Token holds a value of one of these types:
-//
-// Delim, for the four JSON delimiters [ ] { }
-// bool, for JSON booleans
-// float64, for JSON numbers
-// Number, for JSON numbers
-// string, for JSON string literals
-// nil, for JSON null
-type Token = json.Token
-
-// A Number represents a JSON number literal.
-type Number = json.Number
-
-// RawMessage is a raw encoded JSON value.
-// It implements Marshaler and Unmarshaler and can
-// be used to delay JSON decoding or precompute a JSON encoding.
-type RawMessage = json.RawMessage
-
-// A Delim is a JSON array or object delimiter, one of [ ] { or }.
-type Delim = json.Delim
-
-// Compact appends to dst the JSON-encoded src with
-// insignificant space characters elided.
-func Compact(dst *bytes.Buffer, src []byte) error {
- return encoder.Compact(dst, src, false)
-}
-
-// Indent appends to dst an indented form of the JSON-encoded src.
-// Each element in a JSON object or array begins on a new,
-// indented line beginning with prefix followed by one or more
-// copies of indent according to the indentation nesting.
-// The data appended to dst does not begin with the prefix nor
-// any indentation, to make it easier to embed inside other formatted JSON data.
-// Although leading space characters (space, tab, carriage return, newline)
-// at the beginning of src are dropped, trailing space characters
-// at the end of src are preserved and copied to dst.
-// For example, if src has no trailing spaces, neither will dst;
-// if src ends in a trailing newline, so will dst.
-func Indent(dst *bytes.Buffer, src []byte, prefix, indent string) error {
- return encoder.Indent(dst, src, prefix, indent)
-}
-
-// HTMLEscape appends to dst the JSON-encoded src with <, >, &, U+2028 and U+2029
-// characters inside string literals changed to \u003c, \u003e, \u0026, \u2028, \u2029
-// so that the JSON will be safe to embed inside HTML " that closes the next token. If
- // non-empty, the subsequent call to Next will return a raw or RCDATA text
- // token: one that treats "
" as text instead of an element.
- // rawTag's contents are lower-cased.
- rawTag string
- // textIsRaw is whether the current text token's data is not escaped.
- textIsRaw bool
- // convertNUL is whether NUL bytes in the current token's data should
- // be converted into \ufffd replacement characters.
- convertNUL bool
- // allowCDATA is whether CDATA sections are allowed in the current context.
- allowCDATA bool
-}
-
-// AllowCDATA sets whether or not the tokenizer recognizes as
-// the text "foo". The default value is false, which means to recognize it as
-// a bogus comment "" instead.
-//
-// Strictly speaking, an HTML5 compliant tokenizer should allow CDATA if and
-// only if tokenizing foreign content, such as MathML and SVG. However,
-// tracking foreign-contentness is difficult to do purely in the tokenizer,
-// as opposed to the parser, due to HTML integration points: an
-
-# Roadmap
-
-```
-* version ( expected release date )
-
-* v0.9.0
- |
- | while maintaining compatibility with encoding/json, we will add convenient APIs
- |
- v
-* v1.0.0
-```
-
-We are accepting requests for features that will be implemented between v0.9.0 and v.1.0.0.
-If you have the API you need, please submit your issue [here](https://github.com/goccy/go-json/issues).
-
-# Features
-
-- Drop-in replacement of `encoding/json`
-- Fast ( See [Benchmark section](https://github.com/goccy/go-json#benchmarks) )
-- Flexible customization with options
-- Coloring the encoded string
-- Can propagate context.Context to `MarshalJSON` or `UnmarshalJSON`
-- Can dynamically filter the fields of the structure type-safely
-
-# Installation
-
-```
-go get github.com/goccy/go-json
-```
-
-# How to use
-
-Replace import statement from `encoding/json` to `github.com/goccy/go-json`
-
-```
--import "encoding/json"
-+import "github.com/goccy/go-json"
-```
-
-# JSON library comparison
-
-| name | encoder | decoder | compatible with `encoding/json` |
-| :----: | :------: | :-----: | :-----------------------------: |
-| encoding/json | yes | yes | N/A |
-| [json-iterator/go](https://github.com/json-iterator/go) | yes | yes | partial |
-| [easyjson](https://github.com/mailru/easyjson) | yes | yes | no |
-| [gojay](https://github.com/francoispqt/gojay) | yes | yes | no |
-| [segmentio/encoding/json](https://github.com/segmentio/encoding/tree/master/json) | yes | yes | partial |
-| [jettison](https://github.com/wI2L/jettison) | yes | no | no |
-| [simdjson-go](https://github.com/minio/simdjson-go) | no | yes | no |
-| goccy/go-json | yes | yes | yes |
-
-- `json-iterator/go` isn't compatible with `encoding/json` in many ways (e.g. https://github.com/json-iterator/go/issues/229 ), but it hasn't been supported for a long time.
-- `segmentio/encoding/json` is well supported for encoders, but some are not supported for decoder APIs such as `Token` ( streaming decode )
-
-## Other libraries
-
-- [jingo](https://github.com/bet365/jingo)
-
-I tried the benchmark but it didn't work.
-Also, it seems to panic when it receives an unexpected value because there is no error handling...
-
-- [ffjson](https://github.com/pquerna/ffjson)
-
-Benchmarking gave very slow results.
-It seems that it is assumed that the user will use the buffer pool properly.
-Also, development seems to have already stopped
-
-# Benchmarks
-
-```
-$ cd benchmarks
-$ go test -bench .
-```
-
-## Encode
-
-
-
-
-## Decode
-
-
-
-
-
-
-# Fuzzing
-
-[go-json-fuzz](https://github.com/goccy/go-json-fuzz) is the repository for fuzzing tests.
-If you run the test in this repository and find a bug, please commit to corpus to go-json-fuzz and report the issue to [go-json](https://github.com/goccy/go-json/issues).
-
-# How it works
-
-`go-json` is very fast in both encoding and decoding compared to other libraries.
-It's easier to implement by using automatic code generation for performance or by using a dedicated interface, but `go-json` dares to stick to compatibility with `encoding/json` and is the simple interface. Despite this, we are developing with the aim of being the fastest library.
-
-Here, we explain the various speed-up techniques implemented by `go-json`.
-
-## Basic technique
-
-The techniques listed here are the ones used by most of the libraries listed above.
-
-### Buffer reuse
-
-Since the only value required for the result of `json.Marshal(interface{}) ([]byte, error)` is `[]byte`, the only value that must be allocated during encoding is the return value `[]byte` .
-
-Also, as the number of allocations increases, the performance will be affected, so the number of allocations should be kept as low as possible when creating `[]byte`.
-
-Therefore, there is a technique to reduce the number of times a new buffer must be allocated by reusing the buffer used for the previous encoding by using `sync.Pool`.
-
-Finally, you allocate a buffer that is as long as the resulting buffer and copy the contents into it, you only need to allocate the buffer once in theory.
-
-```go
-type buffer struct {
- data []byte
-}
-
-var bufPool = sync.Pool{
- New: func() interface{} {
- return &buffer{data: make([]byte, 0, 1024)}
- },
-}
-
-buf := bufPool.Get().(*buffer)
-data := encode(buf.data) // reuse buf.data
-
-newBuf := make([]byte, len(data))
-copy(newBuf, buf)
-
-buf.data = data
-bufPool.Put(buf)
-```
-
-### Elimination of reflection
-
-As you know, the reflection operation is very slow.
-
-Therefore, using the fact that the address position where the type information is stored is fixed for each binary ( we call this `typeptr` ),
-we can use the address in the type information to call a pre-built optimized process.
-
-For example, you can get the address to the type information from `interface{}` as follows and you can use that information to call a process that does not have reflection.
-
-To process without reflection, pass a pointer (`unsafe.Pointer`) to the value is stored.
-
-```go
-
-type emptyInterface struct {
- typ unsafe.Pointer
- ptr unsafe.Pointer
-}
-
-var typeToEncoder = map[uintptr]func(unsafe.Pointer)([]byte, error){}
-
-func Marshal(v interface{}) ([]byte, error) {
- iface := (*emptyInterface)(unsafe.Pointer(&v)
- typeptr := uintptr(iface.typ)
- if enc, exists := typeToEncoder[typeptr]; exists {
- return enc(iface.ptr)
- }
- ...
-}
-```
-
-※ In reality, `typeToEncoder` can be referenced by multiple goroutines, so exclusive control is required.
-
-## Unique speed-up technique
-
-## Encoder
-
-### Do not escape arguments of `Marshal`
-
-`json.Marshal` and `json.Unmarshal` receive `interface{}` value and they perform type determination dynamically to process.
-In normal case, you need to use the `reflect` library to determine the type dynamically, but since `reflect.Type` is defined as `interface`, when you call the method of `reflect.Type`, The reflect's argument is escaped.
-
-Therefore, the arguments for `Marshal` and `Unmarshal` are always escaped to the heap.
-However, `go-json` can use the feature of `reflect.Type` while avoiding escaping.
-
-`reflect.Type` is defined as `interface`, but in reality `reflect.Type` is implemented only by the structure `rtype` defined in the `reflect` package.
-For this reason, to date `reflect.Type` is the same as `*reflect.rtype`.
-
-Therefore, by directly handling `*reflect.rtype`, which is an implementation of `reflect.Type`, it is possible to avoid escaping because it changes from `interface` to using `struct`.
-
-The technique for working with `*reflect.rtype` directly from `go-json` is implemented at [rtype.go](https://github.com/goccy/go-json/blob/master/internal/runtime/rtype.go)
-
-Also, the same technique is cut out as a library ( https://github.com/goccy/go-reflect )
-
-Initially this feature was the default behavior of `go-json`.
-But after careful testing, I found that I passed a large value to `json.Marshal()` and if the argument could not be assigned to the stack, it could not be properly escaped to the heap (a bug in the Go compiler).
-
-Therefore, this feature will be provided as an **optional** until this issue is resolved.
-
-To use it, add `NoEscape` like `MarshalNoEscape()`
-
-### Encoding using opcode sequence
-
-I explained that you can use `typeptr` to call a pre-built process from type information.
-
-In other libraries, this dedicated process is processed by making it an function calling like anonymous function, but function calls are inherently slow processes and should be avoided as much as possible.
-
-Therefore, `go-json` adopted the Instruction-based execution processing system, which is also used to implement virtual machines for programming language.
-
-If it is the first type to encode, create the opcode ( instruction ) sequence required for encoding.
-From the second time onward, use `typeptr` to get the cached pre-built opcode sequence and encode it based on it. An example of the opcode sequence is shown below.
-
-```go
-json.Marshal(struct{
- X int `json:"x"`
- Y string `json:"y"`
-}{X: 1, Y: "hello"})
-```
-
-When encoding a structure like the one above, create a sequence of opcodes like this:
-
-```
-- opStructFieldHead ( `{` )
-- opStructFieldInt ( `"x": 1,` )
-- opStructFieldString ( `"y": "hello"` )
-- opStructEnd ( `}` )
-- opEnd
-```
-
-※ When processing each operation, write the letters on the right.
-
-In addition, each opcode is managed by the following structure (
-Pseudo code ).
-
-```go
-type opType int
-const (
- opStructFieldHead opType = iota
- opStructFieldInt
- opStructFieldStirng
- opStructEnd
- opEnd
-)
-type opcode struct {
- op opType
- key []byte
- next *opcode
-}
-```
-
-The process of encoding using the opcode sequence is roughly implemented as follows.
-
-```go
-func encode(code *opcode, b []byte, p unsafe.Pointer) ([]byte, error) {
- for {
- switch code.op {
- case opStructFieldHead:
- b = append(b, '{')
- code = code.next
- case opStructFieldInt:
- b = append(b, code.key...)
- b = appendInt((*int)(unsafe.Pointer(uintptr(p)+code.offset)))
- code = code.next
- case opStructFieldString:
- b = append(b, code.key...)
- b = appendString((*string)(unsafe.Pointer(uintptr(p)+code.offset)))
- code = code.next
- case opStructEnd:
- b = append(b, '}')
- code = code.next
- case opEnd:
- goto END
- }
- }
-END:
- return b, nil
-}
-```
-
-In this way, the huge `switch-case` is used to encode by manipulating the linked list opcodes to avoid unnecessary function calls.
-
-### Opcode sequence optimization
-
-One of the advantages of encoding using the opcode sequence is the ease of optimization.
-The opcode sequence mentioned above is actually converted into the following optimized operations and used.
-
-```
-- opStructFieldHeadInt ( `{"x": 1,` )
-- opStructEndString ( `"y": "hello"}` )
-- opEnd
-```
-
-It has been reduced from 5 opcodes to 3 opcodes !
-Reducing the number of opcodees means reducing the number of branches with `switch-case`.
-In other words, the closer the number of operations is to 1, the faster the processing can be performed.
-
-In `go-json`, optimization to reduce the number of opcodes itself like the above and it speeds up by preparing opcodes with optimized paths.
-
-### Change recursive call from CALL to JMP
-
-Recursive processing is required during encoding if the type is defined recursively as follows:
-
-```go
-type T struct {
- X int
- U *U
-}
-
-type U struct {
- T *T
-}
-
-b, err := json.Marshal(&T{
- X: 1,
- U: &U{
- T: &T{
- X: 2,
- },
- },
-})
-fmt.Println(string(b)) // {"X":1,"U":{"T":{"X":2,"U":null}}}
-```
-
-In `go-json`, recursive processing is processed by the operation type of ` opStructFieldRecursive`.
-
-In this operation, after acquiring the opcode sequence used for recursive processing, the function is **not** called recursively as it is, but the necessary values are saved by itself and implemented by moving to the next operation.
-
-The technique of implementing recursive processing with the `JMP` operation while avoiding the `CALL` operation is a famous technique for implementing a high-speed virtual machine.
-
-For more details, please refer to [the article](https://engineering.mercari.com/blog/entry/1599563768-081104c850) ( but Japanese only ).
-
-### Dispatch by typeptr from map to slice
-
-When retrieving the data cached from the type information by `typeptr`, we usually use map.
-Map requires exclusive control, so use `sync.Map` for a naive implementation.
-
-However, this is slow, so it's a good idea to use the `atomic` package for exclusive control as implemented by `segmentio/encoding/json` ( https://github.com/segmentio/encoding/blob/master/json/codec.go#L41-L55 ).
-
-This implementation slows down the set instead of speeding up the get, but it works well because of the nature of the library, it encodes much more for the same type.
-
-However, as a result of profiling, I noticed that `runtime.mapaccess2` accounts for a significant percentage of the execution time. So I thought if I could change the lookup from map to slice.
-
-There is an API named `typelinks` defined in the `runtime` package that the `reflect` package uses internally.
-This allows you to get all the type information defined in the binary at runtime.
-
-The fact that all type information can be acquired means that by constructing slices in advance with the acquired total number of type information, it is possible to look up with the value of `typeptr` without worrying about out-of-range access.
-
-However, if there is too much type information, it will use a lot of memory, so by default we will only use this optimization if the slice size fits within **2Mib** .
-
-If this approach is not available, it will fall back to the `atomic` based process described above.
-
-If you want to know more, please refer to the implementation [here](https://github.com/goccy/go-json/blob/master/internal/runtime/type.go#L36-L100)
-
-## Decoder
-
-### Dispatch by typeptr from map to slice
-
-Like the encoder, the decoder also uses typeptr to call the dedicated process.
-
-### Faster termination character inspection using NUL character
-
-In order to decode, you have to traverse the input buffer character by position.
-At that time, if you check whether the buffer has reached the end, it will be very slow.
-
-`buf` : `[]byte` type variable. holds the string passed to the decoder
-`cursor` : `int64` type variable. holds the current read position
-
-```go
-buflen := len(buf)
-for ; cursor < buflen; cursor++ { // compare cursor and buflen at all times, it is so slow.
- switch buf[cursor] {
- case ' ', '\n', '\r', '\t':
- }
-}
-```
-
-Therefore, by adding the `NUL` (`\000`) character to the end of the read buffer as shown below, it is possible to check the termination character at the same time as other characters.
-
-```go
-for {
- switch buf[cursor] {
- case ' ', '\n', '\r', '\t':
- case '\000':
- return nil
- }
- cursor++
-}
-```
-
-### Use Boundary Check Elimination
-
-Due to the `NUL` character optimization, the Go compiler does a boundary check every time, even though `buf[cursor]` does not cause out-of-range access.
-
-Therefore, `go-json` eliminates boundary check by fetching characters for hotspot by pointer operation. For example, the following code.
-
-```go
-func char(ptr unsafe.Pointer, offset int64) byte {
- return *(*byte)(unsafe.Pointer(uintptr(ptr) + uintptr(offset)))
-}
-
-p := (*sliceHeader)(&unsafe.Pointer(buf)).data
-for {
- switch char(p, cursor) {
- case ' ', '\n', '\r', '\t':
- case '\000':
- return nil
- }
- cursor++
-}
-```
-
-### Checking the existence of fields of struct using Bitmaps
-
-I found by the profiling result, in the struct decode, lookup process for field was taking a long time.
-
-For example, consider decoding a string like `{"a":1,"b":2,"c":3}` into the following structure:
-
-```go
-type T struct {
- A int `json:"a"`
- B int `json:"b"`
- C int `json:"c"`
-}
-```
-
-At this time, it was found that it takes a lot of time to acquire the decoding process corresponding to the field from the field name as shown below during the decoding process.
-
-```go
-fieldName := decodeKey(buf, cursor) // "a" or "b" or "c"
-decoder, exists := fieldToDecoderMap[fieldName] // so slow
-if exists {
- decoder(buf, cursor)
-} else {
- skipValue(buf, cursor)
-}
-```
-
-To improve this process, `json-iterator/go` is optimized so that it can be branched by switch-case when the number of fields in the structure is 10 or less (switch-case is faster than map). However, there is a risk of hash collision because the value hashed by the FNV algorithm is used for conditional branching. Also, `gojay` processes this part at high speed by letting the library user yourself write `switch-case`.
-
-
-`go-json` considers and implements a new approach that is different from these. I call this **bitmap field optimization**.
-
-The range of values per character can be represented by `[256]byte`. Also, if the number of fields in the structure is 8 or less, `int8` type can represent the state of each field.
-In other words, it has the following structure.
-
-- Base ( 8bit ): `00000000`
-- Key "a": `00000001` ( assign key "a" to the first bit )
-- Key "b": `00000010` ( assign key "b" to the second bit )
-- Key "c": `00000100` ( assign key "c" to the third bit )
-
-Bitmap structure is the following
-
-```
- | key index(0) |
-------------------------
- 0 | 00000000 |
- 1 | 00000000 |
-~~ | |
-97 (a) | 00000001 |
-98 (b) | 00000010 |
-99 (c) | 00000100 |
-~~ | |
-255 | 00000000 |
-```
-
-You can think of this as a Bitmap with a height of `256` and a width of the maximum string length in the field name.
-In other words, it can be represented by the following type .
-
-```go
-[maxFieldKeyLength][256]int8
-```
-
-When decoding a field character, check whether the corresponding character exists by referring to the pre-built bitmap like the following.
-
-```go
-var curBit int8 = math.MaxInt8 // 11111111
-
-c := char(buf, cursor)
-bit := bitmap[keyIdx][c]
-curBit &= bit
-if curBit == 0 {
- // not found field
-}
-```
-
-If `curBit` is not `0` until the end of the field string, then the string is
-You may have hit one of the fields.
-But the possibility is that if the decoded string is shorter than the field string, you will get a false hit.
-
-- input: `{"a":1}`
-```go
-type T struct {
- X int `json:"abc"`
-}
-```
-※ Since `a` is shorter than `abc`, it can decode to the end of the field character without `curBit` being 0.
-
-Rest assured. In this case, it doesn't matter because you can tell if you hit by comparing the string length of `a` with the string length of `abc`.
-
-Finally, calculate the position of the bit where `1` is set and get the corresponding value, and you're done.
-
-Using this technique, field lookups are possible with only bitwise operations and access to slices.
-
-`go-json` uses a similar technique for fields with 9 or more and 16 or less fields. At this time, Bitmap is constructed as `[maxKeyLen][256]int16` type.
-
-Currently, this optimization is not performed when the maximum length of the field name is long (specifically, 64 bytes or more) in addition to the limitation of the number of fields from the viewpoint of saving memory usage.
-
-### Others
-
-I have done a lot of other optimizations. I will find time to write about them. If you have any questions about what's written here or other optimizations, please visit the `#go-json` channel on `gophers.slack.com` .
-
-## Reference
-
-Regarding the story of go-json, there are the following articles in Japanese only.
-
-- https://speakerdeck.com/goccy/zui-su-falsejsonraiburariwoqiu-mete
-- https://engineering.mercari.com/blog/entry/1599563768-081104c850/
-
-# Looking for Sponsors
-
-I'm looking for sponsors this library. This library is being developed as a personal project in my spare time. If you want a quick response or problem resolution when using this library in your project, please register as a [sponsor](https://github.com/sponsors/goccy). I will cooperate as much as possible. Of course, this library is developed as an MIT license, so you can use it freely for free.
-
-# License
-
-MIT
diff --git a/vendor/github.com/goccy/go-json/color.go b/vendor/github.com/goccy/go-json/color.go
deleted file mode 100644
index e80b22b4..00000000
--- a/vendor/github.com/goccy/go-json/color.go
+++ /dev/null
@@ -1,68 +0,0 @@
-package json
-
-import (
- "fmt"
-
- "github.com/goccy/go-json/internal/encoder"
-)
-
-type (
- ColorFormat = encoder.ColorFormat
- ColorScheme = encoder.ColorScheme
-)
-
-const escape = "\x1b"
-
-type colorAttr int
-
-//nolint:deadcode,varcheck
-const (
- fgBlackColor colorAttr = iota + 30
- fgRedColor
- fgGreenColor
- fgYellowColor
- fgBlueColor
- fgMagentaColor
- fgCyanColor
- fgWhiteColor
-)
-
-//nolint:deadcode,varcheck
-const (
- fgHiBlackColor colorAttr = iota + 90
- fgHiRedColor
- fgHiGreenColor
- fgHiYellowColor
- fgHiBlueColor
- fgHiMagentaColor
- fgHiCyanColor
- fgHiWhiteColor
-)
-
-func createColorFormat(attr colorAttr) ColorFormat {
- return ColorFormat{
- Header: wrapColor(attr),
- Footer: resetColor(),
- }
-}
-
-func wrapColor(attr colorAttr) string {
- return fmt.Sprintf("%s[%dm", escape, attr)
-}
-
-func resetColor() string {
- return wrapColor(colorAttr(0))
-}
-
-var (
- DefaultColorScheme = &ColorScheme{
- Int: createColorFormat(fgHiMagentaColor),
- Uint: createColorFormat(fgHiMagentaColor),
- Float: createColorFormat(fgHiMagentaColor),
- Bool: createColorFormat(fgHiYellowColor),
- String: createColorFormat(fgHiGreenColor),
- Binary: createColorFormat(fgHiRedColor),
- ObjectKey: createColorFormat(fgHiCyanColor),
- Null: createColorFormat(fgBlueColor),
- }
-)
diff --git a/vendor/github.com/goccy/go-json/decode.go b/vendor/github.com/goccy/go-json/decode.go
deleted file mode 100644
index 74c6ac3b..00000000
--- a/vendor/github.com/goccy/go-json/decode.go
+++ /dev/null
@@ -1,263 +0,0 @@
-package json
-
-import (
- "context"
- "fmt"
- "io"
- "reflect"
- "unsafe"
-
- "github.com/goccy/go-json/internal/decoder"
- "github.com/goccy/go-json/internal/errors"
- "github.com/goccy/go-json/internal/runtime"
-)
-
-type Decoder struct {
- s *decoder.Stream
-}
-
-const (
- nul = '\000'
-)
-
-type emptyInterface struct {
- typ *runtime.Type
- ptr unsafe.Pointer
-}
-
-func unmarshal(data []byte, v interface{}, optFuncs ...DecodeOptionFunc) error {
- src := make([]byte, len(data)+1) // append nul byte to the end
- copy(src, data)
-
- header := (*emptyInterface)(unsafe.Pointer(&v))
-
- if err := validateType(header.typ, uintptr(header.ptr)); err != nil {
- return err
- }
- dec, err := decoder.CompileToGetDecoder(header.typ)
- if err != nil {
- return err
- }
- ctx := decoder.TakeRuntimeContext()
- ctx.Buf = src
- ctx.Option.Flags = 0
- for _, optFunc := range optFuncs {
- optFunc(ctx.Option)
- }
- cursor, err := dec.Decode(ctx, 0, 0, header.ptr)
- if err != nil {
- decoder.ReleaseRuntimeContext(ctx)
- return err
- }
- decoder.ReleaseRuntimeContext(ctx)
- return validateEndBuf(src, cursor)
-}
-
-func unmarshalContext(ctx context.Context, data []byte, v interface{}, optFuncs ...DecodeOptionFunc) error {
- src := make([]byte, len(data)+1) // append nul byte to the end
- copy(src, data)
-
- header := (*emptyInterface)(unsafe.Pointer(&v))
-
- if err := validateType(header.typ, uintptr(header.ptr)); err != nil {
- return err
- }
- dec, err := decoder.CompileToGetDecoder(header.typ)
- if err != nil {
- return err
- }
- rctx := decoder.TakeRuntimeContext()
- rctx.Buf = src
- rctx.Option.Flags = 0
- rctx.Option.Flags |= decoder.ContextOption
- rctx.Option.Context = ctx
- for _, optFunc := range optFuncs {
- optFunc(rctx.Option)
- }
- cursor, err := dec.Decode(rctx, 0, 0, header.ptr)
- if err != nil {
- decoder.ReleaseRuntimeContext(rctx)
- return err
- }
- decoder.ReleaseRuntimeContext(rctx)
- return validateEndBuf(src, cursor)
-}
-
-var (
- pathDecoder = decoder.NewPathDecoder()
-)
-
-func extractFromPath(path *Path, data []byte, optFuncs ...DecodeOptionFunc) ([][]byte, error) {
- if path.path.RootSelectorOnly {
- return [][]byte{data}, nil
- }
- src := make([]byte, len(data)+1) // append nul byte to the end
- copy(src, data)
-
- ctx := decoder.TakeRuntimeContext()
- ctx.Buf = src
- ctx.Option.Flags = 0
- ctx.Option.Flags |= decoder.PathOption
- ctx.Option.Path = path.path
- for _, optFunc := range optFuncs {
- optFunc(ctx.Option)
- }
- paths, cursor, err := pathDecoder.DecodePath(ctx, 0, 0)
- if err != nil {
- decoder.ReleaseRuntimeContext(ctx)
- return nil, err
- }
- decoder.ReleaseRuntimeContext(ctx)
- if err := validateEndBuf(src, cursor); err != nil {
- return nil, err
- }
- return paths, nil
-}
-
-func unmarshalNoEscape(data []byte, v interface{}, optFuncs ...DecodeOptionFunc) error {
- src := make([]byte, len(data)+1) // append nul byte to the end
- copy(src, data)
-
- header := (*emptyInterface)(unsafe.Pointer(&v))
-
- if err := validateType(header.typ, uintptr(header.ptr)); err != nil {
- return err
- }
- dec, err := decoder.CompileToGetDecoder(header.typ)
- if err != nil {
- return err
- }
-
- ctx := decoder.TakeRuntimeContext()
- ctx.Buf = src
- ctx.Option.Flags = 0
- for _, optFunc := range optFuncs {
- optFunc(ctx.Option)
- }
- cursor, err := dec.Decode(ctx, 0, 0, noescape(header.ptr))
- if err != nil {
- decoder.ReleaseRuntimeContext(ctx)
- return err
- }
- decoder.ReleaseRuntimeContext(ctx)
- return validateEndBuf(src, cursor)
-}
-
-func validateEndBuf(src []byte, cursor int64) error {
- for {
- switch src[cursor] {
- case ' ', '\t', '\n', '\r':
- cursor++
- continue
- case nul:
- return nil
- }
- return errors.ErrSyntax(
- fmt.Sprintf("invalid character '%c' after top-level value", src[cursor]),
- cursor+1,
- )
- }
-}
-
-//nolint:staticcheck
-//go:nosplit
-func noescape(p unsafe.Pointer) unsafe.Pointer {
- x := uintptr(p)
- return unsafe.Pointer(x ^ 0)
-}
-
-func validateType(typ *runtime.Type, p uintptr) error {
- if typ == nil || typ.Kind() != reflect.Ptr || p == 0 {
- return &InvalidUnmarshalError{Type: runtime.RType2Type(typ)}
- }
- return nil
-}
-
-// NewDecoder returns a new decoder that reads from r.
-//
-// The decoder introduces its own buffering and may
-// read data from r beyond the JSON values requested.
-func NewDecoder(r io.Reader) *Decoder {
- s := decoder.NewStream(r)
- return &Decoder{
- s: s,
- }
-}
-
-// Buffered returns a reader of the data remaining in the Decoder's
-// buffer. The reader is valid until the next call to Decode.
-func (d *Decoder) Buffered() io.Reader {
- return d.s.Buffered()
-}
-
-// Decode reads the next JSON-encoded value from its
-// input and stores it in the value pointed to by v.
-//
-// See the documentation for Unmarshal for details about
-// the conversion of JSON into a Go value.
-func (d *Decoder) Decode(v interface{}) error {
- return d.DecodeWithOption(v)
-}
-
-// DecodeContext reads the next JSON-encoded value from its
-// input and stores it in the value pointed to by v with context.Context.
-func (d *Decoder) DecodeContext(ctx context.Context, v interface{}) error {
- d.s.Option.Flags |= decoder.ContextOption
- d.s.Option.Context = ctx
- return d.DecodeWithOption(v)
-}
-
-func (d *Decoder) DecodeWithOption(v interface{}, optFuncs ...DecodeOptionFunc) error {
- header := (*emptyInterface)(unsafe.Pointer(&v))
- typ := header.typ
- ptr := uintptr(header.ptr)
- typeptr := uintptr(unsafe.Pointer(typ))
- // noescape trick for header.typ ( reflect.*rtype )
- copiedType := *(**runtime.Type)(unsafe.Pointer(&typeptr))
-
- if err := validateType(copiedType, ptr); err != nil {
- return err
- }
-
- dec, err := decoder.CompileToGetDecoder(typ)
- if err != nil {
- return err
- }
- if err := d.s.PrepareForDecode(); err != nil {
- return err
- }
- s := d.s
- for _, optFunc := range optFuncs {
- optFunc(s.Option)
- }
- if err := dec.DecodeStream(s, 0, header.ptr); err != nil {
- return err
- }
- s.Reset()
- return nil
-}
-
-func (d *Decoder) More() bool {
- return d.s.More()
-}
-
-func (d *Decoder) Token() (Token, error) {
- return d.s.Token()
-}
-
-// DisallowUnknownFields causes the Decoder to return an error when the destination
-// is a struct and the input contains object keys which do not match any
-// non-ignored, exported fields in the destination.
-func (d *Decoder) DisallowUnknownFields() {
- d.s.DisallowUnknownFields = true
-}
-
-func (d *Decoder) InputOffset() int64 {
- return d.s.TotalOffset()
-}
-
-// UseNumber causes the Decoder to unmarshal a number into an interface{} as a
-// Number instead of as a float64.
-func (d *Decoder) UseNumber() {
- d.s.UseNumber = true
-}
diff --git a/vendor/github.com/goccy/go-json/docker-compose.yml b/vendor/github.com/goccy/go-json/docker-compose.yml
deleted file mode 100644
index db40c79a..00000000
--- a/vendor/github.com/goccy/go-json/docker-compose.yml
+++ /dev/null
@@ -1,13 +0,0 @@
-version: '2'
-services:
- go-json:
- image: golang:1.18
- volumes:
- - '.:/go/src/go-json'
- deploy:
- resources:
- limits:
- memory: 620M
- working_dir: /go/src/go-json
- command: |
- sh -c "go test -c . && ls go-json.test"
diff --git a/vendor/github.com/goccy/go-json/encode.go b/vendor/github.com/goccy/go-json/encode.go
deleted file mode 100644
index c5173825..00000000
--- a/vendor/github.com/goccy/go-json/encode.go
+++ /dev/null
@@ -1,326 +0,0 @@
-package json
-
-import (
- "context"
- "io"
- "os"
- "unsafe"
-
- "github.com/goccy/go-json/internal/encoder"
- "github.com/goccy/go-json/internal/encoder/vm"
- "github.com/goccy/go-json/internal/encoder/vm_color"
- "github.com/goccy/go-json/internal/encoder/vm_color_indent"
- "github.com/goccy/go-json/internal/encoder/vm_indent"
-)
-
-// An Encoder writes JSON values to an output stream.
-type Encoder struct {
- w io.Writer
- enabledIndent bool
- enabledHTMLEscape bool
- prefix string
- indentStr string
-}
-
-// NewEncoder returns a new encoder that writes to w.
-func NewEncoder(w io.Writer) *Encoder {
- return &Encoder{w: w, enabledHTMLEscape: true}
-}
-
-// Encode writes the JSON encoding of v to the stream, followed by a newline character.
-//
-// See the documentation for Marshal for details about the conversion of Go values to JSON.
-func (e *Encoder) Encode(v interface{}) error {
- return e.EncodeWithOption(v)
-}
-
-// EncodeWithOption call Encode with EncodeOption.
-func (e *Encoder) EncodeWithOption(v interface{}, optFuncs ...EncodeOptionFunc) error {
- ctx := encoder.TakeRuntimeContext()
- ctx.Option.Flag = 0
-
- err := e.encodeWithOption(ctx, v, optFuncs...)
-
- encoder.ReleaseRuntimeContext(ctx)
- return err
-}
-
-// EncodeContext call Encode with context.Context and EncodeOption.
-func (e *Encoder) EncodeContext(ctx context.Context, v interface{}, optFuncs ...EncodeOptionFunc) error {
- rctx := encoder.TakeRuntimeContext()
- rctx.Option.Flag = 0
- rctx.Option.Flag |= encoder.ContextOption
- rctx.Option.Context = ctx
-
- err := e.encodeWithOption(rctx, v, optFuncs...) //nolint: contextcheck
-
- encoder.ReleaseRuntimeContext(rctx)
- return err
-}
-
-func (e *Encoder) encodeWithOption(ctx *encoder.RuntimeContext, v interface{}, optFuncs ...EncodeOptionFunc) error {
- if e.enabledHTMLEscape {
- ctx.Option.Flag |= encoder.HTMLEscapeOption
- }
- ctx.Option.Flag |= encoder.NormalizeUTF8Option
- ctx.Option.DebugOut = os.Stdout
- for _, optFunc := range optFuncs {
- optFunc(ctx.Option)
- }
- var (
- buf []byte
- err error
- )
- if e.enabledIndent {
- buf, err = encodeIndent(ctx, v, e.prefix, e.indentStr)
- } else {
- buf, err = encode(ctx, v)
- }
- if err != nil {
- return err
- }
- if e.enabledIndent {
- buf = buf[:len(buf)-2]
- } else {
- buf = buf[:len(buf)-1]
- }
- buf = append(buf, '\n')
- if _, err := e.w.Write(buf); err != nil {
- return err
- }
- return nil
-}
-
-// SetEscapeHTML specifies whether problematic HTML characters should be escaped inside JSON quoted strings.
-// The default behavior is to escape &, <, and > to \u0026, \u003c, and \u003e to avoid certain safety problems that can arise when embedding JSON in HTML.
-//
-// In non-HTML settings where the escaping interferes with the readability of the output, SetEscapeHTML(false) disables this behavior.
-func (e *Encoder) SetEscapeHTML(on bool) {
- e.enabledHTMLEscape = on
-}
-
-// SetIndent instructs the encoder to format each subsequent encoded value as if indented by the package-level function Indent(dst, src, prefix, indent).
-// Calling SetIndent("", "") disables indentation.
-func (e *Encoder) SetIndent(prefix, indent string) {
- if prefix == "" && indent == "" {
- e.enabledIndent = false
- return
- }
- e.prefix = prefix
- e.indentStr = indent
- e.enabledIndent = true
-}
-
-func marshalContext(ctx context.Context, v interface{}, optFuncs ...EncodeOptionFunc) ([]byte, error) {
- rctx := encoder.TakeRuntimeContext()
- rctx.Option.Flag = 0
- rctx.Option.Flag = encoder.HTMLEscapeOption | encoder.NormalizeUTF8Option | encoder.ContextOption
- rctx.Option.Context = ctx
- for _, optFunc := range optFuncs {
- optFunc(rctx.Option)
- }
-
- buf, err := encode(rctx, v) //nolint: contextcheck
- if err != nil {
- encoder.ReleaseRuntimeContext(rctx)
- return nil, err
- }
-
- // this line exists to escape call of `runtime.makeslicecopy` .
- // if use `make([]byte, len(buf)-1)` and `copy(copied, buf)`,
- // dst buffer size and src buffer size are differrent.
- // in this case, compiler uses `runtime.makeslicecopy`, but it is slow.
- buf = buf[:len(buf)-1]
- copied := make([]byte, len(buf))
- copy(copied, buf)
-
- encoder.ReleaseRuntimeContext(rctx)
- return copied, nil
-}
-
-func marshal(v interface{}, optFuncs ...EncodeOptionFunc) ([]byte, error) {
- ctx := encoder.TakeRuntimeContext()
-
- ctx.Option.Flag = 0
- ctx.Option.Flag |= (encoder.HTMLEscapeOption | encoder.NormalizeUTF8Option)
- for _, optFunc := range optFuncs {
- optFunc(ctx.Option)
- }
-
- buf, err := encode(ctx, v)
- if err != nil {
- encoder.ReleaseRuntimeContext(ctx)
- return nil, err
- }
-
- // this line exists to escape call of `runtime.makeslicecopy` .
- // if use `make([]byte, len(buf)-1)` and `copy(copied, buf)`,
- // dst buffer size and src buffer size are differrent.
- // in this case, compiler uses `runtime.makeslicecopy`, but it is slow.
- buf = buf[:len(buf)-1]
- copied := make([]byte, len(buf))
- copy(copied, buf)
-
- encoder.ReleaseRuntimeContext(ctx)
- return copied, nil
-}
-
-func marshalNoEscape(v interface{}) ([]byte, error) {
- ctx := encoder.TakeRuntimeContext()
-
- ctx.Option.Flag = 0
- ctx.Option.Flag |= (encoder.HTMLEscapeOption | encoder.NormalizeUTF8Option)
-
- buf, err := encodeNoEscape(ctx, v)
- if err != nil {
- encoder.ReleaseRuntimeContext(ctx)
- return nil, err
- }
-
- // this line exists to escape call of `runtime.makeslicecopy` .
- // if use `make([]byte, len(buf)-1)` and `copy(copied, buf)`,
- // dst buffer size and src buffer size are differrent.
- // in this case, compiler uses `runtime.makeslicecopy`, but it is slow.
- buf = buf[:len(buf)-1]
- copied := make([]byte, len(buf))
- copy(copied, buf)
-
- encoder.ReleaseRuntimeContext(ctx)
- return copied, nil
-}
-
-func marshalIndent(v interface{}, prefix, indent string, optFuncs ...EncodeOptionFunc) ([]byte, error) {
- ctx := encoder.TakeRuntimeContext()
-
- ctx.Option.Flag = 0
- ctx.Option.Flag |= (encoder.HTMLEscapeOption | encoder.NormalizeUTF8Option | encoder.IndentOption)
- for _, optFunc := range optFuncs {
- optFunc(ctx.Option)
- }
-
- buf, err := encodeIndent(ctx, v, prefix, indent)
- if err != nil {
- encoder.ReleaseRuntimeContext(ctx)
- return nil, err
- }
-
- buf = buf[:len(buf)-2]
- copied := make([]byte, len(buf))
- copy(copied, buf)
-
- encoder.ReleaseRuntimeContext(ctx)
- return copied, nil
-}
-
-func encode(ctx *encoder.RuntimeContext, v interface{}) ([]byte, error) {
- b := ctx.Buf[:0]
- if v == nil {
- b = encoder.AppendNull(ctx, b)
- b = encoder.AppendComma(ctx, b)
- return b, nil
- }
- header := (*emptyInterface)(unsafe.Pointer(&v))
- typ := header.typ
-
- typeptr := uintptr(unsafe.Pointer(typ))
- codeSet, err := encoder.CompileToGetCodeSet(ctx, typeptr)
- if err != nil {
- return nil, err
- }
-
- p := uintptr(header.ptr)
- ctx.Init(p, codeSet.CodeLength)
- ctx.KeepRefs = append(ctx.KeepRefs, header.ptr)
-
- buf, err := encodeRunCode(ctx, b, codeSet)
- if err != nil {
- return nil, err
- }
- ctx.Buf = buf
- return buf, nil
-}
-
-func encodeNoEscape(ctx *encoder.RuntimeContext, v interface{}) ([]byte, error) {
- b := ctx.Buf[:0]
- if v == nil {
- b = encoder.AppendNull(ctx, b)
- b = encoder.AppendComma(ctx, b)
- return b, nil
- }
- header := (*emptyInterface)(unsafe.Pointer(&v))
- typ := header.typ
-
- typeptr := uintptr(unsafe.Pointer(typ))
- codeSet, err := encoder.CompileToGetCodeSet(ctx, typeptr)
- if err != nil {
- return nil, err
- }
-
- p := uintptr(header.ptr)
- ctx.Init(p, codeSet.CodeLength)
- buf, err := encodeRunCode(ctx, b, codeSet)
- if err != nil {
- return nil, err
- }
-
- ctx.Buf = buf
- return buf, nil
-}
-
-func encodeIndent(ctx *encoder.RuntimeContext, v interface{}, prefix, indent string) ([]byte, error) {
- b := ctx.Buf[:0]
- if v == nil {
- b = encoder.AppendNull(ctx, b)
- b = encoder.AppendCommaIndent(ctx, b)
- return b, nil
- }
- header := (*emptyInterface)(unsafe.Pointer(&v))
- typ := header.typ
-
- typeptr := uintptr(unsafe.Pointer(typ))
- codeSet, err := encoder.CompileToGetCodeSet(ctx, typeptr)
- if err != nil {
- return nil, err
- }
-
- p := uintptr(header.ptr)
- ctx.Init(p, codeSet.CodeLength)
- buf, err := encodeRunIndentCode(ctx, b, codeSet, prefix, indent)
-
- ctx.KeepRefs = append(ctx.KeepRefs, header.ptr)
-
- if err != nil {
- return nil, err
- }
-
- ctx.Buf = buf
- return buf, nil
-}
-
-func encodeRunCode(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet) ([]byte, error) {
- if (ctx.Option.Flag & encoder.DebugOption) != 0 {
- if (ctx.Option.Flag & encoder.ColorizeOption) != 0 {
- return vm_color.DebugRun(ctx, b, codeSet)
- }
- return vm.DebugRun(ctx, b, codeSet)
- }
- if (ctx.Option.Flag & encoder.ColorizeOption) != 0 {
- return vm_color.Run(ctx, b, codeSet)
- }
- return vm.Run(ctx, b, codeSet)
-}
-
-func encodeRunIndentCode(ctx *encoder.RuntimeContext, b []byte, codeSet *encoder.OpcodeSet, prefix, indent string) ([]byte, error) {
- ctx.Prefix = []byte(prefix)
- ctx.IndentStr = []byte(indent)
- if (ctx.Option.Flag & encoder.DebugOption) != 0 {
- if (ctx.Option.Flag & encoder.ColorizeOption) != 0 {
- return vm_color_indent.DebugRun(ctx, b, codeSet)
- }
- return vm_indent.DebugRun(ctx, b, codeSet)
- }
- if (ctx.Option.Flag & encoder.ColorizeOption) != 0 {
- return vm_color_indent.Run(ctx, b, codeSet)
- }
- return vm_indent.Run(ctx, b, codeSet)
-}
diff --git a/vendor/github.com/goccy/go-json/error.go b/vendor/github.com/goccy/go-json/error.go
deleted file mode 100644
index 5b2dcee5..00000000
--- a/vendor/github.com/goccy/go-json/error.go
+++ /dev/null
@@ -1,41 +0,0 @@
-package json
-
-import (
- "github.com/goccy/go-json/internal/errors"
-)
-
-// Before Go 1.2, an InvalidUTF8Error was returned by Marshal when
-// attempting to encode a string value with invalid UTF-8 sequences.
-// As of Go 1.2, Marshal instead coerces the string to valid UTF-8 by
-// replacing invalid bytes with the Unicode replacement rune U+FFFD.
-//
-// Deprecated: No longer used; kept for compatibility.
-type InvalidUTF8Error = errors.InvalidUTF8Error
-
-// An InvalidUnmarshalError describes an invalid argument passed to Unmarshal.
-// (The argument to Unmarshal must be a non-nil pointer.)
-type InvalidUnmarshalError = errors.InvalidUnmarshalError
-
-// A MarshalerError represents an error from calling a MarshalJSON or MarshalText method.
-type MarshalerError = errors.MarshalerError
-
-// A SyntaxError is a description of a JSON syntax error.
-type SyntaxError = errors.SyntaxError
-
-// An UnmarshalFieldError describes a JSON object key that
-// led to an unexported (and therefore unwritable) struct field.
-//
-// Deprecated: No longer used; kept for compatibility.
-type UnmarshalFieldError = errors.UnmarshalFieldError
-
-// An UnmarshalTypeError describes a JSON value that was
-// not appropriate for a value of a specific Go type.
-type UnmarshalTypeError = errors.UnmarshalTypeError
-
-// An UnsupportedTypeError is returned by Marshal when attempting
-// to encode an unsupported value type.
-type UnsupportedTypeError = errors.UnsupportedTypeError
-
-type UnsupportedValueError = errors.UnsupportedValueError
-
-type PathError = errors.PathError
diff --git a/vendor/github.com/goccy/go-json/internal/decoder/anonymous_field.go b/vendor/github.com/goccy/go-json/internal/decoder/anonymous_field.go
deleted file mode 100644
index b6876cf0..00000000
--- a/vendor/github.com/goccy/go-json/internal/decoder/anonymous_field.go
+++ /dev/null
@@ -1,41 +0,0 @@
-package decoder
-
-import (
- "unsafe"
-
- "github.com/goccy/go-json/internal/runtime"
-)
-
-type anonymousFieldDecoder struct {
- structType *runtime.Type
- offset uintptr
- dec Decoder
-}
-
-func newAnonymousFieldDecoder(structType *runtime.Type, offset uintptr, dec Decoder) *anonymousFieldDecoder {
- return &anonymousFieldDecoder{
- structType: structType,
- offset: offset,
- dec: dec,
- }
-}
-
-func (d *anonymousFieldDecoder) DecodeStream(s *Stream, depth int64, p unsafe.Pointer) error {
- if *(*unsafe.Pointer)(p) == nil {
- *(*unsafe.Pointer)(p) = unsafe_New(d.structType)
- }
- p = *(*unsafe.Pointer)(p)
- return d.dec.DecodeStream(s, depth, unsafe.Pointer(uintptr(p)+d.offset))
-}
-
-func (d *anonymousFieldDecoder) Decode(ctx *RuntimeContext, cursor, depth int64, p unsafe.Pointer) (int64, error) {
- if *(*unsafe.Pointer)(p) == nil {
- *(*unsafe.Pointer)(p) = unsafe_New(d.structType)
- }
- p = *(*unsafe.Pointer)(p)
- return d.dec.Decode(ctx, cursor, depth, unsafe.Pointer(uintptr(p)+d.offset))
-}
-
-func (d *anonymousFieldDecoder) DecodePath(ctx *RuntimeContext, cursor, depth int64) ([][]byte, int64, error) {
- return d.dec.DecodePath(ctx, cursor, depth)
-}
diff --git a/vendor/github.com/goccy/go-json/internal/decoder/array.go b/vendor/github.com/goccy/go-json/internal/decoder/array.go
deleted file mode 100644
index 4b23ed43..00000000
--- a/vendor/github.com/goccy/go-json/internal/decoder/array.go
+++ /dev/null
@@ -1,176 +0,0 @@
-package decoder
-
-import (
- "fmt"
- "unsafe"
-
- "github.com/goccy/go-json/internal/errors"
- "github.com/goccy/go-json/internal/runtime"
-)
-
-type arrayDecoder struct {
- elemType *runtime.Type
- size uintptr
- valueDecoder Decoder
- alen int
- structName string
- fieldName string
- zeroValue unsafe.Pointer
-}
-
-func newArrayDecoder(dec Decoder, elemType *runtime.Type, alen int, structName, fieldName string) *arrayDecoder {
- // workaround to avoid checkptr errors. cannot use `*(*unsafe.Pointer)(unsafe_New(elemType))` directly.
- zeroValuePtr := unsafe_New(elemType)
- zeroValue := **(**unsafe.Pointer)(unsafe.Pointer(&zeroValuePtr))
- return &arrayDecoder{
- valueDecoder: dec,
- elemType: elemType,
- size: elemType.Size(),
- alen: alen,
- structName: structName,
- fieldName: fieldName,
- zeroValue: zeroValue,
- }
-}
-
-func (d *arrayDecoder) DecodeStream(s *Stream, depth int64, p unsafe.Pointer) error {
- depth++
- if depth > maxDecodeNestingDepth {
- return errors.ErrExceededMaxDepth(s.char(), s.cursor)
- }
-
- for {
- switch s.char() {
- case ' ', '\n', '\t', '\r':
- case 'n':
- if err := nullBytes(s); err != nil {
- return err
- }
- return nil
- case '[':
- idx := 0
- s.cursor++
- if s.skipWhiteSpace() == ']' {
- for idx < d.alen {
- *(*unsafe.Pointer)(unsafe.Pointer(uintptr(p) + uintptr(idx)*d.size)) = d.zeroValue
- idx++
- }
- s.cursor++
- return nil
- }
- for {
- if idx < d.alen {
- if err := d.valueDecoder.DecodeStream(s, depth, unsafe.Pointer(uintptr(p)+uintptr(idx)*d.size)); err != nil {
- return err
- }
- } else {
- if err := s.skipValue(depth); err != nil {
- return err
- }
- }
- idx++
- switch s.skipWhiteSpace() {
- case ']':
- for idx < d.alen {
- *(*unsafe.Pointer)(unsafe.Pointer(uintptr(p) + uintptr(idx)*d.size)) = d.zeroValue
- idx++
- }
- s.cursor++
- return nil
- case ',':
- s.cursor++
- continue
- case nul:
- if s.read() {
- s.cursor++
- continue
- }
- goto ERROR
- default:
- goto ERROR
- }
- }
- case nul:
- if s.read() {
- continue
- }
- goto ERROR
- default:
- goto ERROR
- }
- s.cursor++
- }
-ERROR:
- return errors.ErrUnexpectedEndOfJSON("array", s.totalOffset())
-}
-
-func (d *arrayDecoder) Decode(ctx *RuntimeContext, cursor, depth int64, p unsafe.Pointer) (int64, error) {
- buf := ctx.Buf
- depth++
- if depth > maxDecodeNestingDepth {
- return 0, errors.ErrExceededMaxDepth(buf[cursor], cursor)
- }
-
- for {
- switch buf[cursor] {
- case ' ', '\n', '\t', '\r':
- cursor++
- continue
- case 'n':
- if err := validateNull(buf, cursor); err != nil {
- return 0, err
- }
- cursor += 4
- return cursor, nil
- case '[':
- idx := 0
- cursor++
- cursor = skipWhiteSpace(buf, cursor)
- if buf[cursor] == ']' {
- for idx < d.alen {
- *(*unsafe.Pointer)(unsafe.Pointer(uintptr(p) + uintptr(idx)*d.size)) = d.zeroValue
- idx++
- }
- cursor++
- return cursor, nil
- }
- for {
- if idx < d.alen {
- c, err := d.valueDecoder.Decode(ctx, cursor, depth, unsafe.Pointer(uintptr(p)+uintptr(idx)*d.size))
- if err != nil {
- return 0, err
- }
- cursor = c
- } else {
- c, err := skipValue(buf, cursor, depth)
- if err != nil {
- return 0, err
- }
- cursor = c
- }
- idx++
- cursor = skipWhiteSpace(buf, cursor)
- switch buf[cursor] {
- case ']':
- for idx < d.alen {
- *(*unsafe.Pointer)(unsafe.Pointer(uintptr(p) + uintptr(idx)*d.size)) = d.zeroValue
- idx++
- }
- cursor++
- return cursor, nil
- case ',':
- cursor++
- continue
- default:
- return 0, errors.ErrInvalidCharacter(buf[cursor], "array", cursor)
- }
- }
- default:
- return 0, errors.ErrUnexpectedEndOfJSON("array", cursor)
- }
- }
-}
-
-func (d *arrayDecoder) DecodePath(ctx *RuntimeContext, cursor, depth int64) ([][]byte, int64, error) {
- return nil, 0, fmt.Errorf("json: array decoder does not support decode path")
-}
diff --git a/vendor/github.com/goccy/go-json/internal/decoder/assign.go b/vendor/github.com/goccy/go-json/internal/decoder/assign.go
deleted file mode 100644
index c53e6ad9..00000000
--- a/vendor/github.com/goccy/go-json/internal/decoder/assign.go
+++ /dev/null
@@ -1,438 +0,0 @@
-package decoder
-
-import (
- "fmt"
- "reflect"
- "strconv"
-)
-
-var (
- nilValue = reflect.ValueOf(nil)
-)
-
-func AssignValue(src, dst reflect.Value) error {
- if dst.Type().Kind() != reflect.Ptr {
- return fmt.Errorf("invalid dst type. required pointer type: %T", dst.Type())
- }
- casted, err := castValue(dst.Elem().Type(), src)
- if err != nil {
- return err
- }
- dst.Elem().Set(casted)
- return nil
-}
-
-func castValue(t reflect.Type, v reflect.Value) (reflect.Value, error) {
- switch t.Kind() {
- case reflect.Int:
- vv, err := castInt(v)
- if err != nil {
- return nilValue, err
- }
- return reflect.ValueOf(int(vv.Int())), nil
- case reflect.Int8:
- vv, err := castInt(v)
- if err != nil {
- return nilValue, err
- }
- return reflect.ValueOf(int8(vv.Int())), nil
- case reflect.Int16:
- vv, err := castInt(v)
- if err != nil {
- return nilValue, err
- }
- return reflect.ValueOf(int16(vv.Int())), nil
- case reflect.Int32:
- vv, err := castInt(v)
- if err != nil {
- return nilValue, err
- }
- return reflect.ValueOf(int32(vv.Int())), nil
- case reflect.Int64:
- return castInt(v)
- case reflect.Uint:
- vv, err := castUint(v)
- if err != nil {
- return nilValue, err
- }
- return reflect.ValueOf(uint(vv.Uint())), nil
- case reflect.Uint8:
- vv, err := castUint(v)
- if err != nil {
- return nilValue, err
- }
- return reflect.ValueOf(uint8(vv.Uint())), nil
- case reflect.Uint16:
- vv, err := castUint(v)
- if err != nil {
- return nilValue, err
- }
- return reflect.ValueOf(uint16(vv.Uint())), nil
- case reflect.Uint32:
- vv, err := castUint(v)
- if err != nil {
- return nilValue, err
- }
- return reflect.ValueOf(uint32(vv.Uint())), nil
- case reflect.Uint64:
- return castUint(v)
- case reflect.Uintptr:
- vv, err := castUint(v)
- if err != nil {
- return nilValue, err
- }
- return reflect.ValueOf(uintptr(vv.Uint())), nil
- case reflect.String:
- return castString(v)
- case reflect.Bool:
- return castBool(v)
- case reflect.Float32:
- vv, err := castFloat(v)
- if err != nil {
- return nilValue, err
- }
- return reflect.ValueOf(float32(vv.Float())), nil
- case reflect.Float64:
- return castFloat(v)
- case reflect.Array:
- return castArray(t, v)
- case reflect.Slice:
- return castSlice(t, v)
- case reflect.Map:
- return castMap(t, v)
- case reflect.Struct:
- return castStruct(t, v)
- }
- return v, nil
-}
-
-func castInt(v reflect.Value) (reflect.Value, error) {
- switch v.Type().Kind() {
- case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
- return v, nil
- case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
- return reflect.ValueOf(int64(v.Uint())), nil
- case reflect.String:
- i64, err := strconv.ParseInt(v.String(), 10, 64)
- if err != nil {
- return nilValue, err
- }
- return reflect.ValueOf(i64), nil
- case reflect.Bool:
- if v.Bool() {
- return reflect.ValueOf(int64(1)), nil
- }
- return reflect.ValueOf(int64(0)), nil
- case reflect.Float32, reflect.Float64:
- return reflect.ValueOf(int64(v.Float())), nil
- case reflect.Array:
- if v.Len() > 0 {
- return castInt(v.Index(0))
- }
- return nilValue, fmt.Errorf("failed to cast to int64 from empty array")
- case reflect.Slice:
- if v.Len() > 0 {
- return castInt(v.Index(0))
- }
- return nilValue, fmt.Errorf("failed to cast to int64 from empty slice")
- case reflect.Interface:
- return castInt(reflect.ValueOf(v.Interface()))
- case reflect.Map:
- return nilValue, fmt.Errorf("failed to cast to int64 from map")
- case reflect.Struct:
- return nilValue, fmt.Errorf("failed to cast to int64 from struct")
- case reflect.Ptr:
- return castInt(v.Elem())
- }
- return nilValue, fmt.Errorf("failed to cast to int64 from %s", v.Type().Kind())
-}
-
-func castUint(v reflect.Value) (reflect.Value, error) {
- switch v.Type().Kind() {
- case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
- return reflect.ValueOf(uint64(v.Int())), nil
- case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
- return v, nil
- case reflect.String:
- u64, err := strconv.ParseUint(v.String(), 10, 64)
- if err != nil {
- return nilValue, err
- }
- return reflect.ValueOf(u64), nil
- case reflect.Bool:
- if v.Bool() {
- return reflect.ValueOf(uint64(1)), nil
- }
- return reflect.ValueOf(uint64(0)), nil
- case reflect.Float32, reflect.Float64:
- return reflect.ValueOf(uint64(v.Float())), nil
- case reflect.Array:
- if v.Len() > 0 {
- return castUint(v.Index(0))
- }
- return nilValue, fmt.Errorf("failed to cast to uint64 from empty array")
- case reflect.Slice:
- if v.Len() > 0 {
- return castUint(v.Index(0))
- }
- return nilValue, fmt.Errorf("failed to cast to uint64 from empty slice")
- case reflect.Interface:
- return castUint(reflect.ValueOf(v.Interface()))
- case reflect.Map:
- return nilValue, fmt.Errorf("failed to cast to uint64 from map")
- case reflect.Struct:
- return nilValue, fmt.Errorf("failed to cast to uint64 from struct")
- case reflect.Ptr:
- return castUint(v.Elem())
- }
- return nilValue, fmt.Errorf("failed to cast to uint64 from %s", v.Type().Kind())
-}
-
-func castString(v reflect.Value) (reflect.Value, error) {
- switch v.Type().Kind() {
- case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
- return reflect.ValueOf(fmt.Sprint(v.Int())), nil
- case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
- return reflect.ValueOf(fmt.Sprint(v.Uint())), nil
- case reflect.String:
- return v, nil
- case reflect.Bool:
- if v.Bool() {
- return reflect.ValueOf("true"), nil
- }
- return reflect.ValueOf("false"), nil
- case reflect.Float32, reflect.Float64:
- return reflect.ValueOf(fmt.Sprint(v.Float())), nil
- case reflect.Array:
- if v.Len() > 0 {
- return castString(v.Index(0))
- }
- return nilValue, fmt.Errorf("failed to cast to string from empty array")
- case reflect.Slice:
- if v.Len() > 0 {
- return castString(v.Index(0))
- }
- return nilValue, fmt.Errorf("failed to cast to string from empty slice")
- case reflect.Interface:
- return castString(reflect.ValueOf(v.Interface()))
- case reflect.Map:
- return nilValue, fmt.Errorf("failed to cast to string from map")
- case reflect.Struct:
- return nilValue, fmt.Errorf("failed to cast to string from struct")
- case reflect.Ptr:
- return castString(v.Elem())
- }
- return nilValue, fmt.Errorf("failed to cast to string from %s", v.Type().Kind())
-}
-
-func castBool(v reflect.Value) (reflect.Value, error) {
- switch v.Type().Kind() {
- case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
- switch v.Int() {
- case 0:
- return reflect.ValueOf(false), nil
- case 1:
- return reflect.ValueOf(true), nil
- }
- return nilValue, fmt.Errorf("failed to cast to bool from %d", v.Int())
- case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
- switch v.Uint() {
- case 0:
- return reflect.ValueOf(false), nil
- case 1:
- return reflect.ValueOf(true), nil
- }
- return nilValue, fmt.Errorf("failed to cast to bool from %d", v.Uint())
- case reflect.String:
- b, err := strconv.ParseBool(v.String())
- if err != nil {
- return nilValue, err
- }
- return reflect.ValueOf(b), nil
- case reflect.Bool:
- return v, nil
- case reflect.Float32, reflect.Float64:
- switch v.Float() {
- case 0:
- return reflect.ValueOf(false), nil
- case 1:
- return reflect.ValueOf(true), nil
- }
- return nilValue, fmt.Errorf("failed to cast to bool from %f", v.Float())
- case reflect.Array:
- if v.Len() > 0 {
- return castBool(v.Index(0))
- }
- return nilValue, fmt.Errorf("failed to cast to string from empty array")
- case reflect.Slice:
- if v.Len() > 0 {
- return castBool(v.Index(0))
- }
- return nilValue, fmt.Errorf("failed to cast to string from empty slice")
- case reflect.Interface:
- return castBool(reflect.ValueOf(v.Interface()))
- case reflect.Map:
- return nilValue, fmt.Errorf("failed to cast to string from map")
- case reflect.Struct:
- return nilValue, fmt.Errorf("failed to cast to string from struct")
- case reflect.Ptr:
- return castBool(v.Elem())
- }
- return nilValue, fmt.Errorf("failed to cast to bool from %s", v.Type().Kind())
-}
-
-func castFloat(v reflect.Value) (reflect.Value, error) {
- switch v.Type().Kind() {
- case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
- return reflect.ValueOf(float64(v.Int())), nil
- case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
- return reflect.ValueOf(float64(v.Uint())), nil
- case reflect.String:
- f64, err := strconv.ParseFloat(v.String(), 64)
- if err != nil {
- return nilValue, err
- }
- return reflect.ValueOf(f64), nil
- case reflect.Bool:
- if v.Bool() {
- return reflect.ValueOf(float64(1)), nil
- }
- return reflect.ValueOf(float64(0)), nil
- case reflect.Float32, reflect.Float64:
- return v, nil
- case reflect.Array:
- if v.Len() > 0 {
- return castFloat(v.Index(0))
- }
- return nilValue, fmt.Errorf("failed to cast to float64 from empty array")
- case reflect.Slice:
- if v.Len() > 0 {
- return castFloat(v.Index(0))
- }
- return nilValue, fmt.Errorf("failed to cast to float64 from empty slice")
- case reflect.Interface:
- return castFloat(reflect.ValueOf(v.Interface()))
- case reflect.Map:
- return nilValue, fmt.Errorf("failed to cast to float64 from map")
- case reflect.Struct:
- return nilValue, fmt.Errorf("failed to cast to float64 from struct")
- case reflect.Ptr:
- return castFloat(v.Elem())
- }
- return nilValue, fmt.Errorf("failed to cast to float64 from %s", v.Type().Kind())
-}
-
-func castArray(t reflect.Type, v reflect.Value) (reflect.Value, error) {
- kind := v.Type().Kind()
- if kind == reflect.Interface {
- return castArray(t, reflect.ValueOf(v.Interface()))
- }
- if kind != reflect.Slice && kind != reflect.Array {
- return nilValue, fmt.Errorf("failed to cast to array from %s", kind)
- }
- if t.Elem() == v.Type().Elem() {
- return v, nil
- }
- if t.Len() != v.Len() {
- return nilValue, fmt.Errorf("failed to cast [%d]array from slice of %d length", t.Len(), v.Len())
- }
- ret := reflect.New(t).Elem()
- for i := 0; i < v.Len(); i++ {
- vv, err := castValue(t.Elem(), v.Index(i))
- if err != nil {
- return nilValue, err
- }
- ret.Index(i).Set(vv)
- }
- return ret, nil
-}
-
-func castSlice(t reflect.Type, v reflect.Value) (reflect.Value, error) {
- kind := v.Type().Kind()
- if kind == reflect.Interface {
- return castSlice(t, reflect.ValueOf(v.Interface()))
- }
- if kind != reflect.Slice && kind != reflect.Array {
- return nilValue, fmt.Errorf("failed to cast to slice from %s", kind)
- }
- if t.Elem() == v.Type().Elem() {
- return v, nil
- }
- ret := reflect.MakeSlice(t, v.Len(), v.Len())
- for i := 0; i < v.Len(); i++ {
- vv, err := castValue(t.Elem(), v.Index(i))
- if err != nil {
- return nilValue, err
- }
- ret.Index(i).Set(vv)
- }
- return ret, nil
-}
-
-func castMap(t reflect.Type, v reflect.Value) (reflect.Value, error) {
- ret := reflect.MakeMap(t)
- switch v.Type().Kind() {
- case reflect.Map:
- iter := v.MapRange()
- for iter.Next() {
- key, err := castValue(t.Key(), iter.Key())
- if err != nil {
- return nilValue, err
- }
- value, err := castValue(t.Elem(), iter.Value())
- if err != nil {
- return nilValue, err
- }
- ret.SetMapIndex(key, value)
- }
- return ret, nil
- case reflect.Interface:
- return castMap(t, reflect.ValueOf(v.Interface()))
- case reflect.Slice:
- if v.Len() > 0 {
- return castMap(t, v.Index(0))
- }
- return nilValue, fmt.Errorf("failed to cast to map from empty slice")
- }
- return nilValue, fmt.Errorf("failed to cast to map from %s", v.Type().Kind())
-}
-
-func castStruct(t reflect.Type, v reflect.Value) (reflect.Value, error) {
- ret := reflect.New(t).Elem()
- switch v.Type().Kind() {
- case reflect.Map:
- iter := v.MapRange()
- for iter.Next() {
- key := iter.Key()
- k, err := castString(key)
- if err != nil {
- return nilValue, err
- }
- fieldName := k.String()
- field, ok := t.FieldByName(fieldName)
- if ok {
- value, err := castValue(field.Type, iter.Value())
- if err != nil {
- return nilValue, err
- }
- ret.FieldByName(fieldName).Set(value)
- }
- }
- return ret, nil
- case reflect.Struct:
- for i := 0; i < v.Type().NumField(); i++ {
- name := v.Type().Field(i).Name
- ret.FieldByName(name).Set(v.FieldByName(name))
- }
- return ret, nil
- case reflect.Interface:
- return castStruct(t, reflect.ValueOf(v.Interface()))
- case reflect.Slice:
- if v.Len() > 0 {
- return castStruct(t, v.Index(0))
- }
- return nilValue, fmt.Errorf("failed to cast to struct from empty slice")
- default:
- return nilValue, fmt.Errorf("failed to cast to struct from %s", v.Type().Kind())
- }
-}
diff --git a/vendor/github.com/goccy/go-json/internal/decoder/bool.go b/vendor/github.com/goccy/go-json/internal/decoder/bool.go
deleted file mode 100644
index ba6cf5bc..00000000
--- a/vendor/github.com/goccy/go-json/internal/decoder/bool.go
+++ /dev/null
@@ -1,83 +0,0 @@
-package decoder
-
-import (
- "fmt"
- "unsafe"
-
- "github.com/goccy/go-json/internal/errors"
-)
-
-type boolDecoder struct {
- structName string
- fieldName string
-}
-
-func newBoolDecoder(structName, fieldName string) *boolDecoder {
- return &boolDecoder{structName: structName, fieldName: fieldName}
-}
-
-func (d *boolDecoder) DecodeStream(s *Stream, depth int64, p unsafe.Pointer) error {
- c := s.skipWhiteSpace()
- for {
- switch c {
- case 't':
- if err := trueBytes(s); err != nil {
- return err
- }
- **(**bool)(unsafe.Pointer(&p)) = true
- return nil
- case 'f':
- if err := falseBytes(s); err != nil {
- return err
- }
- **(**bool)(unsafe.Pointer(&p)) = false
- return nil
- case 'n':
- if err := nullBytes(s); err != nil {
- return err
- }
- return nil
- case nul:
- if s.read() {
- c = s.char()
- continue
- }
- goto ERROR
- }
- break
- }
-ERROR:
- return errors.ErrUnexpectedEndOfJSON("bool", s.totalOffset())
-}
-
-func (d *boolDecoder) Decode(ctx *RuntimeContext, cursor, depth int64, p unsafe.Pointer) (int64, error) {
- buf := ctx.Buf
- cursor = skipWhiteSpace(buf, cursor)
- switch buf[cursor] {
- case 't':
- if err := validateTrue(buf, cursor); err != nil {
- return 0, err
- }
- cursor += 4
- **(**bool)(unsafe.Pointer(&p)) = true
- return cursor, nil
- case 'f':
- if err := validateFalse(buf, cursor); err != nil {
- return 0, err
- }
- cursor += 5
- **(**bool)(unsafe.Pointer(&p)) = false
- return cursor, nil
- case 'n':
- if err := validateNull(buf, cursor); err != nil {
- return 0, err
- }
- cursor += 4
- return cursor, nil
- }
- return 0, errors.ErrUnexpectedEndOfJSON("bool", cursor)
-}
-
-func (d *boolDecoder) DecodePath(ctx *RuntimeContext, cursor, depth int64) ([][]byte, int64, error) {
- return nil, 0, fmt.Errorf("json: bool decoder does not support decode path")
-}
diff --git a/vendor/github.com/goccy/go-json/internal/decoder/bytes.go b/vendor/github.com/goccy/go-json/internal/decoder/bytes.go
deleted file mode 100644
index 939bf432..00000000
--- a/vendor/github.com/goccy/go-json/internal/decoder/bytes.go
+++ /dev/null
@@ -1,118 +0,0 @@
-package decoder
-
-import (
- "encoding/base64"
- "fmt"
- "unsafe"
-
- "github.com/goccy/go-json/internal/errors"
- "github.com/goccy/go-json/internal/runtime"
-)
-
-type bytesDecoder struct {
- typ *runtime.Type
- sliceDecoder Decoder
- stringDecoder *stringDecoder
- structName string
- fieldName string
-}
-
-func byteUnmarshalerSliceDecoder(typ *runtime.Type, structName string, fieldName string) Decoder {
- var unmarshalDecoder Decoder
- switch {
- case runtime.PtrTo(typ).Implements(unmarshalJSONType):
- unmarshalDecoder = newUnmarshalJSONDecoder(runtime.PtrTo(typ), structName, fieldName)
- case runtime.PtrTo(typ).Implements(unmarshalTextType):
- unmarshalDecoder = newUnmarshalTextDecoder(runtime.PtrTo(typ), structName, fieldName)
- default:
- unmarshalDecoder, _ = compileUint8(typ, structName, fieldName)
- }
- return newSliceDecoder(unmarshalDecoder, typ, 1, structName, fieldName)
-}
-
-func newBytesDecoder(typ *runtime.Type, structName string, fieldName string) *bytesDecoder {
- return &bytesDecoder{
- typ: typ,
- sliceDecoder: byteUnmarshalerSliceDecoder(typ, structName, fieldName),
- stringDecoder: newStringDecoder(structName, fieldName),
- structName: structName,
- fieldName: fieldName,
- }
-}
-
-func (d *bytesDecoder) DecodeStream(s *Stream, depth int64, p unsafe.Pointer) error {
- bytes, err := d.decodeStreamBinary(s, depth, p)
- if err != nil {
- return err
- }
- if bytes == nil {
- s.reset()
- return nil
- }
- decodedLen := base64.StdEncoding.DecodedLen(len(bytes))
- buf := make([]byte, decodedLen)
- n, err := base64.StdEncoding.Decode(buf, bytes)
- if err != nil {
- return err
- }
- *(*[]byte)(p) = buf[:n]
- s.reset()
- return nil
-}
-
-func (d *bytesDecoder) Decode(ctx *RuntimeContext, cursor, depth int64, p unsafe.Pointer) (int64, error) {
- bytes, c, err := d.decodeBinary(ctx, cursor, depth, p)
- if err != nil {
- return 0, err
- }
- if bytes == nil {
- return c, nil
- }
- cursor = c
- decodedLen := base64.StdEncoding.DecodedLen(len(bytes))
- b := make([]byte, decodedLen)
- n, err := base64.StdEncoding.Decode(b, bytes)
- if err != nil {
- return 0, err
- }
- *(*[]byte)(p) = b[:n]
- return cursor, nil
-}
-
-func (d *bytesDecoder) DecodePath(ctx *RuntimeContext, cursor, depth int64) ([][]byte, int64, error) {
- return nil, 0, fmt.Errorf("json: []byte decoder does not support decode path")
-}
-
-func (d *bytesDecoder) decodeStreamBinary(s *Stream, depth int64, p unsafe.Pointer) ([]byte, error) {
- c := s.skipWhiteSpace()
- if c == '[' {
- if d.sliceDecoder == nil {
- return nil, &errors.UnmarshalTypeError{
- Type: runtime.RType2Type(d.typ),
- Offset: s.totalOffset(),
- }
- }
- err := d.sliceDecoder.DecodeStream(s, depth, p)
- return nil, err
- }
- return d.stringDecoder.decodeStreamByte(s)
-}
-
-func (d *bytesDecoder) decodeBinary(ctx *RuntimeContext, cursor, depth int64, p unsafe.Pointer) ([]byte, int64, error) {
- buf := ctx.Buf
- cursor = skipWhiteSpace(buf, cursor)
- if buf[cursor] == '[' {
- if d.sliceDecoder == nil {
- return nil, 0, &errors.UnmarshalTypeError{
- Type: runtime.RType2Type(d.typ),
- Offset: cursor,
- }
- }
- c, err := d.sliceDecoder.Decode(ctx, cursor, depth, p)
- if err != nil {
- return nil, 0, err
- }
- return nil, c, nil
- }
- return d.stringDecoder.decodeByte(buf, cursor)
-}
diff --git a/vendor/github.com/goccy/go-json/internal/decoder/compile.go b/vendor/github.com/goccy/go-json/internal/decoder/compile.go
deleted file mode 100644
index 8ad50936..00000000
--- a/vendor/github.com/goccy/go-json/internal/decoder/compile.go
+++ /dev/null
@@ -1,493 +0,0 @@
-package decoder
-
-import (
- "encoding/json"
- "fmt"
- "reflect"
- "strings"
- "sync"
- "sync/atomic"
- "unicode"
- "unsafe"
-
- "github.com/goccy/go-json/internal/runtime"
-)
-
-var (
- jsonNumberType = reflect.TypeOf(json.Number(""))
- typeAddr *runtime.TypeAddr
- cachedDecoderMap unsafe.Pointer // map[uintptr]decoder
- cachedDecoder []Decoder
- initOnce sync.Once
-)
-
-func initDecoder() {
- initOnce.Do(func() {
- typeAddr = runtime.AnalyzeTypeAddr()
- if typeAddr == nil {
- typeAddr = &runtime.TypeAddr{}
- }
- cachedDecoder = make([]Decoder, typeAddr.AddrRange>>typeAddr.AddrShift+1)
- })
-}
-
-func loadDecoderMap() map[uintptr]Decoder {
- initDecoder()
- p := atomic.LoadPointer(&cachedDecoderMap)
- return *(*map[uintptr]Decoder)(unsafe.Pointer(&p))
-}
-
-func storeDecoder(typ uintptr, dec Decoder, m map[uintptr]Decoder) {
- initDecoder()
- newDecoderMap := make(map[uintptr]Decoder, len(m)+1)
- newDecoderMap[typ] = dec
-
- for k, v := range m {
- newDecoderMap[k] = v
- }
-
- atomic.StorePointer(&cachedDecoderMap, *(*unsafe.Pointer)(unsafe.Pointer(&newDecoderMap)))
-}
-
-func compileToGetDecoderSlowPath(typeptr uintptr, typ *runtime.Type) (Decoder, error) {
- decoderMap := loadDecoderMap()
- if dec, exists := decoderMap[typeptr]; exists {
- return dec, nil
- }
-
- dec, err := compileHead(typ, map[uintptr]Decoder{})
- if err != nil {
- return nil, err
- }
- storeDecoder(typeptr, dec, decoderMap)
- return dec, nil
-}
-
-func compileHead(typ *runtime.Type, structTypeToDecoder map[uintptr]Decoder) (Decoder, error) {
- switch {
- case implementsUnmarshalJSONType(runtime.PtrTo(typ)):
- return newUnmarshalJSONDecoder(runtime.PtrTo(typ), "", ""), nil
- case runtime.PtrTo(typ).Implements(unmarshalTextType):
- return newUnmarshalTextDecoder(runtime.PtrTo(typ), "", ""), nil
- }
- return compile(typ.Elem(), "", "", structTypeToDecoder)
-}
-
-func compile(typ *runtime.Type, structName, fieldName string, structTypeToDecoder map[uintptr]Decoder) (Decoder, error) {
- switch {
- case implementsUnmarshalJSONType(runtime.PtrTo(typ)):
- return newUnmarshalJSONDecoder(runtime.PtrTo(typ), structName, fieldName), nil
- case runtime.PtrTo(typ).Implements(unmarshalTextType):
- return newUnmarshalTextDecoder(runtime.PtrTo(typ), structName, fieldName), nil
- }
-
- switch typ.Kind() {
- case reflect.Ptr:
- return compilePtr(typ, structName, fieldName, structTypeToDecoder)
- case reflect.Struct:
- return compileStruct(typ, structName, fieldName, structTypeToDecoder)
- case reflect.Slice:
- elem := typ.Elem()
- if elem.Kind() == reflect.Uint8 {
- return compileBytes(elem, structName, fieldName)
- }
- return compileSlice(typ, structName, fieldName, structTypeToDecoder)
- case reflect.Array:
- return compileArray(typ, structName, fieldName, structTypeToDecoder)
- case reflect.Map:
- return compileMap(typ, structName, fieldName, structTypeToDecoder)
- case reflect.Interface:
- return compileInterface(typ, structName, fieldName)
- case reflect.Uintptr:
- return compileUint(typ, structName, fieldName)
- case reflect.Int:
- return compileInt(typ, structName, fieldName)
- case reflect.Int8:
- return compileInt8(typ, structName, fieldName)
- case reflect.Int16:
- return compileInt16(typ, structName, fieldName)
- case reflect.Int32:
- return compileInt32(typ, structName, fieldName)
- case reflect.Int64:
- return compileInt64(typ, structName, fieldName)
- case reflect.Uint:
- return compileUint(typ, structName, fieldName)
- case reflect.Uint8:
- return compileUint8(typ, structName, fieldName)
- case reflect.Uint16:
- return compileUint16(typ, structName, fieldName)
- case reflect.Uint32:
- return compileUint32(typ, structName, fieldName)
- case reflect.Uint64:
- return compileUint64(typ, structName, fieldName)
- case reflect.String:
- return compileString(typ, structName, fieldName)
- case reflect.Bool:
- return compileBool(structName, fieldName)
- case reflect.Float32:
- return compileFloat32(structName, fieldName)
- case reflect.Float64:
- return compileFloat64(structName, fieldName)
- case reflect.Func:
- return compileFunc(typ, structName, fieldName)
- }
- return newInvalidDecoder(typ, structName, fieldName), nil
-}
-
-func isStringTagSupportedType(typ *runtime.Type) bool {
- switch {
- case implementsUnmarshalJSONType(runtime.PtrTo(typ)):
- return false
- case runtime.PtrTo(typ).Implements(unmarshalTextType):
- return false
- }
- switch typ.Kind() {
- case reflect.Map:
- return false
- case reflect.Slice:
- return false
- case reflect.Array:
- return false
- case reflect.Struct:
- return false
- case reflect.Interface:
- return false
- }
- return true
-}
-
-func compileMapKey(typ *runtime.Type, structName, fieldName string, structTypeToDecoder map[uintptr]Decoder) (Decoder, error) {
- if runtime.PtrTo(typ).Implements(unmarshalTextType) {
- return newUnmarshalTextDecoder(runtime.PtrTo(typ), structName, fieldName), nil
- }
- if typ.Kind() == reflect.String {
- return newStringDecoder(structName, fieldName), nil
- }
- dec, err := compile(typ, structName, fieldName, structTypeToDecoder)
- if err != nil {
- return nil, err
- }
- for {
- switch t := dec.(type) {
- case *stringDecoder, *interfaceDecoder:
- return dec, nil
- case *boolDecoder, *intDecoder, *uintDecoder, *numberDecoder:
- return newWrappedStringDecoder(typ, dec, structName, fieldName), nil
- case *ptrDecoder:
- dec = t.dec
- default:
- return newInvalidDecoder(typ, structName, fieldName), nil
- }
- }
-}
-
-func compilePtr(typ *runtime.Type, structName, fieldName string, structTypeToDecoder map[uintptr]Decoder) (Decoder, error) {
- dec, err := compile(typ.Elem(), structName, fieldName, structTypeToDecoder)
- if err != nil {
- return nil, err
- }
- return newPtrDecoder(dec, typ.Elem(), structName, fieldName), nil
-}
-
-func compileInt(typ *runtime.Type, structName, fieldName string) (Decoder, error) {
- return newIntDecoder(typ, structName, fieldName, func(p unsafe.Pointer, v int64) {
- *(*int)(p) = int(v)
- }), nil
-}
-
-func compileInt8(typ *runtime.Type, structName, fieldName string) (Decoder, error) {
- return newIntDecoder(typ, structName, fieldName, func(p unsafe.Pointer, v int64) {
- *(*int8)(p) = int8(v)
- }), nil
-}
-
-func compileInt16(typ *runtime.Type, structName, fieldName string) (Decoder, error) {
- return newIntDecoder(typ, structName, fieldName, func(p unsafe.Pointer, v int64) {
- *(*int16)(p) = int16(v)
- }), nil
-}
-
-func compileInt32(typ *runtime.Type, structName, fieldName string) (Decoder, error) {
- return newIntDecoder(typ, structName, fieldName, func(p unsafe.Pointer, v int64) {
- *(*int32)(p) = int32(v)
- }), nil
-}
-
-func compileInt64(typ *runtime.Type, structName, fieldName string) (Decoder, error) {
- return newIntDecoder(typ, structName, fieldName, func(p unsafe.Pointer, v int64) {
- *(*int64)(p) = v
- }), nil
-}
-
-func compileUint(typ *runtime.Type, structName, fieldName string) (Decoder, error) {
- return newUintDecoder(typ, structName, fieldName, func(p unsafe.Pointer, v uint64) {
- *(*uint)(p) = uint(v)
- }), nil
-}
-
-func compileUint8(typ *runtime.Type, structName, fieldName string) (Decoder, error) {
- return newUintDecoder(typ, structName, fieldName, func(p unsafe.Pointer, v uint64) {
- *(*uint8)(p) = uint8(v)
- }), nil
-}
-
-func compileUint16(typ *runtime.Type, structName, fieldName string) (Decoder, error) {
- return newUintDecoder(typ, structName, fieldName, func(p unsafe.Pointer, v uint64) {
- *(*uint16)(p) = uint16(v)
- }), nil
-}
-
-func compileUint32(typ *runtime.Type, structName, fieldName string) (Decoder, error) {
- return newUintDecoder(typ, structName, fieldName, func(p unsafe.Pointer, v uint64) {
- *(*uint32)(p) = uint32(v)
- }), nil
-}
-
-func compileUint64(typ *runtime.Type, structName, fieldName string) (Decoder, error) {
- return newUintDecoder(typ, structName, fieldName, func(p unsafe.Pointer, v uint64) {
- *(*uint64)(p) = v
- }), nil
-}
-
-func compileFloat32(structName, fieldName string) (Decoder, error) {
- return newFloatDecoder(structName, fieldName, func(p unsafe.Pointer, v float64) {
- *(*float32)(p) = float32(v)
- }), nil
-}
-
-func compileFloat64(structName, fieldName string) (Decoder, error) {
- return newFloatDecoder(structName, fieldName, func(p unsafe.Pointer, v float64) {
- *(*float64)(p) = v
- }), nil
-}
-
-func compileString(typ *runtime.Type, structName, fieldName string) (Decoder, error) {
- if typ == runtime.Type2RType(jsonNumberType) {
- return newNumberDecoder(structName, fieldName, func(p unsafe.Pointer, v json.Number) {
- *(*json.Number)(p) = v
- }), nil
- }
- return newStringDecoder(structName, fieldName), nil
-}
-
-func compileBool(structName, fieldName string) (Decoder, error) {
- return newBoolDecoder(structName, fieldName), nil
-}
-
-func compileBytes(typ *runtime.Type, structName, fieldName string) (Decoder, error) {
- return newBytesDecoder(typ, structName, fieldName), nil
-}
-
-func compileSlice(typ *runtime.Type, structName, fieldName string, structTypeToDecoder map[uintptr]Decoder) (Decoder, error) {
- elem := typ.Elem()
- decoder, err := compile(elem, structName, fieldName, structTypeToDecoder)
- if err != nil {
- return nil, err
- }
- return newSliceDecoder(decoder, elem, elem.Size(), structName, fieldName), nil
-}
-
-func compileArray(typ *runtime.Type, structName, fieldName string, structTypeToDecoder map[uintptr]Decoder) (Decoder, error) {
- elem := typ.Elem()
- decoder, err := compile(elem, structName, fieldName, structTypeToDecoder)
- if err != nil {
- return nil, err
- }
- return newArrayDecoder(decoder, elem, typ.Len(), structName, fieldName), nil
-}
-
-func compileMap(typ *runtime.Type, structName, fieldName string, structTypeToDecoder map[uintptr]Decoder) (Decoder, error) {
- keyDec, err := compileMapKey(typ.Key(), structName, fieldName, structTypeToDecoder)
- if err != nil {
- return nil, err
- }
- valueDec, err := compile(typ.Elem(), structName, fieldName, structTypeToDecoder)
- if err != nil {
- return nil, err
- }
- return newMapDecoder(typ, typ.Key(), keyDec, typ.Elem(), valueDec, structName, fieldName), nil
-}
-
-func compileInterface(typ *runtime.Type, structName, fieldName string) (Decoder, error) {
- return newInterfaceDecoder(typ, structName, fieldName), nil
-}
-
-func compileFunc(typ *runtime.Type, strutName, fieldName string) (Decoder, error) {
- return newFuncDecoder(typ, strutName, fieldName), nil
-}
-
-func typeToStructTags(typ *runtime.Type) runtime.StructTags {
- tags := runtime.StructTags{}
- fieldNum := typ.NumField()
- for i := 0; i < fieldNum; i++ {
- field := typ.Field(i)
- if runtime.IsIgnoredStructField(field) {
- continue
- }
- tags = append(tags, runtime.StructTagFromField(field))
- }
- return tags
-}
-
-func compileStruct(typ *runtime.Type, structName, fieldName string, structTypeToDecoder map[uintptr]Decoder) (Decoder, error) {
- fieldNum := typ.NumField()
- fieldMap := map[string]*structFieldSet{}
- typeptr := uintptr(unsafe.Pointer(typ))
- if dec, exists := structTypeToDecoder[typeptr]; exists {
- return dec, nil
- }
- structDec := newStructDecoder(structName, fieldName, fieldMap)
- structTypeToDecoder[typeptr] = structDec
- structName = typ.Name()
- tags := typeToStructTags(typ)
- allFields := []*structFieldSet{}
- for i := 0; i < fieldNum; i++ {
- field := typ.Field(i)
- if runtime.IsIgnoredStructField(field) {
- continue
- }
- isUnexportedField := unicode.IsLower([]rune(field.Name)[0])
- tag := runtime.StructTagFromField(field)
- dec, err := compile(runtime.Type2RType(field.Type), structName, field.Name, structTypeToDecoder)
- if err != nil {
- return nil, err
- }
- if field.Anonymous && !tag.IsTaggedKey {
- if stDec, ok := dec.(*structDecoder); ok {
- if runtime.Type2RType(field.Type) == typ {
- // recursive definition
- continue
- }
- for k, v := range stDec.fieldMap {
- if tags.ExistsKey(k) {
- continue
- }
- fieldSet := &structFieldSet{
- dec: v.dec,
- offset: field.Offset + v.offset,
- isTaggedKey: v.isTaggedKey,
- key: k,
- keyLen: int64(len(k)),
- }
- allFields = append(allFields, fieldSet)
- }
- } else if pdec, ok := dec.(*ptrDecoder); ok {
- contentDec := pdec.contentDecoder()
- if pdec.typ == typ {
- // recursive definition
- continue
- }
- var fieldSetErr error
- if isUnexportedField {
- fieldSetErr = fmt.Errorf(
- "json: cannot set embedded pointer to unexported struct: %v",
- field.Type.Elem(),
- )
- }
- if dec, ok := contentDec.(*structDecoder); ok {
- for k, v := range dec.fieldMap {
- if tags.ExistsKey(k) {
- continue
- }
- fieldSet := &structFieldSet{
- dec: newAnonymousFieldDecoder(pdec.typ, v.offset, v.dec),
- offset: field.Offset,
- isTaggedKey: v.isTaggedKey,
- key: k,
- keyLen: int64(len(k)),
- err: fieldSetErr,
- }
- allFields = append(allFields, fieldSet)
- }
- } else {
- fieldSet := &structFieldSet{
- dec: pdec,
- offset: field.Offset,
- isTaggedKey: tag.IsTaggedKey,
- key: field.Name,
- keyLen: int64(len(field.Name)),
- }
- allFields = append(allFields, fieldSet)
- }
- } else {
- fieldSet := &structFieldSet{
- dec: dec,
- offset: field.Offset,
- isTaggedKey: tag.IsTaggedKey,
- key: field.Name,
- keyLen: int64(len(field.Name)),
- }
- allFields = append(allFields, fieldSet)
- }
- } else {
- if tag.IsString && isStringTagSupportedType(runtime.Type2RType(field.Type)) {
- dec = newWrappedStringDecoder(runtime.Type2RType(field.Type), dec, structName, field.Name)
- }
- var key string
- if tag.Key != "" {
- key = tag.Key
- } else {
- key = field.Name
- }
- fieldSet := &structFieldSet{
- dec: dec,
- offset: field.Offset,
- isTaggedKey: tag.IsTaggedKey,
- key: key,
- keyLen: int64(len(key)),
- }
- allFields = append(allFields, fieldSet)
- }
- }
- for _, set := range filterDuplicatedFields(allFields) {
- fieldMap[set.key] = set
- lower := strings.ToLower(set.key)
- if _, exists := fieldMap[lower]; !exists {
- // first win
- fieldMap[lower] = set
- }
- }
- delete(structTypeToDecoder, typeptr)
- structDec.tryOptimize()
- return structDec, nil
-}
-
-func filterDuplicatedFields(allFields []*structFieldSet) []*structFieldSet {
- fieldMap := map[string][]*structFieldSet{}
- for _, field := range allFields {
- fieldMap[field.key] = append(fieldMap[field.key], field)
- }
- duplicatedFieldMap := map[string]struct{}{}
- for k, sets := range fieldMap {
- sets = filterFieldSets(sets)
- if len(sets) != 1 {
- duplicatedFieldMap[k] = struct{}{}
- }
- }
-
- filtered := make([]*structFieldSet, 0, len(allFields))
- for _, field := range allFields {
- if _, exists := duplicatedFieldMap[field.key]; exists {
- continue
- }
- filtered = append(filtered, field)
- }
- return filtered
-}
-
-func filterFieldSets(sets []*structFieldSet) []*structFieldSet {
- if len(sets) == 1 {
- return sets
- }
- filtered := make([]*structFieldSet, 0, len(sets))
- for _, set := range sets {
- if set.isTaggedKey {
- filtered = append(filtered, set)
- }
- }
- return filtered
-}
-
-func implementsUnmarshalJSONType(typ *runtime.Type) bool {
- return typ.Implements(unmarshalJSONType) || typ.Implements(unmarshalJSONContextType)
-}
diff --git a/vendor/github.com/goccy/go-json/internal/decoder/compile_norace.go b/vendor/github.com/goccy/go-json/internal/decoder/compile_norace.go
deleted file mode 100644
index 025ca85b..00000000
--- a/vendor/github.com/goccy/go-json/internal/decoder/compile_norace.go
+++ /dev/null
@@ -1,30 +0,0 @@
-//go:build !race
-// +build !race
-
-package decoder
-
-import (
- "unsafe"
-
- "github.com/goccy/go-json/internal/runtime"
-)
-
-func CompileToGetDecoder(typ *runtime.Type) (Decoder, error) {
- initDecoder()
- typeptr := uintptr(unsafe.Pointer(typ))
- if typeptr > typeAddr.MaxTypeAddr {
- return compileToGetDecoderSlowPath(typeptr, typ)
- }
-
- index := (typeptr - typeAddr.BaseTypeAddr) >> typeAddr.AddrShift
- if dec := cachedDecoder[index]; dec != nil {
- return dec, nil
- }
-
- dec, err := compileHead(typ, map[uintptr]Decoder{})
- if err != nil {
- return nil, err
- }
- cachedDecoder[index] = dec
- return dec, nil
-}
diff --git a/vendor/github.com/goccy/go-json/internal/decoder/compile_race.go b/vendor/github.com/goccy/go-json/internal/decoder/compile_race.go
deleted file mode 100644
index 023b817c..00000000
--- a/vendor/github.com/goccy/go-json/internal/decoder/compile_race.go
+++ /dev/null
@@ -1,38 +0,0 @@
-//go:build race
-// +build race
-
-package decoder
-
-import (
- "sync"
- "unsafe"
-
- "github.com/goccy/go-json/internal/runtime"
-)
-
-var decMu sync.RWMutex
-
-func CompileToGetDecoder(typ *runtime.Type) (Decoder, error) {
- initDecoder()
- typeptr := uintptr(unsafe.Pointer(typ))
- if typeptr > typeAddr.MaxTypeAddr {
- return compileToGetDecoderSlowPath(typeptr, typ)
- }
-
- index := (typeptr - typeAddr.BaseTypeAddr) >> typeAddr.AddrShift
- decMu.RLock()
- if dec := cachedDecoder[index]; dec != nil {
- decMu.RUnlock()
- return dec, nil
- }
- decMu.RUnlock()
-
- dec, err := compileHead(typ, map[uintptr]Decoder{})
- if err != nil {
- return nil, err
- }
- decMu.Lock()
- cachedDecoder[index] = dec
- decMu.Unlock()
- return dec, nil
-}
diff --git a/vendor/github.com/goccy/go-json/internal/decoder/context.go b/vendor/github.com/goccy/go-json/internal/decoder/context.go
deleted file mode 100644
index cb2ffdaf..00000000
--- a/vendor/github.com/goccy/go-json/internal/decoder/context.go
+++ /dev/null
@@ -1,254 +0,0 @@
-package decoder
-
-import (
- "sync"
- "unsafe"
-
- "github.com/goccy/go-json/internal/errors"
-)
-
-type RuntimeContext struct {
- Buf []byte
- Option *Option
-}
-
-var (
- runtimeContextPool = sync.Pool{
- New: func() interface{} {
- return &RuntimeContext{
- Option: &Option{},
- }
- },
- }
-)
-
-func TakeRuntimeContext() *RuntimeContext {
- return runtimeContextPool.Get().(*RuntimeContext)
-}
-
-func ReleaseRuntimeContext(ctx *RuntimeContext) {
- runtimeContextPool.Put(ctx)
-}
-
-var (
- isWhiteSpace = [256]bool{}
-)
-
-func init() {
- isWhiteSpace[' '] = true
- isWhiteSpace['\n'] = true
- isWhiteSpace['\t'] = true
- isWhiteSpace['\r'] = true
-}
-
-func char(ptr unsafe.Pointer, offset int64) byte {
- return *(*byte)(unsafe.Pointer(uintptr(ptr) + uintptr(offset)))
-}
-
-func skipWhiteSpace(buf []byte, cursor int64) int64 {
- for isWhiteSpace[buf[cursor]] {
- cursor++
- }
- return cursor
-}
-
-func skipObject(buf []byte, cursor, depth int64) (int64, error) {
- braceCount := 1
- for {
- switch buf[cursor] {
- case '{':
- braceCount++
- depth++
- if depth > maxDecodeNestingDepth {
- return 0, errors.ErrExceededMaxDepth(buf[cursor], cursor)
- }
- case '}':
- depth--
- braceCount--
- if braceCount == 0 {
- return cursor + 1, nil
- }
- case '[':
- depth++
- if depth > maxDecodeNestingDepth {
- return 0, errors.ErrExceededMaxDepth(buf[cursor], cursor)
- }
- case ']':
- depth--
- case '"':
- for {
- cursor++
- switch buf[cursor] {
- case '\\':
- cursor++
- if buf[cursor] == nul {
- return 0, errors.ErrUnexpectedEndOfJSON("string of object", cursor)
- }
- case '"':
- goto SWITCH_OUT
- case nul:
- return 0, errors.ErrUnexpectedEndOfJSON("string of object", cursor)
- }
- }
- case nul:
- return 0, errors.ErrUnexpectedEndOfJSON("object of object", cursor)
- }
- SWITCH_OUT:
- cursor++
- }
-}
-
-func skipArray(buf []byte, cursor, depth int64) (int64, error) {
- bracketCount := 1
- for {
- switch buf[cursor] {
- case '[':
- bracketCount++
- depth++
- if depth > maxDecodeNestingDepth {
- return 0, errors.ErrExceededMaxDepth(buf[cursor], cursor)
- }
- case ']':
- bracketCount--
- depth--
- if bracketCount == 0 {
- return cursor + 1, nil
- }
- case '{':
- depth++
- if depth > maxDecodeNestingDepth {
- return 0, errors.ErrExceededMaxDepth(buf[cursor], cursor)
- }
- case '}':
- depth--
- case '"':
- for {
- cursor++
- switch buf[cursor] {
- case '\\':
- cursor++
- if buf[cursor] == nul {
- return 0, errors.ErrUnexpectedEndOfJSON("string of object", cursor)
- }
- case '"':
- goto SWITCH_OUT
- case nul:
- return 0, errors.ErrUnexpectedEndOfJSON("string of object", cursor)
- }
- }
- case nul:
- return 0, errors.ErrUnexpectedEndOfJSON("array of object", cursor)
- }
- SWITCH_OUT:
- cursor++
- }
-}
-
-func skipValue(buf []byte, cursor, depth int64) (int64, error) {
- for {
- switch buf[cursor] {
- case ' ', '\t', '\n', '\r':
- cursor++
- continue
- case '{':
- return skipObject(buf, cursor+1, depth+1)
- case '[':
- return skipArray(buf, cursor+1, depth+1)
- case '"':
- for {
- cursor++
- switch buf[cursor] {
- case '\\':
- cursor++
- if buf[cursor] == nul {
- return 0, errors.ErrUnexpectedEndOfJSON("string of object", cursor)
- }
- case '"':
- return cursor + 1, nil
- case nul:
- return 0, errors.ErrUnexpectedEndOfJSON("string of object", cursor)
- }
- }
- case '-', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
- for {
- cursor++
- if floatTable[buf[cursor]] {
- continue
- }
- break
- }
- return cursor, nil
- case 't':
- if err := validateTrue(buf, cursor); err != nil {
- return 0, err
- }
- cursor += 4
- return cursor, nil
- case 'f':
- if err := validateFalse(buf, cursor); err != nil {
- return 0, err
- }
- cursor += 5
- return cursor, nil
- case 'n':
- if err := validateNull(buf, cursor); err != nil {
- return 0, err
- }
- cursor += 4
- return cursor, nil
- default:
- return cursor, errors.ErrUnexpectedEndOfJSON("null", cursor)
- }
- }
-}
-
-func validateTrue(buf []byte, cursor int64) error {
- if cursor+3 >= int64(len(buf)) {
- return errors.ErrUnexpectedEndOfJSON("true", cursor)
- }
- if buf[cursor+1] != 'r' {
- return errors.ErrInvalidCharacter(buf[cursor+1], "true", cursor)
- }
- if buf[cursor+2] != 'u' {
- return errors.ErrInvalidCharacter(buf[cursor+2], "true", cursor)
- }
- if buf[cursor+3] != 'e' {
- return errors.ErrInvalidCharacter(buf[cursor+3], "true", cursor)
- }
- return nil
-}
-
-func validateFalse(buf []byte, cursor int64) error {
- if cursor+4 >= int64(len(buf)) {
- return errors.ErrUnexpectedEndOfJSON("false", cursor)
- }
- if buf[cursor+1] != 'a' {
- return errors.ErrInvalidCharacter(buf[cursor+1], "false", cursor)
- }
- if buf[cursor+2] != 'l' {
- return errors.ErrInvalidCharacter(buf[cursor+2], "false", cursor)
- }
- if buf[cursor+3] != 's' {
- return errors.ErrInvalidCharacter(buf[cursor+3], "false", cursor)
- }
- if buf[cursor+4] != 'e' {
- return errors.ErrInvalidCharacter(buf[cursor+4], "false", cursor)
- }
- return nil
-}
-
-func validateNull(buf []byte, cursor int64) error {
- if cursor+3 >= int64(len(buf)) {
- return errors.ErrUnexpectedEndOfJSON("null", cursor)
- }
- if buf[cursor+1] != 'u' {
- return errors.ErrInvalidCharacter(buf[cursor+1], "null", cursor)
- }
- if buf[cursor+2] != 'l' {
- return errors.ErrInvalidCharacter(buf[cursor+2], "null", cursor)
- }
- if buf[cursor+3] != 'l' {
- return errors.ErrInvalidCharacter(buf[cursor+3], "null", cursor)
- }
- return nil
-}
diff --git a/vendor/github.com/goccy/go-json/internal/decoder/float.go b/vendor/github.com/goccy/go-json/internal/decoder/float.go
deleted file mode 100644
index 9b2eb8b3..00000000
--- a/vendor/github.com/goccy/go-json/internal/decoder/float.go
+++ /dev/null
@@ -1,170 +0,0 @@
-package decoder
-
-import (
- "strconv"
- "unsafe"
-
- "github.com/goccy/go-json/internal/errors"
-)
-
-type floatDecoder struct {
- op func(unsafe.Pointer, float64)
- structName string
- fieldName string
-}
-
-func newFloatDecoder(structName, fieldName string, op func(unsafe.Pointer, float64)) *floatDecoder {
- return &floatDecoder{op: op, structName: structName, fieldName: fieldName}
-}
-
-var (
- floatTable = [256]bool{
- '0': true,
- '1': true,
- '2': true,
- '3': true,
- '4': true,
- '5': true,
- '6': true,
- '7': true,
- '8': true,
- '9': true,
- '.': true,
- 'e': true,
- 'E': true,
- '+': true,
- '-': true,
- }
-
- validEndNumberChar = [256]bool{
- nul: true,
- ' ': true,
- '\t': true,
- '\r': true,
- '\n': true,
- ',': true,
- ':': true,
- '}': true,
- ']': true,
- }
-)
-
-func floatBytes(s *Stream) []byte {
- start := s.cursor
- for {
- s.cursor++
- if floatTable[s.char()] {
- continue
- } else if s.char() == nul {
- if s.read() {
- s.cursor-- // for retry current character
- continue
- }
- }
- break
- }
- return s.buf[start:s.cursor]
-}
-
-func (d *floatDecoder) decodeStreamByte(s *Stream) ([]byte, error) {
- for {
- switch s.char() {
- case ' ', '\n', '\t', '\r':
- s.cursor++
- continue
- case '-', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
- return floatBytes(s), nil
- case 'n':
- if err := nullBytes(s); err != nil {
- return nil, err
- }
- return nil, nil
- case nul:
- if s.read() {
- continue
- }
- goto ERROR
- default:
- goto ERROR
- }
- }
-ERROR:
- return nil, errors.ErrUnexpectedEndOfJSON("float", s.totalOffset())
-}
-
-func (d *floatDecoder) decodeByte(buf []byte, cursor int64) ([]byte, int64, error) {
- for {
- switch buf[cursor] {
- case ' ', '\n', '\t', '\r':
- cursor++
- continue
- case '-', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
- start := cursor
- cursor++
- for floatTable[buf[cursor]] {
- cursor++
- }
- num := buf[start:cursor]
- return num, cursor, nil
- case 'n':
- if err := validateNull(buf, cursor); err != nil {
- return nil, 0, err
- }
- cursor += 4
- return nil, cursor, nil
- default:
- return nil, 0, errors.ErrUnexpectedEndOfJSON("float", cursor)
- }
- }
-}
-
-func (d *floatDecoder) DecodeStream(s *Stream, depth int64, p unsafe.Pointer) error {
- bytes, err := d.decodeStreamByte(s)
- if err != nil {
- return err
- }
- if bytes == nil {
- return nil
- }
- str := *(*string)(unsafe.Pointer(&bytes))
- f64, err := strconv.ParseFloat(str, 64)
- if err != nil {
- return errors.ErrSyntax(err.Error(), s.totalOffset())
- }
- d.op(p, f64)
- return nil
-}
-
-func (d *floatDecoder) Decode(ctx *RuntimeContext, cursor, depth int64, p unsafe.Pointer) (int64, error) {
- buf := ctx.Buf
- bytes, c, err := d.decodeByte(buf, cursor)
- if err != nil {
- return 0, err
- }
- if bytes == nil {
- return c, nil
- }
- cursor = c
- if !validEndNumberChar[buf[cursor]] {
- return 0, errors.ErrUnexpectedEndOfJSON("float", cursor)
- }
- s := *(*string)(unsafe.Pointer(&bytes))
- f64, err := strconv.ParseFloat(s, 64)
- if err != nil {
- return 0, errors.ErrSyntax(err.Error(), cursor)
- }
- d.op(p, f64)
- return cursor, nil
-}
-
-func (d *floatDecoder) DecodePath(ctx *RuntimeContext, cursor, depth int64) ([][]byte, int64, error) {
- buf := ctx.Buf
- bytes, c, err := d.decodeByte(buf, cursor)
- if err != nil {
- return nil, 0, err
- }
- if bytes == nil {
- return [][]byte{nullbytes}, c, nil
- }
- return [][]byte{bytes}, c, nil
-}
diff --git a/vendor/github.com/goccy/go-json/internal/decoder/func.go b/vendor/github.com/goccy/go-json/internal/decoder/func.go
deleted file mode 100644
index 4cc12ca8..00000000
--- a/vendor/github.com/goccy/go-json/internal/decoder/func.go
+++ /dev/null
@@ -1,146 +0,0 @@
-package decoder
-
-import (
- "bytes"
- "fmt"
- "unsafe"
-
- "github.com/goccy/go-json/internal/errors"
- "github.com/goccy/go-json/internal/runtime"
-)
-
-type funcDecoder struct {
- typ *runtime.Type
- structName string
- fieldName string
-}
-
-func newFuncDecoder(typ *runtime.Type, structName, fieldName string) *funcDecoder {
- fnDecoder := &funcDecoder{typ, structName, fieldName}
- return fnDecoder
-}
-
-func (d *funcDecoder) DecodeStream(s *Stream, depth int64, p unsafe.Pointer) error {
- s.skipWhiteSpace()
- start := s.cursor
- if err := s.skipValue(depth); err != nil {
- return err
- }
- src := s.buf[start:s.cursor]
- if len(src) > 0 {
- switch src[0] {
- case '"':
- return &errors.UnmarshalTypeError{
- Value: "string",
- Type: runtime.RType2Type(d.typ),
- Offset: s.totalOffset(),
- }
- case '[':
- return &errors.UnmarshalTypeError{
- Value: "array",
- Type: runtime.RType2Type(d.typ),
- Offset: s.totalOffset(),
- }
- case '{':
- return &errors.UnmarshalTypeError{
- Value: "object",
- Type: runtime.RType2Type(d.typ),
- Offset: s.totalOffset(),
- }
- case '-', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
- return &errors.UnmarshalTypeError{
- Value: "number",
- Type: runtime.RType2Type(d.typ),
- Offset: s.totalOffset(),
- }
- case 'n':
- if err := nullBytes(s); err != nil {
- return err
- }
- *(*unsafe.Pointer)(p) = nil
- return nil
- case 't':
- if err := trueBytes(s); err == nil {
- return &errors.UnmarshalTypeError{
- Value: "boolean",
- Type: runtime.RType2Type(d.typ),
- Offset: s.totalOffset(),
- }
- }
- case 'f':
- if err := falseBytes(s); err == nil {
- return &errors.UnmarshalTypeError{
- Value: "boolean",
- Type: runtime.RType2Type(d.typ),
- Offset: s.totalOffset(),
- }
- }
- }
- }
- return errors.ErrInvalidBeginningOfValue(s.buf[s.cursor], s.totalOffset())
-}
-
-func (d *funcDecoder) Decode(ctx *RuntimeContext, cursor, depth int64, p unsafe.Pointer) (int64, error) {
- buf := ctx.Buf
- cursor = skipWhiteSpace(buf, cursor)
- start := cursor
- end, err := skipValue(buf, cursor, depth)
- if err != nil {
- return 0, err
- }
- src := buf[start:end]
- if len(src) > 0 {
- switch src[0] {
- case '"':
- return 0, &errors.UnmarshalTypeError{
- Value: "string",
- Type: runtime.RType2Type(d.typ),
- Offset: start,
- }
- case '[':
- return 0, &errors.UnmarshalTypeError{
- Value: "array",
- Type: runtime.RType2Type(d.typ),
- Offset: start,
- }
- case '{':
- return 0, &errors.UnmarshalTypeError{
- Value: "object",
- Type: runtime.RType2Type(d.typ),
- Offset: start,
- }
- case '-', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
- return 0, &errors.UnmarshalTypeError{
- Value: "number",
- Type: runtime.RType2Type(d.typ),
- Offset: start,
- }
- case 'n':
- if bytes.Equal(src, nullbytes) {
- *(*unsafe.Pointer)(p) = nil
- return end, nil
- }
- case 't':
- if err := validateTrue(buf, start); err == nil {
- return 0, &errors.UnmarshalTypeError{
- Value: "boolean",
- Type: runtime.RType2Type(d.typ),
- Offset: start,
- }
- }
- case 'f':
- if err := validateFalse(buf, start); err == nil {
- return 0, &errors.UnmarshalTypeError{
- Value: "boolean",
- Type: runtime.RType2Type(d.typ),
- Offset: start,
- }
- }
- }
- }
- return cursor, errors.ErrInvalidBeginningOfValue(buf[cursor], cursor)
-}
-
-func (d *funcDecoder) DecodePath(ctx *RuntimeContext, cursor, depth int64) ([][]byte, int64, error) {
- return nil, 0, fmt.Errorf("json: func decoder does not support decode path")
-}
diff --git a/vendor/github.com/goccy/go-json/internal/decoder/int.go b/vendor/github.com/goccy/go-json/internal/decoder/int.go
deleted file mode 100644
index 1a7f0819..00000000
--- a/vendor/github.com/goccy/go-json/internal/decoder/int.go
+++ /dev/null
@@ -1,246 +0,0 @@
-package decoder
-
-import (
- "fmt"
- "reflect"
- "unsafe"
-
- "github.com/goccy/go-json/internal/errors"
- "github.com/goccy/go-json/internal/runtime"
-)
-
-type intDecoder struct {
- typ *runtime.Type
- kind reflect.Kind
- op func(unsafe.Pointer, int64)
- structName string
- fieldName string
-}
-
-func newIntDecoder(typ *runtime.Type, structName, fieldName string, op func(unsafe.Pointer, int64)) *intDecoder {
- return &intDecoder{
- typ: typ,
- kind: typ.Kind(),
- op: op,
- structName: structName,
- fieldName: fieldName,
- }
-}
-
-func (d *intDecoder) typeError(buf []byte, offset int64) *errors.UnmarshalTypeError {
- return &errors.UnmarshalTypeError{
- Value: fmt.Sprintf("number %s", string(buf)),
- Type: runtime.RType2Type(d.typ),
- Struct: d.structName,
- Field: d.fieldName,
- Offset: offset,
- }
-}
-
-var (
- pow10i64 = [...]int64{
- 1e00, 1e01, 1e02, 1e03, 1e04, 1e05, 1e06, 1e07, 1e08, 1e09,
- 1e10, 1e11, 1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18,
- }
- pow10i64Len = len(pow10i64)
-)
-
-func (d *intDecoder) parseInt(b []byte) (int64, error) {
- isNegative := false
- if b[0] == '-' {
- b = b[1:]
- isNegative = true
- }
- maxDigit := len(b)
- if maxDigit > pow10i64Len {
- return 0, fmt.Errorf("invalid length of number")
- }
- sum := int64(0)
- for i := 0; i < maxDigit; i++ {
- c := int64(b[i]) - 48
- digitValue := pow10i64[maxDigit-i-1]
- sum += c * digitValue
- }
- if isNegative {
- return -1 * sum, nil
- }
- return sum, nil
-}
-
-var (
- numTable = [256]bool{
- '0': true,
- '1': true,
- '2': true,
- '3': true,
- '4': true,
- '5': true,
- '6': true,
- '7': true,
- '8': true,
- '9': true,
- }
-)
-
-var (
- numZeroBuf = []byte{'0'}
-)
-
-func (d *intDecoder) decodeStreamByte(s *Stream) ([]byte, error) {
- for {
- switch s.char() {
- case ' ', '\n', '\t', '\r':
- s.cursor++
- continue
- case '-':
- start := s.cursor
- for {
- s.cursor++
- if numTable[s.char()] {
- continue
- } else if s.char() == nul {
- if s.read() {
- s.cursor-- // for retry current character
- continue
- }
- }
- break
- }
- num := s.buf[start:s.cursor]
- if len(num) < 2 {
- goto ERROR
- }
- return num, nil
- case '0':
- s.cursor++
- return numZeroBuf, nil
- case '1', '2', '3', '4', '5', '6', '7', '8', '9':
- start := s.cursor
- for {
- s.cursor++
- if numTable[s.char()] {
- continue
- } else if s.char() == nul {
- if s.read() {
- s.cursor-- // for retry current character
- continue
- }
- }
- break
- }
- num := s.buf[start:s.cursor]
- return num, nil
- case 'n':
- if err := nullBytes(s); err != nil {
- return nil, err
- }
- return nil, nil
- case nul:
- if s.read() {
- continue
- }
- goto ERROR
- default:
- return nil, d.typeError([]byte{s.char()}, s.totalOffset())
- }
- }
-ERROR:
- return nil, errors.ErrUnexpectedEndOfJSON("number(integer)", s.totalOffset())
-}
-
-func (d *intDecoder) decodeByte(buf []byte, cursor int64) ([]byte, int64, error) {
- b := (*sliceHeader)(unsafe.Pointer(&buf)).data
- for {
- switch char(b, cursor) {
- case ' ', '\n', '\t', '\r':
- cursor++
- continue
- case '0':
- cursor++
- return numZeroBuf, cursor, nil
- case '-', '1', '2', '3', '4', '5', '6', '7', '8', '9':
- start := cursor
- cursor++
- for numTable[char(b, cursor)] {
- cursor++
- }
- num := buf[start:cursor]
- return num, cursor, nil
- case 'n':
- if err := validateNull(buf, cursor); err != nil {
- return nil, 0, err
- }
- cursor += 4
- return nil, cursor, nil
- default:
- return nil, 0, d.typeError([]byte{char(b, cursor)}, cursor)
- }
- }
-}
-
-func (d *intDecoder) DecodeStream(s *Stream, depth int64, p unsafe.Pointer) error {
- bytes, err := d.decodeStreamByte(s)
- if err != nil {
- return err
- }
- if bytes == nil {
- return nil
- }
- i64, err := d.parseInt(bytes)
- if err != nil {
- return d.typeError(bytes, s.totalOffset())
- }
- switch d.kind {
- case reflect.Int8:
- if i64 < -1*(1<<7) || (1<<7) <= i64 {
- return d.typeError(bytes, s.totalOffset())
- }
- case reflect.Int16:
- if i64 < -1*(1<<15) || (1<<15) <= i64 {
- return d.typeError(bytes, s.totalOffset())
- }
- case reflect.Int32:
- if i64 < -1*(1<<31) || (1<<31) <= i64 {
- return d.typeError(bytes, s.totalOffset())
- }
- }
- d.op(p, i64)
- s.reset()
- return nil
-}
-
-func (d *intDecoder) Decode(ctx *RuntimeContext, cursor, depth int64, p unsafe.Pointer) (int64, error) {
- bytes, c, err := d.decodeByte(ctx.Buf, cursor)
- if err != nil {
- return 0, err
- }
- if bytes == nil {
- return c, nil
- }
- cursor = c
-
- i64, err := d.parseInt(bytes)
- if err != nil {
- return 0, d.typeError(bytes, cursor)
- }
- switch d.kind {
- case reflect.Int8:
- if i64 < -1*(1<<7) || (1<<7) <= i64 {
- return 0, d.typeError(bytes, cursor)
- }
- case reflect.Int16:
- if i64 < -1*(1<<15) || (1<<15) <= i64 {
- return 0, d.typeError(bytes, cursor)
- }
- case reflect.Int32:
- if i64 < -1*(1<<31) || (1<<31) <= i64 {
- return 0, d.typeError(bytes, cursor)
- }
- }
- d.op(p, i64)
- return cursor, nil
-}
-
-func (d *intDecoder) DecodePath(ctx *RuntimeContext, cursor, depth int64) ([][]byte, int64, error) {
- return nil, 0, fmt.Errorf("json: int decoder does not support decode path")
-}
diff --git a/vendor/github.com/goccy/go-json/internal/decoder/interface.go b/vendor/github.com/goccy/go-json/internal/decoder/interface.go
deleted file mode 100644
index 45c69ab8..00000000
--- a/vendor/github.com/goccy/go-json/internal/decoder/interface.go
+++ /dev/null
@@ -1,528 +0,0 @@
-package decoder
-
-import (
- "bytes"
- "encoding"
- "encoding/json"
- "reflect"
- "unsafe"
-
- "github.com/goccy/go-json/internal/errors"
- "github.com/goccy/go-json/internal/runtime"
-)
-
-type interfaceDecoder struct {
- typ *runtime.Type
- structName string
- fieldName string
- sliceDecoder *sliceDecoder
- mapDecoder *mapDecoder
- floatDecoder *floatDecoder
- numberDecoder *numberDecoder
- stringDecoder *stringDecoder
-}
-
-func newEmptyInterfaceDecoder(structName, fieldName string) *interfaceDecoder {
- ifaceDecoder := &interfaceDecoder{
- typ: emptyInterfaceType,
- structName: structName,
- fieldName: fieldName,
- floatDecoder: newFloatDecoder(structName, fieldName, func(p unsafe.Pointer, v float64) {
- *(*interface{})(p) = v
- }),
- numberDecoder: newNumberDecoder(structName, fieldName, func(p unsafe.Pointer, v json.Number) {
- *(*interface{})(p) = v
- }),
- stringDecoder: newStringDecoder(structName, fieldName),
- }
- ifaceDecoder.sliceDecoder = newSliceDecoder(
- ifaceDecoder,
- emptyInterfaceType,
- emptyInterfaceType.Size(),
- structName, fieldName,
- )
- ifaceDecoder.mapDecoder = newMapDecoder(
- interfaceMapType,
- stringType,
- ifaceDecoder.stringDecoder,
- interfaceMapType.Elem(),
- ifaceDecoder,
- structName,
- fieldName,
- )
- return ifaceDecoder
-}
-
-func newInterfaceDecoder(typ *runtime.Type, structName, fieldName string) *interfaceDecoder {
- emptyIfaceDecoder := newEmptyInterfaceDecoder(structName, fieldName)
- stringDecoder := newStringDecoder(structName, fieldName)
- return &interfaceDecoder{
- typ: typ,
- structName: structName,
- fieldName: fieldName,
- sliceDecoder: newSliceDecoder(
- emptyIfaceDecoder,
- emptyInterfaceType,
- emptyInterfaceType.Size(),
- structName, fieldName,
- ),
- mapDecoder: newMapDecoder(
- interfaceMapType,
- stringType,
- stringDecoder,
- interfaceMapType.Elem(),
- emptyIfaceDecoder,
- structName,
- fieldName,
- ),
- floatDecoder: newFloatDecoder(structName, fieldName, func(p unsafe.Pointer, v float64) {
- *(*interface{})(p) = v
- }),
- numberDecoder: newNumberDecoder(structName, fieldName, func(p unsafe.Pointer, v json.Number) {
- *(*interface{})(p) = v
- }),
- stringDecoder: stringDecoder,
- }
-}
-
-func (d *interfaceDecoder) numDecoder(s *Stream) Decoder {
- if s.UseNumber {
- return d.numberDecoder
- }
- return d.floatDecoder
-}
-
-var (
- emptyInterfaceType = runtime.Type2RType(reflect.TypeOf((*interface{})(nil)).Elem())
- EmptyInterfaceType = emptyInterfaceType
- interfaceMapType = runtime.Type2RType(
- reflect.TypeOf((*map[string]interface{})(nil)).Elem(),
- )
- stringType = runtime.Type2RType(
- reflect.TypeOf(""),
- )
-)
-
-func decodeStreamUnmarshaler(s *Stream, depth int64, unmarshaler json.Unmarshaler) error {
- start := s.cursor
- if err := s.skipValue(depth); err != nil {
- return err
- }
- src := s.buf[start:s.cursor]
- dst := make([]byte, len(src))
- copy(dst, src)
-
- if err := unmarshaler.UnmarshalJSON(dst); err != nil {
- return err
- }
- return nil
-}
-
-func decodeStreamUnmarshalerContext(s *Stream, depth int64, unmarshaler unmarshalerContext) error {
- start := s.cursor
- if err := s.skipValue(depth); err != nil {
- return err
- }
- src := s.buf[start:s.cursor]
- dst := make([]byte, len(src))
- copy(dst, src)
-
- if err := unmarshaler.UnmarshalJSON(s.Option.Context, dst); err != nil {
- return err
- }
- return nil
-}
-
-func decodeUnmarshaler(buf []byte, cursor, depth int64, unmarshaler json.Unmarshaler) (int64, error) {
- cursor = skipWhiteSpace(buf, cursor)
- start := cursor
- end, err := skipValue(buf, cursor, depth)
- if err != nil {
- return 0, err
- }
- src := buf[start:end]
- dst := make([]byte, len(src))
- copy(dst, src)
-
- if err := unmarshaler.UnmarshalJSON(dst); err != nil {
- return 0, err
- }
- return end, nil
-}
-
-func decodeUnmarshalerContext(ctx *RuntimeContext, buf []byte, cursor, depth int64, unmarshaler unmarshalerContext) (int64, error) {
- cursor = skipWhiteSpace(buf, cursor)
- start := cursor
- end, err := skipValue(buf, cursor, depth)
- if err != nil {
- return 0, err
- }
- src := buf[start:end]
- dst := make([]byte, len(src))
- copy(dst, src)
-
- if err := unmarshaler.UnmarshalJSON(ctx.Option.Context, dst); err != nil {
- return 0, err
- }
- return end, nil
-}
-
-func decodeStreamTextUnmarshaler(s *Stream, depth int64, unmarshaler encoding.TextUnmarshaler, p unsafe.Pointer) error {
- start := s.cursor
- if err := s.skipValue(depth); err != nil {
- return err
- }
- src := s.buf[start:s.cursor]
- if bytes.Equal(src, nullbytes) {
- *(*unsafe.Pointer)(p) = nil
- return nil
- }
-
- dst := make([]byte, len(src))
- copy(dst, src)
-
- if err := unmarshaler.UnmarshalText(dst); err != nil {
- return err
- }
- return nil
-}
-
-func decodeTextUnmarshaler(buf []byte, cursor, depth int64, unmarshaler encoding.TextUnmarshaler, p unsafe.Pointer) (int64, error) {
- cursor = skipWhiteSpace(buf, cursor)
- start := cursor
- end, err := skipValue(buf, cursor, depth)
- if err != nil {
- return 0, err
- }
- src := buf[start:end]
- if bytes.Equal(src, nullbytes) {
- *(*unsafe.Pointer)(p) = nil
- return end, nil
- }
- if s, ok := unquoteBytes(src); ok {
- src = s
- }
- if err := unmarshaler.UnmarshalText(src); err != nil {
- return 0, err
- }
- return end, nil
-}
-
-func (d *interfaceDecoder) decodeStreamEmptyInterface(s *Stream, depth int64, p unsafe.Pointer) error {
- c := s.skipWhiteSpace()
- for {
- switch c {
- case '{':
- var v map[string]interface{}
- ptr := unsafe.Pointer(&v)
- if err := d.mapDecoder.DecodeStream(s, depth, ptr); err != nil {
- return err
- }
- *(*interface{})(p) = v
- return nil
- case '[':
- var v []interface{}
- ptr := unsafe.Pointer(&v)
- if err := d.sliceDecoder.DecodeStream(s, depth, ptr); err != nil {
- return err
- }
- *(*interface{})(p) = v
- return nil
- case '-', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
- return d.numDecoder(s).DecodeStream(s, depth, p)
- case '"':
- s.cursor++
- start := s.cursor
- for {
- switch s.char() {
- case '\\':
- if _, err := decodeEscapeString(s, nil); err != nil {
- return err
- }
- case '"':
- literal := s.buf[start:s.cursor]
- s.cursor++
- *(*interface{})(p) = string(literal)
- return nil
- case nul:
- if s.read() {
- continue
- }
- return errors.ErrUnexpectedEndOfJSON("string", s.totalOffset())
- }
- s.cursor++
- }
- case 't':
- if err := trueBytes(s); err != nil {
- return err
- }
- **(**interface{})(unsafe.Pointer(&p)) = true
- return nil
- case 'f':
- if err := falseBytes(s); err != nil {
- return err
- }
- **(**interface{})(unsafe.Pointer(&p)) = false
- return nil
- case 'n':
- if err := nullBytes(s); err != nil {
- return err
- }
- *(*interface{})(p) = nil
- return nil
- case nul:
- if s.read() {
- c = s.char()
- continue
- }
- }
- break
- }
- return errors.ErrInvalidBeginningOfValue(c, s.totalOffset())
-}
-
-type emptyInterface struct {
- typ *runtime.Type
- ptr unsafe.Pointer
-}
-
-func (d *interfaceDecoder) DecodeStream(s *Stream, depth int64, p unsafe.Pointer) error {
- runtimeInterfaceValue := *(*interface{})(unsafe.Pointer(&emptyInterface{
- typ: d.typ,
- ptr: p,
- }))
- rv := reflect.ValueOf(runtimeInterfaceValue)
- if rv.NumMethod() > 0 && rv.CanInterface() {
- if u, ok := rv.Interface().(unmarshalerContext); ok {
- return decodeStreamUnmarshalerContext(s, depth, u)
- }
- if u, ok := rv.Interface().(json.Unmarshaler); ok {
- return decodeStreamUnmarshaler(s, depth, u)
- }
- if u, ok := rv.Interface().(encoding.TextUnmarshaler); ok {
- return decodeStreamTextUnmarshaler(s, depth, u, p)
- }
- if s.skipWhiteSpace() == 'n' {
- if err := nullBytes(s); err != nil {
- return err
- }
- *(*interface{})(p) = nil
- return nil
- }
- return d.errUnmarshalType(rv.Type(), s.totalOffset())
- }
- iface := rv.Interface()
- ifaceHeader := (*emptyInterface)(unsafe.Pointer(&iface))
- typ := ifaceHeader.typ
- if ifaceHeader.ptr == nil || d.typ == typ || typ == nil {
- // concrete type is empty interface
- return d.decodeStreamEmptyInterface(s, depth, p)
- }
- if typ.Kind() == reflect.Ptr && typ.Elem() == d.typ || typ.Kind() != reflect.Ptr {
- return d.decodeStreamEmptyInterface(s, depth, p)
- }
- if s.skipWhiteSpace() == 'n' {
- if err := nullBytes(s); err != nil {
- return err
- }
- *(*interface{})(p) = nil
- return nil
- }
- decoder, err := CompileToGetDecoder(typ)
- if err != nil {
- return err
- }
- return decoder.DecodeStream(s, depth, ifaceHeader.ptr)
-}
-
-func (d *interfaceDecoder) errUnmarshalType(typ reflect.Type, offset int64) *errors.UnmarshalTypeError {
- return &errors.UnmarshalTypeError{
- Value: typ.String(),
- Type: typ,
- Offset: offset,
- Struct: d.structName,
- Field: d.fieldName,
- }
-}
-
-func (d *interfaceDecoder) Decode(ctx *RuntimeContext, cursor, depth int64, p unsafe.Pointer) (int64, error) {
- buf := ctx.Buf
- runtimeInterfaceValue := *(*interface{})(unsafe.Pointer(&emptyInterface{
- typ: d.typ,
- ptr: p,
- }))
- rv := reflect.ValueOf(runtimeInterfaceValue)
- if rv.NumMethod() > 0 && rv.CanInterface() {
- if u, ok := rv.Interface().(unmarshalerContext); ok {
- return decodeUnmarshalerContext(ctx, buf, cursor, depth, u)
- }
- if u, ok := rv.Interface().(json.Unmarshaler); ok {
- return decodeUnmarshaler(buf, cursor, depth, u)
- }
- if u, ok := rv.Interface().(encoding.TextUnmarshaler); ok {
- return decodeTextUnmarshaler(buf, cursor, depth, u, p)
- }
- cursor = skipWhiteSpace(buf, cursor)
- if buf[cursor] == 'n' {
- if err := validateNull(buf, cursor); err != nil {
- return 0, err
- }
- cursor += 4
- **(**interface{})(unsafe.Pointer(&p)) = nil
- return cursor, nil
- }
- return 0, d.errUnmarshalType(rv.Type(), cursor)
- }
-
- iface := rv.Interface()
- ifaceHeader := (*emptyInterface)(unsafe.Pointer(&iface))
- typ := ifaceHeader.typ
- if ifaceHeader.ptr == nil || d.typ == typ || typ == nil {
- // concrete type is empty interface
- return d.decodeEmptyInterface(ctx, cursor, depth, p)
- }
- if typ.Kind() == reflect.Ptr && typ.Elem() == d.typ || typ.Kind() != reflect.Ptr {
- return d.decodeEmptyInterface(ctx, cursor, depth, p)
- }
- cursor = skipWhiteSpace(buf, cursor)
- if buf[cursor] == 'n' {
- if err := validateNull(buf, cursor); err != nil {
- return 0, err
- }
- cursor += 4
- **(**interface{})(unsafe.Pointer(&p)) = nil
- return cursor, nil
- }
- decoder, err := CompileToGetDecoder(typ)
- if err != nil {
- return 0, err
- }
- return decoder.Decode(ctx, cursor, depth, ifaceHeader.ptr)
-}
-
-func (d *interfaceDecoder) decodeEmptyInterface(ctx *RuntimeContext, cursor, depth int64, p unsafe.Pointer) (int64, error) {
- buf := ctx.Buf
- cursor = skipWhiteSpace(buf, cursor)
- switch buf[cursor] {
- case '{':
- var v map[string]interface{}
- ptr := unsafe.Pointer(&v)
- cursor, err := d.mapDecoder.Decode(ctx, cursor, depth, ptr)
- if err != nil {
- return 0, err
- }
- **(**interface{})(unsafe.Pointer(&p)) = v
- return cursor, nil
- case '[':
- var v []interface{}
- ptr := unsafe.Pointer(&v)
- cursor, err := d.sliceDecoder.Decode(ctx, cursor, depth, ptr)
- if err != nil {
- return 0, err
- }
- **(**interface{})(unsafe.Pointer(&p)) = v
- return cursor, nil
- case '-', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
- return d.floatDecoder.Decode(ctx, cursor, depth, p)
- case '"':
- var v string
- ptr := unsafe.Pointer(&v)
- cursor, err := d.stringDecoder.Decode(ctx, cursor, depth, ptr)
- if err != nil {
- return 0, err
- }
- **(**interface{})(unsafe.Pointer(&p)) = v
- return cursor, nil
- case 't':
- if err := validateTrue(buf, cursor); err != nil {
- return 0, err
- }
- cursor += 4
- **(**interface{})(unsafe.Pointer(&p)) = true
- return cursor, nil
- case 'f':
- if err := validateFalse(buf, cursor); err != nil {
- return 0, err
- }
- cursor += 5
- **(**interface{})(unsafe.Pointer(&p)) = false
- return cursor, nil
- case 'n':
- if err := validateNull(buf, cursor); err != nil {
- return 0, err
- }
- cursor += 4
- **(**interface{})(unsafe.Pointer(&p)) = nil
- return cursor, nil
- }
- return cursor, errors.ErrInvalidBeginningOfValue(buf[cursor], cursor)
-}
-
-func NewPathDecoder() Decoder {
- ifaceDecoder := &interfaceDecoder{
- typ: emptyInterfaceType,
- structName: "",
- fieldName: "",
- floatDecoder: newFloatDecoder("", "", func(p unsafe.Pointer, v float64) {
- *(*interface{})(p) = v
- }),
- numberDecoder: newNumberDecoder("", "", func(p unsafe.Pointer, v json.Number) {
- *(*interface{})(p) = v
- }),
- stringDecoder: newStringDecoder("", ""),
- }
- ifaceDecoder.sliceDecoder = newSliceDecoder(
- ifaceDecoder,
- emptyInterfaceType,
- emptyInterfaceType.Size(),
- "", "",
- )
- ifaceDecoder.mapDecoder = newMapDecoder(
- interfaceMapType,
- stringType,
- ifaceDecoder.stringDecoder,
- interfaceMapType.Elem(),
- ifaceDecoder,
- "", "",
- )
- return ifaceDecoder
-}
-
-var (
- truebytes = []byte("true")
- falsebytes = []byte("false")
-)
-
-func (d *interfaceDecoder) DecodePath(ctx *RuntimeContext, cursor, depth int64) ([][]byte, int64, error) {
- buf := ctx.Buf
- cursor = skipWhiteSpace(buf, cursor)
- switch buf[cursor] {
- case '{':
- return d.mapDecoder.DecodePath(ctx, cursor, depth)
- case '[':
- return d.sliceDecoder.DecodePath(ctx, cursor, depth)
- case '-', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
- return d.floatDecoder.DecodePath(ctx, cursor, depth)
- case '"':
- return d.stringDecoder.DecodePath(ctx, cursor, depth)
- case 't':
- if err := validateTrue(buf, cursor); err != nil {
- return nil, 0, err
- }
- cursor += 4
- return [][]byte{truebytes}, cursor, nil
- case 'f':
- if err := validateFalse(buf, cursor); err != nil {
- return nil, 0, err
- }
- cursor += 5
- return [][]byte{falsebytes}, cursor, nil
- case 'n':
- if err := validateNull(buf, cursor); err != nil {
- return nil, 0, err
- }
- cursor += 4
- return [][]byte{nullbytes}, cursor, nil
- }
- return nil, cursor, errors.ErrInvalidBeginningOfValue(buf[cursor], cursor)
-}
diff --git a/vendor/github.com/goccy/go-json/internal/decoder/invalid.go b/vendor/github.com/goccy/go-json/internal/decoder/invalid.go
deleted file mode 100644
index 4c9721b0..00000000
--- a/vendor/github.com/goccy/go-json/internal/decoder/invalid.go
+++ /dev/null
@@ -1,55 +0,0 @@
-package decoder
-
-import (
- "reflect"
- "unsafe"
-
- "github.com/goccy/go-json/internal/errors"
- "github.com/goccy/go-json/internal/runtime"
-)
-
-type invalidDecoder struct {
- typ *runtime.Type
- kind reflect.Kind
- structName string
- fieldName string
-}
-
-func newInvalidDecoder(typ *runtime.Type, structName, fieldName string) *invalidDecoder {
- return &invalidDecoder{
- typ: typ,
- kind: typ.Kind(),
- structName: structName,
- fieldName: fieldName,
- }
-}
-
-func (d *invalidDecoder) DecodeStream(s *Stream, depth int64, p unsafe.Pointer) error {
- return &errors.UnmarshalTypeError{
- Value: "object",
- Type: runtime.RType2Type(d.typ),
- Offset: s.totalOffset(),
- Struct: d.structName,
- Field: d.fieldName,
- }
-}
-
-func (d *invalidDecoder) Decode(ctx *RuntimeContext, cursor, depth int64, p unsafe.Pointer) (int64, error) {
- return 0, &errors.UnmarshalTypeError{
- Value: "object",
- Type: runtime.RType2Type(d.typ),
- Offset: cursor,
- Struct: d.structName,
- Field: d.fieldName,
- }
-}
-
-func (d *invalidDecoder) DecodePath(ctx *RuntimeContext, cursor, depth int64) ([][]byte, int64, error) {
- return nil, 0, &errors.UnmarshalTypeError{
- Value: "object",
- Type: runtime.RType2Type(d.typ),
- Offset: cursor,
- Struct: d.structName,
- Field: d.fieldName,
- }
-}
diff --git a/vendor/github.com/goccy/go-json/internal/decoder/map.go b/vendor/github.com/goccy/go-json/internal/decoder/map.go
deleted file mode 100644
index 07a9caea..00000000
--- a/vendor/github.com/goccy/go-json/internal/decoder/map.go
+++ /dev/null
@@ -1,280 +0,0 @@
-package decoder
-
-import (
- "reflect"
- "unsafe"
-
- "github.com/goccy/go-json/internal/errors"
- "github.com/goccy/go-json/internal/runtime"
-)
-
-type mapDecoder struct {
- mapType *runtime.Type
- keyType *runtime.Type
- valueType *runtime.Type
- canUseAssignFaststrType bool
- keyDecoder Decoder
- valueDecoder Decoder
- structName string
- fieldName string
-}
-
-func newMapDecoder(mapType *runtime.Type, keyType *runtime.Type, keyDec Decoder, valueType *runtime.Type, valueDec Decoder, structName, fieldName string) *mapDecoder {
- return &mapDecoder{
- mapType: mapType,
- keyDecoder: keyDec,
- keyType: keyType,
- canUseAssignFaststrType: canUseAssignFaststrType(keyType, valueType),
- valueType: valueType,
- valueDecoder: valueDec,
- structName: structName,
- fieldName: fieldName,
- }
-}
-
-const (
- mapMaxElemSize = 128
-)
-
-// See detail: https://github.com/goccy/go-json/pull/283
-func canUseAssignFaststrType(key *runtime.Type, value *runtime.Type) bool {
- indirectElem := value.Size() > mapMaxElemSize
- if indirectElem {
- return false
- }
- return key.Kind() == reflect.String
-}
-
-//go:linkname makemap reflect.makemap
-func makemap(*runtime.Type, int) unsafe.Pointer
-
-//nolint:golint
-//go:linkname mapassign_faststr runtime.mapassign_faststr
-//go:noescape
-func mapassign_faststr(t *runtime.Type, m unsafe.Pointer, s string) unsafe.Pointer
-
-//go:linkname mapassign reflect.mapassign
-//go:noescape
-func mapassign(t *runtime.Type, m unsafe.Pointer, k, v unsafe.Pointer)
-
-func (d *mapDecoder) mapassign(t *runtime.Type, m, k, v unsafe.Pointer) {
- if d.canUseAssignFaststrType {
- mapV := mapassign_faststr(t, m, *(*string)(k))
- typedmemmove(d.valueType, mapV, v)
- } else {
- mapassign(t, m, k, v)
- }
-}
-
-func (d *mapDecoder) DecodeStream(s *Stream, depth int64, p unsafe.Pointer) error {
- depth++
- if depth > maxDecodeNestingDepth {
- return errors.ErrExceededMaxDepth(s.char(), s.cursor)
- }
-
- switch s.skipWhiteSpace() {
- case 'n':
- if err := nullBytes(s); err != nil {
- return err
- }
- **(**unsafe.Pointer)(unsafe.Pointer(&p)) = nil
- return nil
- case '{':
- default:
- return errors.ErrExpected("{ character for map value", s.totalOffset())
- }
- mapValue := *(*unsafe.Pointer)(p)
- if mapValue == nil {
- mapValue = makemap(d.mapType, 0)
- }
- s.cursor++
- if s.skipWhiteSpace() == '}' {
- *(*unsafe.Pointer)(p) = mapValue
- s.cursor++
- return nil
- }
- for {
- k := unsafe_New(d.keyType)
- if err := d.keyDecoder.DecodeStream(s, depth, k); err != nil {
- return err
- }
- s.skipWhiteSpace()
- if !s.equalChar(':') {
- return errors.ErrExpected("colon after object key", s.totalOffset())
- }
- s.cursor++
- v := unsafe_New(d.valueType)
- if err := d.valueDecoder.DecodeStream(s, depth, v); err != nil {
- return err
- }
- d.mapassign(d.mapType, mapValue, k, v)
- s.skipWhiteSpace()
- if s.equalChar('}') {
- **(**unsafe.Pointer)(unsafe.Pointer(&p)) = mapValue
- s.cursor++
- return nil
- }
- if !s.equalChar(',') {
- return errors.ErrExpected("comma after object value", s.totalOffset())
- }
- s.cursor++
- }
-}
-
-func (d *mapDecoder) Decode(ctx *RuntimeContext, cursor, depth int64, p unsafe.Pointer) (int64, error) {
- buf := ctx.Buf
- depth++
- if depth > maxDecodeNestingDepth {
- return 0, errors.ErrExceededMaxDepth(buf[cursor], cursor)
- }
-
- cursor = skipWhiteSpace(buf, cursor)
- buflen := int64(len(buf))
- if buflen < 2 {
- return 0, errors.ErrExpected("{} for map", cursor)
- }
- switch buf[cursor] {
- case 'n':
- if err := validateNull(buf, cursor); err != nil {
- return 0, err
- }
- cursor += 4
- **(**unsafe.Pointer)(unsafe.Pointer(&p)) = nil
- return cursor, nil
- case '{':
- default:
- return 0, errors.ErrExpected("{ character for map value", cursor)
- }
- cursor++
- cursor = skipWhiteSpace(buf, cursor)
- mapValue := *(*unsafe.Pointer)(p)
- if mapValue == nil {
- mapValue = makemap(d.mapType, 0)
- }
- if buf[cursor] == '}' {
- **(**unsafe.Pointer)(unsafe.Pointer(&p)) = mapValue
- cursor++
- return cursor, nil
- }
- for {
- k := unsafe_New(d.keyType)
- keyCursor, err := d.keyDecoder.Decode(ctx, cursor, depth, k)
- if err != nil {
- return 0, err
- }
- cursor = skipWhiteSpace(buf, keyCursor)
- if buf[cursor] != ':' {
- return 0, errors.ErrExpected("colon after object key", cursor)
- }
- cursor++
- v := unsafe_New(d.valueType)
- valueCursor, err := d.valueDecoder.Decode(ctx, cursor, depth, v)
- if err != nil {
- return 0, err
- }
- d.mapassign(d.mapType, mapValue, k, v)
- cursor = skipWhiteSpace(buf, valueCursor)
- if buf[cursor] == '}' {
- **(**unsafe.Pointer)(unsafe.Pointer(&p)) = mapValue
- cursor++
- return cursor, nil
- }
- if buf[cursor] != ',' {
- return 0, errors.ErrExpected("comma after object value", cursor)
- }
- cursor++
- }
-}
-
-func (d *mapDecoder) DecodePath(ctx *RuntimeContext, cursor, depth int64) ([][]byte, int64, error) {
- buf := ctx.Buf
- depth++
- if depth > maxDecodeNestingDepth {
- return nil, 0, errors.ErrExceededMaxDepth(buf[cursor], cursor)
- }
-
- cursor = skipWhiteSpace(buf, cursor)
- buflen := int64(len(buf))
- if buflen < 2 {
- return nil, 0, errors.ErrExpected("{} for map", cursor)
- }
- switch buf[cursor] {
- case 'n':
- if err := validateNull(buf, cursor); err != nil {
- return nil, 0, err
- }
- cursor += 4
- return [][]byte{nullbytes}, cursor, nil
- case '{':
- default:
- return nil, 0, errors.ErrExpected("{ character for map value", cursor)
- }
- cursor++
- cursor = skipWhiteSpace(buf, cursor)
- if buf[cursor] == '}' {
- cursor++
- return nil, cursor, nil
- }
- keyDecoder, ok := d.keyDecoder.(*stringDecoder)
- if !ok {
- return nil, 0, &errors.UnmarshalTypeError{
- Value: "string",
- Type: reflect.TypeOf(""),
- Offset: cursor,
- Struct: d.structName,
- Field: d.fieldName,
- }
- }
- ret := [][]byte{}
- for {
- key, keyCursor, err := keyDecoder.decodeByte(buf, cursor)
- if err != nil {
- return nil, 0, err
- }
- cursor = skipWhiteSpace(buf, keyCursor)
- if buf[cursor] != ':' {
- return nil, 0, errors.ErrExpected("colon after object key", cursor)
- }
- cursor++
- child, found, err := ctx.Option.Path.Field(string(key))
- if err != nil {
- return nil, 0, err
- }
- if found {
- if child != nil {
- oldPath := ctx.Option.Path.node
- ctx.Option.Path.node = child
- paths, c, err := d.valueDecoder.DecodePath(ctx, cursor, depth)
- if err != nil {
- return nil, 0, err
- }
- ctx.Option.Path.node = oldPath
- ret = append(ret, paths...)
- cursor = c
- } else {
- start := cursor
- end, err := skipValue(buf, cursor, depth)
- if err != nil {
- return nil, 0, err
- }
- ret = append(ret, buf[start:end])
- cursor = end
- }
- } else {
- c, err := skipValue(buf, cursor, depth)
- if err != nil {
- return nil, 0, err
- }
- cursor = c
- }
- cursor = skipWhiteSpace(buf, cursor)
- if buf[cursor] == '}' {
- cursor++
- return ret, cursor, nil
- }
- if buf[cursor] != ',' {
- return nil, 0, errors.ErrExpected("comma after object value", cursor)
- }
- cursor++
- }
-}
diff --git a/vendor/github.com/goccy/go-json/internal/decoder/number.go b/vendor/github.com/goccy/go-json/internal/decoder/number.go
deleted file mode 100644
index 10e5435e..00000000
--- a/vendor/github.com/goccy/go-json/internal/decoder/number.go
+++ /dev/null
@@ -1,123 +0,0 @@
-package decoder
-
-import (
- "encoding/json"
- "strconv"
- "unsafe"
-
- "github.com/goccy/go-json/internal/errors"
-)
-
-type numberDecoder struct {
- stringDecoder *stringDecoder
- op func(unsafe.Pointer, json.Number)
- structName string
- fieldName string
-}
-
-func newNumberDecoder(structName, fieldName string, op func(unsafe.Pointer, json.Number)) *numberDecoder {
- return &numberDecoder{
- stringDecoder: newStringDecoder(structName, fieldName),
- op: op,
- structName: structName,
- fieldName: fieldName,
- }
-}
-
-func (d *numberDecoder) DecodeStream(s *Stream, depth int64, p unsafe.Pointer) error {
- bytes, err := d.decodeStreamByte(s)
- if err != nil {
- return err
- }
- if _, err := strconv.ParseFloat(*(*string)(unsafe.Pointer(&bytes)), 64); err != nil {
- return errors.ErrSyntax(err.Error(), s.totalOffset())
- }
- d.op(p, json.Number(string(bytes)))
- s.reset()
- return nil
-}
-
-func (d *numberDecoder) Decode(ctx *RuntimeContext, cursor, depth int64, p unsafe.Pointer) (int64, error) {
- bytes, c, err := d.decodeByte(ctx.Buf, cursor)
- if err != nil {
- return 0, err
- }
- if _, err := strconv.ParseFloat(*(*string)(unsafe.Pointer(&bytes)), 64); err != nil {
- return 0, errors.ErrSyntax(err.Error(), c)
- }
- cursor = c
- s := *(*string)(unsafe.Pointer(&bytes))
- d.op(p, json.Number(s))
- return cursor, nil
-}
-
-func (d *numberDecoder) DecodePath(ctx *RuntimeContext, cursor, depth int64) ([][]byte, int64, error) {
- bytes, c, err := d.decodeByte(ctx.Buf, cursor)
- if err != nil {
- return nil, 0, err
- }
- if bytes == nil {
- return [][]byte{nullbytes}, c, nil
- }
- return [][]byte{bytes}, c, nil
-}
-
-func (d *numberDecoder) decodeStreamByte(s *Stream) ([]byte, error) {
- start := s.cursor
- for {
- switch s.char() {
- case ' ', '\n', '\t', '\r':
- s.cursor++
- continue
- case '-', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
- return floatBytes(s), nil
- case 'n':
- if err := nullBytes(s); err != nil {
- return nil, err
- }
- return nil, nil
- case '"':
- return d.stringDecoder.decodeStreamByte(s)
- case nul:
- if s.read() {
- continue
- }
- goto ERROR
- default:
- goto ERROR
- }
- }
-ERROR:
- if s.cursor == start {
- return nil, errors.ErrInvalidBeginningOfValue(s.char(), s.totalOffset())
- }
- return nil, errors.ErrUnexpectedEndOfJSON("json.Number", s.totalOffset())
-}
-
-func (d *numberDecoder) decodeByte(buf []byte, cursor int64) ([]byte, int64, error) {
- for {
- switch buf[cursor] {
- case ' ', '\n', '\t', '\r':
- cursor++
- continue
- case '-', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
- start := cursor
- cursor++
- for floatTable[buf[cursor]] {
- cursor++
- }
- num := buf[start:cursor]
- return num, cursor, nil
- case 'n':
- if err := validateNull(buf, cursor); err != nil {
- return nil, 0, err
- }
- cursor += 4
- return nil, cursor, nil
- case '"':
- return d.stringDecoder.decodeByte(buf, cursor)
- default:
- return nil, 0, errors.ErrUnexpectedEndOfJSON("json.Number", cursor)
- }
- }
-}
diff --git a/vendor/github.com/goccy/go-json/internal/decoder/option.go b/vendor/github.com/goccy/go-json/internal/decoder/option.go
deleted file mode 100644
index 502f772e..00000000
--- a/vendor/github.com/goccy/go-json/internal/decoder/option.go
+++ /dev/null
@@ -1,17 +0,0 @@
-package decoder
-
-import "context"
-
-type OptionFlags uint8
-
-const (
- FirstWinOption OptionFlags = 1 << iota
- ContextOption
- PathOption
-)
-
-type Option struct {
- Flags OptionFlags
- Context context.Context
- Path *Path
-}
diff --git a/vendor/github.com/goccy/go-json/internal/decoder/path.go b/vendor/github.com/goccy/go-json/internal/decoder/path.go
deleted file mode 100644
index a15ff69e..00000000
--- a/vendor/github.com/goccy/go-json/internal/decoder/path.go
+++ /dev/null
@@ -1,670 +0,0 @@
-package decoder
-
-import (
- "fmt"
- "reflect"
- "strconv"
-
- "github.com/goccy/go-json/internal/errors"
- "github.com/goccy/go-json/internal/runtime"
-)
-
-type PathString string
-
-func (s PathString) Build() (*Path, error) {
- builder := new(PathBuilder)
- return builder.Build([]rune(s))
-}
-
-type PathBuilder struct {
- root PathNode
- node PathNode
- singleQuotePathSelector bool
- doubleQuotePathSelector bool
-}
-
-func (b *PathBuilder) Build(buf []rune) (*Path, error) {
- node, err := b.build(buf)
- if err != nil {
- return nil, err
- }
- return &Path{
- node: node,
- RootSelectorOnly: node == nil,
- SingleQuotePathSelector: b.singleQuotePathSelector,
- DoubleQuotePathSelector: b.doubleQuotePathSelector,
- }, nil
-}
-
-func (b *PathBuilder) build(buf []rune) (PathNode, error) {
- if len(buf) == 0 {
- return nil, errors.ErrEmptyPath()
- }
- if buf[0] != '$' {
- return nil, errors.ErrInvalidPath("JSON Path must start with a $ character")
- }
- if len(buf) == 1 {
- return nil, nil
- }
- buf = buf[1:]
- offset, err := b.buildNext(buf)
- if err != nil {
- return nil, err
- }
- if len(buf) > offset {
- return nil, errors.ErrInvalidPath("remain invalid path %q", buf[offset:])
- }
- return b.root, nil
-}
-
-func (b *PathBuilder) buildNextCharIfExists(buf []rune, cursor int) (int, error) {
- if len(buf) > cursor {
- offset, err := b.buildNext(buf[cursor:])
- if err != nil {
- return 0, err
- }
- return cursor + 1 + offset, nil
- }
- return cursor, nil
-}
-
-func (b *PathBuilder) buildNext(buf []rune) (int, error) {
- switch buf[0] {
- case '.':
- if len(buf) == 1 {
- return 0, errors.ErrInvalidPath("JSON Path ends with dot character")
- }
- offset, err := b.buildSelector(buf[1:])
- if err != nil {
- return 0, err
- }
- return offset + 1, nil
- case '[':
- if len(buf) == 1 {
- return 0, errors.ErrInvalidPath("JSON Path ends with left bracket character")
- }
- offset, err := b.buildIndex(buf[1:])
- if err != nil {
- return 0, err
- }
- return offset + 1, nil
- default:
- return 0, errors.ErrInvalidPath("expect dot or left bracket character. but found %c character", buf[0])
- }
-}
-
-func (b *PathBuilder) buildSelector(buf []rune) (int, error) {
- switch buf[0] {
- case '.':
- if len(buf) == 1 {
- return 0, errors.ErrInvalidPath("JSON Path ends with double dot character")
- }
- offset, err := b.buildPathRecursive(buf[1:])
- if err != nil {
- return 0, err
- }
- return 1 + offset, nil
- case '[', ']', '$', '*':
- return 0, errors.ErrInvalidPath("found invalid path character %c after dot", buf[0])
- }
- for cursor := 0; cursor < len(buf); cursor++ {
- switch buf[cursor] {
- case '$', '*', ']':
- return 0, errors.ErrInvalidPath("found %c character in field selector context", buf[cursor])
- case '.':
- if cursor+1 >= len(buf) {
- return 0, errors.ErrInvalidPath("JSON Path ends with dot character")
- }
- selector := buf[:cursor]
- b.addSelectorNode(string(selector))
- offset, err := b.buildSelector(buf[cursor+1:])
- if err != nil {
- return 0, err
- }
- return cursor + 1 + offset, nil
- case '[':
- if cursor+1 >= len(buf) {
- return 0, errors.ErrInvalidPath("JSON Path ends with left bracket character")
- }
- selector := buf[:cursor]
- b.addSelectorNode(string(selector))
- offset, err := b.buildIndex(buf[cursor+1:])
- if err != nil {
- return 0, err
- }
- return cursor + 1 + offset, nil
- case '"':
- if cursor+1 >= len(buf) {
- return 0, errors.ErrInvalidPath("JSON Path ends with double quote character")
- }
- offset, err := b.buildQuoteSelector(buf[cursor+1:], DoubleQuotePathSelector)
- if err != nil {
- return 0, err
- }
- return cursor + 1 + offset, nil
- }
- }
- b.addSelectorNode(string(buf))
- return len(buf), nil
-}
-
-func (b *PathBuilder) buildQuoteSelector(buf []rune, sel QuotePathSelector) (int, error) {
- switch buf[0] {
- case '[', ']', '$', '.', '*', '\'', '"':
- return 0, errors.ErrInvalidPath("found invalid path character %c after quote", buf[0])
- }
- for cursor := 0; cursor < len(buf); cursor++ {
- switch buf[cursor] {
- case '\'':
- if sel != SingleQuotePathSelector {
- return 0, errors.ErrInvalidPath("found double quote character in field selector with single quote context")
- }
- if len(buf) <= cursor+1 {
- return 0, errors.ErrInvalidPath("JSON Path ends with single quote character in field selector context")
- }
- if buf[cursor+1] != ']' {
- return 0, errors.ErrInvalidPath("expect right bracket for field selector with single quote but found %c", buf[cursor+1])
- }
- selector := buf[:cursor]
- b.addSelectorNode(string(selector))
- b.singleQuotePathSelector = true
- return b.buildNextCharIfExists(buf, cursor+2)
- case '"':
- if sel != DoubleQuotePathSelector {
- return 0, errors.ErrInvalidPath("found single quote character in field selector with double quote context")
- }
- selector := buf[:cursor]
- b.addSelectorNode(string(selector))
- b.doubleQuotePathSelector = true
- return b.buildNextCharIfExists(buf, cursor+1)
- }
- }
- return 0, errors.ErrInvalidPath("couldn't find quote character in selector quote path context")
-}
-
-func (b *PathBuilder) buildPathRecursive(buf []rune) (int, error) {
- switch buf[0] {
- case '.', '[', ']', '$', '*':
- return 0, errors.ErrInvalidPath("found invalid path character %c after double dot", buf[0])
- }
- for cursor := 0; cursor < len(buf); cursor++ {
- switch buf[cursor] {
- case '$', '*', ']':
- return 0, errors.ErrInvalidPath("found %c character in field selector context", buf[cursor])
- case '.':
- if cursor+1 >= len(buf) {
- return 0, errors.ErrInvalidPath("JSON Path ends with dot character")
- }
- selector := buf[:cursor]
- b.addRecursiveNode(string(selector))
- offset, err := b.buildSelector(buf[cursor+1:])
- if err != nil {
- return 0, err
- }
- return cursor + 1 + offset, nil
- case '[':
- if cursor+1 >= len(buf) {
- return 0, errors.ErrInvalidPath("JSON Path ends with left bracket character")
- }
- selector := buf[:cursor]
- b.addRecursiveNode(string(selector))
- offset, err := b.buildIndex(buf[cursor+1:])
- if err != nil {
- return 0, err
- }
- return cursor + 1 + offset, nil
- }
- }
- b.addRecursiveNode(string(buf))
- return len(buf), nil
-}
-
-func (b *PathBuilder) buildIndex(buf []rune) (int, error) {
- switch buf[0] {
- case '.', '[', ']', '$':
- return 0, errors.ErrInvalidPath("found invalid path character %c after left bracket", buf[0])
- case '\'':
- if len(buf) == 1 {
- return 0, errors.ErrInvalidPath("JSON Path ends with single quote character")
- }
- offset, err := b.buildQuoteSelector(buf[1:], SingleQuotePathSelector)
- if err != nil {
- return 0, err
- }
- return 1 + offset, nil
- case '*':
- if len(buf) == 1 {
- return 0, errors.ErrInvalidPath("JSON Path ends with star character")
- }
- if buf[1] != ']' {
- return 0, errors.ErrInvalidPath("expect right bracket character for index all path but found %c character", buf[1])
- }
- b.addIndexAllNode()
- offset := len("*]")
- if len(buf) > 2 {
- buildOffset, err := b.buildNext(buf[2:])
- if err != nil {
- return 0, err
- }
- return offset + buildOffset, nil
- }
- return offset, nil
- }
-
- for cursor := 0; cursor < len(buf); cursor++ {
- switch buf[cursor] {
- case ']':
- index, err := strconv.ParseInt(string(buf[:cursor]), 10, 64)
- if err != nil {
- return 0, errors.ErrInvalidPath("%q is unexpected index path", buf[:cursor])
- }
- b.addIndexNode(int(index))
- return b.buildNextCharIfExists(buf, cursor+1)
- }
- }
- return 0, errors.ErrInvalidPath("couldn't find right bracket character in index path context")
-}
-
-func (b *PathBuilder) addIndexAllNode() {
- node := newPathIndexAllNode()
- if b.root == nil {
- b.root = node
- b.node = node
- } else {
- b.node = b.node.chain(node)
- }
-}
-
-func (b *PathBuilder) addRecursiveNode(selector string) {
- node := newPathRecursiveNode(selector)
- if b.root == nil {
- b.root = node
- b.node = node
- } else {
- b.node = b.node.chain(node)
- }
-}
-
-func (b *PathBuilder) addSelectorNode(name string) {
- node := newPathSelectorNode(name)
- if b.root == nil {
- b.root = node
- b.node = node
- } else {
- b.node = b.node.chain(node)
- }
-}
-
-func (b *PathBuilder) addIndexNode(idx int) {
- node := newPathIndexNode(idx)
- if b.root == nil {
- b.root = node
- b.node = node
- } else {
- b.node = b.node.chain(node)
- }
-}
-
-type QuotePathSelector int
-
-const (
- SingleQuotePathSelector QuotePathSelector = 1
- DoubleQuotePathSelector QuotePathSelector = 2
-)
-
-type Path struct {
- node PathNode
- RootSelectorOnly bool
- SingleQuotePathSelector bool
- DoubleQuotePathSelector bool
-}
-
-func (p *Path) Field(sel string) (PathNode, bool, error) {
- if p.node == nil {
- return nil, false, nil
- }
- return p.node.Field(sel)
-}
-
-func (p *Path) Get(src, dst reflect.Value) error {
- if p.node == nil {
- return nil
- }
- return p.node.Get(src, dst)
-}
-
-func (p *Path) String() string {
- if p.node == nil {
- return "$"
- }
- return p.node.String()
-}
-
-type PathNode interface {
- fmt.Stringer
- Index(idx int) (PathNode, bool, error)
- Field(fieldName string) (PathNode, bool, error)
- Get(src, dst reflect.Value) error
- chain(PathNode) PathNode
- target() bool
- single() bool
-}
-
-type BasePathNode struct {
- child PathNode
-}
-
-func (n *BasePathNode) chain(node PathNode) PathNode {
- n.child = node
- return node
-}
-
-func (n *BasePathNode) target() bool {
- return n.child == nil
-}
-
-func (n *BasePathNode) single() bool {
- return true
-}
-
-type PathSelectorNode struct {
- *BasePathNode
- selector string
-}
-
-func newPathSelectorNode(selector string) *PathSelectorNode {
- return &PathSelectorNode{
- BasePathNode: &BasePathNode{},
- selector: selector,
- }
-}
-
-func (n *PathSelectorNode) Index(idx int) (PathNode, bool, error) {
- return nil, false, &errors.PathError{}
-}
-
-func (n *PathSelectorNode) Field(fieldName string) (PathNode, bool, error) {
- if n.selector == fieldName {
- return n.child, true, nil
- }
- return nil, false, nil
-}
-
-func (n *PathSelectorNode) Get(src, dst reflect.Value) error {
- switch src.Type().Kind() {
- case reflect.Map:
- iter := src.MapRange()
- for iter.Next() {
- key, ok := iter.Key().Interface().(string)
- if !ok {
- return fmt.Errorf("invalid map key type %T", src.Type().Key())
- }
- child, found, err := n.Field(key)
- if err != nil {
- return err
- }
- if found {
- if child != nil {
- return child.Get(iter.Value(), dst)
- }
- return AssignValue(iter.Value(), dst)
- }
- }
- case reflect.Struct:
- typ := src.Type()
- for i := 0; i < typ.Len(); i++ {
- tag := runtime.StructTagFromField(typ.Field(i))
- child, found, err := n.Field(tag.Key)
- if err != nil {
- return err
- }
- if found {
- if child != nil {
- return child.Get(src.Field(i), dst)
- }
- return AssignValue(src.Field(i), dst)
- }
- }
- case reflect.Ptr:
- return n.Get(src.Elem(), dst)
- case reflect.Interface:
- return n.Get(reflect.ValueOf(src.Interface()), dst)
- case reflect.Float64, reflect.String, reflect.Bool:
- return AssignValue(src, dst)
- }
- return fmt.Errorf("failed to get %s value from %s", n.selector, src.Type())
-}
-
-func (n *PathSelectorNode) String() string {
- s := fmt.Sprintf(".%s", n.selector)
- if n.child != nil {
- s += n.child.String()
- }
- return s
-}
-
-type PathIndexNode struct {
- *BasePathNode
- selector int
-}
-
-func newPathIndexNode(selector int) *PathIndexNode {
- return &PathIndexNode{
- BasePathNode: &BasePathNode{},
- selector: selector,
- }
-}
-
-func (n *PathIndexNode) Index(idx int) (PathNode, bool, error) {
- if n.selector == idx {
- return n.child, true, nil
- }
- return nil, false, nil
-}
-
-func (n *PathIndexNode) Field(fieldName string) (PathNode, bool, error) {
- return nil, false, &errors.PathError{}
-}
-
-func (n *PathIndexNode) Get(src, dst reflect.Value) error {
- switch src.Type().Kind() {
- case reflect.Array, reflect.Slice:
- if src.Len() > n.selector {
- if n.child != nil {
- return n.child.Get(src.Index(n.selector), dst)
- }
- return AssignValue(src.Index(n.selector), dst)
- }
- case reflect.Ptr:
- return n.Get(src.Elem(), dst)
- case reflect.Interface:
- return n.Get(reflect.ValueOf(src.Interface()), dst)
- }
- return fmt.Errorf("failed to get [%d] value from %s", n.selector, src.Type())
-}
-
-func (n *PathIndexNode) String() string {
- s := fmt.Sprintf("[%d]", n.selector)
- if n.child != nil {
- s += n.child.String()
- }
- return s
-}
-
-type PathIndexAllNode struct {
- *BasePathNode
-}
-
-func newPathIndexAllNode() *PathIndexAllNode {
- return &PathIndexAllNode{
- BasePathNode: &BasePathNode{},
- }
-}
-
-func (n *PathIndexAllNode) Index(idx int) (PathNode, bool, error) {
- return n.child, true, nil
-}
-
-func (n *PathIndexAllNode) Field(fieldName string) (PathNode, bool, error) {
- return nil, false, &errors.PathError{}
-}
-
-func (n *PathIndexAllNode) Get(src, dst reflect.Value) error {
- switch src.Type().Kind() {
- case reflect.Array, reflect.Slice:
- var arr []interface{}
- for i := 0; i < src.Len(); i++ {
- var v interface{}
- rv := reflect.ValueOf(&v)
- if n.child != nil {
- if err := n.child.Get(src.Index(i), rv); err != nil {
- return err
- }
- } else {
- if err := AssignValue(src.Index(i), rv); err != nil {
- return err
- }
- }
- arr = append(arr, v)
- }
- if err := AssignValue(reflect.ValueOf(arr), dst); err != nil {
- return err
- }
- return nil
- case reflect.Ptr:
- return n.Get(src.Elem(), dst)
- case reflect.Interface:
- return n.Get(reflect.ValueOf(src.Interface()), dst)
- }
- return fmt.Errorf("failed to get all value from %s", src.Type())
-}
-
-func (n *PathIndexAllNode) String() string {
- s := "[*]"
- if n.child != nil {
- s += n.child.String()
- }
- return s
-}
-
-type PathRecursiveNode struct {
- *BasePathNode
- selector string
-}
-
-func newPathRecursiveNode(selector string) *PathRecursiveNode {
- node := newPathSelectorNode(selector)
- return &PathRecursiveNode{
- BasePathNode: &BasePathNode{
- child: node,
- },
- selector: selector,
- }
-}
-
-func (n *PathRecursiveNode) Field(fieldName string) (PathNode, bool, error) {
- if n.selector == fieldName {
- return n.child, true, nil
- }
- return nil, false, nil
-}
-
-func (n *PathRecursiveNode) Index(_ int) (PathNode, bool, error) {
- return n, true, nil
-}
-
-func valueToSliceValue(v interface{}) []interface{} {
- rv := reflect.ValueOf(v)
- ret := []interface{}{}
- if rv.Type().Kind() == reflect.Slice || rv.Type().Kind() == reflect.Array {
- for i := 0; i < rv.Len(); i++ {
- ret = append(ret, rv.Index(i).Interface())
- }
- return ret
- }
- return []interface{}{v}
-}
-
-func (n *PathRecursiveNode) Get(src, dst reflect.Value) error {
- if n.child == nil {
- return fmt.Errorf("failed to get by recursive path ..%s", n.selector)
- }
- var arr []interface{}
- switch src.Type().Kind() {
- case reflect.Map:
- iter := src.MapRange()
- for iter.Next() {
- key, ok := iter.Key().Interface().(string)
- if !ok {
- return fmt.Errorf("invalid map key type %T", src.Type().Key())
- }
- child, found, err := n.Field(key)
- if err != nil {
- return err
- }
- if found {
- var v interface{}
- rv := reflect.ValueOf(&v)
- _ = child.Get(iter.Value(), rv)
- arr = append(arr, valueToSliceValue(v)...)
- } else {
- var v interface{}
- rv := reflect.ValueOf(&v)
- _ = n.Get(iter.Value(), rv)
- if v != nil {
- arr = append(arr, valueToSliceValue(v)...)
- }
- }
- }
- _ = AssignValue(reflect.ValueOf(arr), dst)
- return nil
- case reflect.Struct:
- typ := src.Type()
- for i := 0; i < typ.Len(); i++ {
- tag := runtime.StructTagFromField(typ.Field(i))
- child, found, err := n.Field(tag.Key)
- if err != nil {
- return err
- }
- if found {
- var v interface{}
- rv := reflect.ValueOf(&v)
- _ = child.Get(src.Field(i), rv)
- arr = append(arr, valueToSliceValue(v)...)
- } else {
- var v interface{}
- rv := reflect.ValueOf(&v)
- _ = n.Get(src.Field(i), rv)
- if v != nil {
- arr = append(arr, valueToSliceValue(v)...)
- }
- }
- }
- _ = AssignValue(reflect.ValueOf(arr), dst)
- return nil
- case reflect.Array, reflect.Slice:
- for i := 0; i < src.Len(); i++ {
- var v interface{}
- rv := reflect.ValueOf(&v)
- _ = n.Get(src.Index(i), rv)
- if v != nil {
- arr = append(arr, valueToSliceValue(v)...)
- }
- }
- _ = AssignValue(reflect.ValueOf(arr), dst)
- return nil
- case reflect.Ptr:
- return n.Get(src.Elem(), dst)
- case reflect.Interface:
- return n.Get(reflect.ValueOf(src.Interface()), dst)
- }
- return fmt.Errorf("failed to get %s value from %s", n.selector, src.Type())
-}
-
-func (n *PathRecursiveNode) String() string {
- s := fmt.Sprintf("..%s", n.selector)
- if n.child != nil {
- s += n.child.String()
- }
- return s
-}
diff --git a/vendor/github.com/goccy/go-json/internal/decoder/ptr.go b/vendor/github.com/goccy/go-json/internal/decoder/ptr.go
deleted file mode 100644
index ae229946..00000000
--- a/vendor/github.com/goccy/go-json/internal/decoder/ptr.go
+++ /dev/null
@@ -1,97 +0,0 @@
-package decoder
-
-import (
- "fmt"
- "unsafe"
-
- "github.com/goccy/go-json/internal/runtime"
-)
-
-type ptrDecoder struct {
- dec Decoder
- typ *runtime.Type
- structName string
- fieldName string
-}
-
-func newPtrDecoder(dec Decoder, typ *runtime.Type, structName, fieldName string) *ptrDecoder {
- return &ptrDecoder{
- dec: dec,
- typ: typ,
- structName: structName,
- fieldName: fieldName,
- }
-}
-
-func (d *ptrDecoder) contentDecoder() Decoder {
- dec, ok := d.dec.(*ptrDecoder)
- if !ok {
- return d.dec
- }
- return dec.contentDecoder()
-}
-
-//nolint:golint
-//go:linkname unsafe_New reflect.unsafe_New
-func unsafe_New(*runtime.Type) unsafe.Pointer
-
-func UnsafeNew(t *runtime.Type) unsafe.Pointer {
- return unsafe_New(t)
-}
-
-func (d *ptrDecoder) DecodeStream(s *Stream, depth int64, p unsafe.Pointer) error {
- if s.skipWhiteSpace() == nul {
- s.read()
- }
- if s.char() == 'n' {
- if err := nullBytes(s); err != nil {
- return err
- }
- *(*unsafe.Pointer)(p) = nil
- return nil
- }
- var newptr unsafe.Pointer
- if *(*unsafe.Pointer)(p) == nil {
- newptr = unsafe_New(d.typ)
- *(*unsafe.Pointer)(p) = newptr
- } else {
- newptr = *(*unsafe.Pointer)(p)
- }
- if err := d.dec.DecodeStream(s, depth, newptr); err != nil {
- return err
- }
- return nil
-}
-
-func (d *ptrDecoder) Decode(ctx *RuntimeContext, cursor, depth int64, p unsafe.Pointer) (int64, error) {
- buf := ctx.Buf
- cursor = skipWhiteSpace(buf, cursor)
- if buf[cursor] == 'n' {
- if err := validateNull(buf, cursor); err != nil {
- return 0, err
- }
- if p != nil {
- *(*unsafe.Pointer)(p) = nil
- }
- cursor += 4
- return cursor, nil
- }
- var newptr unsafe.Pointer
- if *(*unsafe.Pointer)(p) == nil {
- newptr = unsafe_New(d.typ)
- *(*unsafe.Pointer)(p) = newptr
- } else {
- newptr = *(*unsafe.Pointer)(p)
- }
- c, err := d.dec.Decode(ctx, cursor, depth, newptr)
- if err != nil {
- *(*unsafe.Pointer)(p) = nil
- return 0, err
- }
- cursor = c
- return cursor, nil
-}
-
-func (d *ptrDecoder) DecodePath(ctx *RuntimeContext, cursor, depth int64) ([][]byte, int64, error) {
- return nil, 0, fmt.Errorf("json: ptr decoder does not support decode path")
-}
diff --git a/vendor/github.com/goccy/go-json/internal/decoder/slice.go b/vendor/github.com/goccy/go-json/internal/decoder/slice.go
deleted file mode 100644
index 30a23e4b..00000000
--- a/vendor/github.com/goccy/go-json/internal/decoder/slice.go
+++ /dev/null
@@ -1,380 +0,0 @@
-package decoder
-
-import (
- "reflect"
- "sync"
- "unsafe"
-
- "github.com/goccy/go-json/internal/errors"
- "github.com/goccy/go-json/internal/runtime"
-)
-
-var (
- sliceType = runtime.Type2RType(
- reflect.TypeOf((*sliceHeader)(nil)).Elem(),
- )
- nilSlice = unsafe.Pointer(&sliceHeader{})
-)
-
-type sliceDecoder struct {
- elemType *runtime.Type
- isElemPointerType bool
- valueDecoder Decoder
- size uintptr
- arrayPool sync.Pool
- structName string
- fieldName string
-}
-
-// If use reflect.SliceHeader, data type is uintptr.
-// In this case, Go compiler cannot trace reference created by newArray().
-// So, define using unsafe.Pointer as data type
-type sliceHeader struct {
- data unsafe.Pointer
- len int
- cap int
-}
-
-const (
- defaultSliceCapacity = 2
-)
-
-func newSliceDecoder(dec Decoder, elemType *runtime.Type, size uintptr, structName, fieldName string) *sliceDecoder {
- return &sliceDecoder{
- valueDecoder: dec,
- elemType: elemType,
- isElemPointerType: elemType.Kind() == reflect.Ptr || elemType.Kind() == reflect.Map,
- size: size,
- arrayPool: sync.Pool{
- New: func() interface{} {
- return &sliceHeader{
- data: newArray(elemType, defaultSliceCapacity),
- len: 0,
- cap: defaultSliceCapacity,
- }
- },
- },
- structName: structName,
- fieldName: fieldName,
- }
-}
-
-func (d *sliceDecoder) newSlice(src *sliceHeader) *sliceHeader {
- slice := d.arrayPool.Get().(*sliceHeader)
- if src.len > 0 {
- // copy original elem
- if slice.cap < src.cap {
- data := newArray(d.elemType, src.cap)
- slice = &sliceHeader{data: data, len: src.len, cap: src.cap}
- } else {
- slice.len = src.len
- }
- copySlice(d.elemType, *slice, *src)
- } else {
- slice.len = 0
- }
- return slice
-}
-
-func (d *sliceDecoder) releaseSlice(p *sliceHeader) {
- d.arrayPool.Put(p)
-}
-
-//go:linkname copySlice reflect.typedslicecopy
-func copySlice(elemType *runtime.Type, dst, src sliceHeader) int
-
-//go:linkname newArray reflect.unsafe_NewArray
-func newArray(*runtime.Type, int) unsafe.Pointer
-
-//go:linkname typedmemmove reflect.typedmemmove
-func typedmemmove(t *runtime.Type, dst, src unsafe.Pointer)
-
-func (d *sliceDecoder) errNumber(offset int64) *errors.UnmarshalTypeError {
- return &errors.UnmarshalTypeError{
- Value: "number",
- Type: reflect.SliceOf(runtime.RType2Type(d.elemType)),
- Struct: d.structName,
- Field: d.fieldName,
- Offset: offset,
- }
-}
-
-func (d *sliceDecoder) DecodeStream(s *Stream, depth int64, p unsafe.Pointer) error {
- depth++
- if depth > maxDecodeNestingDepth {
- return errors.ErrExceededMaxDepth(s.char(), s.cursor)
- }
-
- for {
- switch s.char() {
- case ' ', '\n', '\t', '\r':
- s.cursor++
- continue
- case 'n':
- if err := nullBytes(s); err != nil {
- return err
- }
- typedmemmove(sliceType, p, nilSlice)
- return nil
- case '[':
- s.cursor++
- if s.skipWhiteSpace() == ']' {
- dst := (*sliceHeader)(p)
- if dst.data == nil {
- dst.data = newArray(d.elemType, 0)
- } else {
- dst.len = 0
- }
- s.cursor++
- return nil
- }
- idx := 0
- slice := d.newSlice((*sliceHeader)(p))
- srcLen := slice.len
- capacity := slice.cap
- data := slice.data
- for {
- if capacity <= idx {
- src := sliceHeader{data: data, len: idx, cap: capacity}
- capacity *= 2
- data = newArray(d.elemType, capacity)
- dst := sliceHeader{data: data, len: idx, cap: capacity}
- copySlice(d.elemType, dst, src)
- }
- ep := unsafe.Pointer(uintptr(data) + uintptr(idx)*d.size)
-
- // if srcLen is greater than idx, keep the original reference
- if srcLen <= idx {
- if d.isElemPointerType {
- **(**unsafe.Pointer)(unsafe.Pointer(&ep)) = nil // initialize elem pointer
- } else {
- // assign new element to the slice
- typedmemmove(d.elemType, ep, unsafe_New(d.elemType))
- }
- }
-
- if err := d.valueDecoder.DecodeStream(s, depth, ep); err != nil {
- return err
- }
- s.skipWhiteSpace()
- RETRY:
- switch s.char() {
- case ']':
- slice.cap = capacity
- slice.len = idx + 1
- slice.data = data
- dst := (*sliceHeader)(p)
- dst.len = idx + 1
- if dst.len > dst.cap {
- dst.data = newArray(d.elemType, dst.len)
- dst.cap = dst.len
- }
- copySlice(d.elemType, *dst, *slice)
- d.releaseSlice(slice)
- s.cursor++
- return nil
- case ',':
- idx++
- case nul:
- if s.read() {
- goto RETRY
- }
- slice.cap = capacity
- slice.data = data
- d.releaseSlice(slice)
- goto ERROR
- default:
- slice.cap = capacity
- slice.data = data
- d.releaseSlice(slice)
- goto ERROR
- }
- s.cursor++
- }
- case '-', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
- return d.errNumber(s.totalOffset())
- case nul:
- if s.read() {
- continue
- }
- goto ERROR
- default:
- goto ERROR
- }
- }
-ERROR:
- return errors.ErrUnexpectedEndOfJSON("slice", s.totalOffset())
-}
-
-func (d *sliceDecoder) Decode(ctx *RuntimeContext, cursor, depth int64, p unsafe.Pointer) (int64, error) {
- buf := ctx.Buf
- depth++
- if depth > maxDecodeNestingDepth {
- return 0, errors.ErrExceededMaxDepth(buf[cursor], cursor)
- }
-
- for {
- switch buf[cursor] {
- case ' ', '\n', '\t', '\r':
- cursor++
- continue
- case 'n':
- if err := validateNull(buf, cursor); err != nil {
- return 0, err
- }
- cursor += 4
- typedmemmove(sliceType, p, nilSlice)
- return cursor, nil
- case '[':
- cursor++
- cursor = skipWhiteSpace(buf, cursor)
- if buf[cursor] == ']' {
- dst := (*sliceHeader)(p)
- if dst.data == nil {
- dst.data = newArray(d.elemType, 0)
- } else {
- dst.len = 0
- }
- cursor++
- return cursor, nil
- }
- idx := 0
- slice := d.newSlice((*sliceHeader)(p))
- srcLen := slice.len
- capacity := slice.cap
- data := slice.data
- for {
- if capacity <= idx {
- src := sliceHeader{data: data, len: idx, cap: capacity}
- capacity *= 2
- data = newArray(d.elemType, capacity)
- dst := sliceHeader{data: data, len: idx, cap: capacity}
- copySlice(d.elemType, dst, src)
- }
- ep := unsafe.Pointer(uintptr(data) + uintptr(idx)*d.size)
- // if srcLen is greater than idx, keep the original reference
- if srcLen <= idx {
- if d.isElemPointerType {
- **(**unsafe.Pointer)(unsafe.Pointer(&ep)) = nil // initialize elem pointer
- } else {
- // assign new element to the slice
- typedmemmove(d.elemType, ep, unsafe_New(d.elemType))
- }
- }
- c, err := d.valueDecoder.Decode(ctx, cursor, depth, ep)
- if err != nil {
- return 0, err
- }
- cursor = c
- cursor = skipWhiteSpace(buf, cursor)
- switch buf[cursor] {
- case ']':
- slice.cap = capacity
- slice.len = idx + 1
- slice.data = data
- dst := (*sliceHeader)(p)
- dst.len = idx + 1
- if dst.len > dst.cap {
- dst.data = newArray(d.elemType, dst.len)
- dst.cap = dst.len
- }
- copySlice(d.elemType, *dst, *slice)
- d.releaseSlice(slice)
- cursor++
- return cursor, nil
- case ',':
- idx++
- default:
- slice.cap = capacity
- slice.data = data
- d.releaseSlice(slice)
- return 0, errors.ErrInvalidCharacter(buf[cursor], "slice", cursor)
- }
- cursor++
- }
- case '-', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
- return 0, d.errNumber(cursor)
- default:
- return 0, errors.ErrUnexpectedEndOfJSON("slice", cursor)
- }
- }
-}
-
-func (d *sliceDecoder) DecodePath(ctx *RuntimeContext, cursor, depth int64) ([][]byte, int64, error) {
- buf := ctx.Buf
- depth++
- if depth > maxDecodeNestingDepth {
- return nil, 0, errors.ErrExceededMaxDepth(buf[cursor], cursor)
- }
-
- ret := [][]byte{}
- for {
- switch buf[cursor] {
- case ' ', '\n', '\t', '\r':
- cursor++
- continue
- case 'n':
- if err := validateNull(buf, cursor); err != nil {
- return nil, 0, err
- }
- cursor += 4
- return [][]byte{nullbytes}, cursor, nil
- case '[':
- cursor++
- cursor = skipWhiteSpace(buf, cursor)
- if buf[cursor] == ']' {
- cursor++
- return ret, cursor, nil
- }
- idx := 0
- for {
- child, found, err := ctx.Option.Path.node.Index(idx)
- if err != nil {
- return nil, 0, err
- }
- if found {
- if child != nil {
- oldPath := ctx.Option.Path.node
- ctx.Option.Path.node = child
- paths, c, err := d.valueDecoder.DecodePath(ctx, cursor, depth)
- if err != nil {
- return nil, 0, err
- }
- ctx.Option.Path.node = oldPath
- ret = append(ret, paths...)
- cursor = c
- } else {
- start := cursor
- end, err := skipValue(buf, cursor, depth)
- if err != nil {
- return nil, 0, err
- }
- ret = append(ret, buf[start:end])
- cursor = end
- }
- } else {
- c, err := skipValue(buf, cursor, depth)
- if err != nil {
- return nil, 0, err
- }
- cursor = c
- }
- cursor = skipWhiteSpace(buf, cursor)
- switch buf[cursor] {
- case ']':
- cursor++
- return ret, cursor, nil
- case ',':
- idx++
- default:
- return nil, 0, errors.ErrInvalidCharacter(buf[cursor], "slice", cursor)
- }
- cursor++
- }
- case '-', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
- return nil, 0, d.errNumber(cursor)
- default:
- return nil, 0, errors.ErrUnexpectedEndOfJSON("slice", cursor)
- }
- }
-}
diff --git a/vendor/github.com/goccy/go-json/internal/decoder/stream.go b/vendor/github.com/goccy/go-json/internal/decoder/stream.go
deleted file mode 100644
index a383f725..00000000
--- a/vendor/github.com/goccy/go-json/internal/decoder/stream.go
+++ /dev/null
@@ -1,556 +0,0 @@
-package decoder
-
-import (
- "bytes"
- "encoding/json"
- "io"
- "strconv"
- "unsafe"
-
- "github.com/goccy/go-json/internal/errors"
-)
-
-const (
- initBufSize = 512
-)
-
-type Stream struct {
- buf []byte
- bufSize int64
- length int64
- r io.Reader
- offset int64
- cursor int64
- filledBuffer bool
- allRead bool
- UseNumber bool
- DisallowUnknownFields bool
- Option *Option
-}
-
-func NewStream(r io.Reader) *Stream {
- return &Stream{
- r: r,
- bufSize: initBufSize,
- buf: make([]byte, initBufSize),
- Option: &Option{},
- }
-}
-
-func (s *Stream) TotalOffset() int64 {
- return s.totalOffset()
-}
-
-func (s *Stream) Buffered() io.Reader {
- buflen := int64(len(s.buf))
- for i := s.cursor; i < buflen; i++ {
- if s.buf[i] == nul {
- return bytes.NewReader(s.buf[s.cursor:i])
- }
- }
- return bytes.NewReader(s.buf[s.cursor:])
-}
-
-func (s *Stream) PrepareForDecode() error {
- for {
- switch s.char() {
- case ' ', '\t', '\r', '\n':
- s.cursor++
- continue
- case ',', ':':
- s.cursor++
- return nil
- case nul:
- if s.read() {
- continue
- }
- return io.EOF
- }
- break
- }
- return nil
-}
-
-func (s *Stream) totalOffset() int64 {
- return s.offset + s.cursor
-}
-
-func (s *Stream) char() byte {
- return s.buf[s.cursor]
-}
-
-func (s *Stream) equalChar(c byte) bool {
- cur := s.buf[s.cursor]
- if cur == nul {
- s.read()
- cur = s.buf[s.cursor]
- }
- return cur == c
-}
-
-func (s *Stream) stat() ([]byte, int64, unsafe.Pointer) {
- return s.buf, s.cursor, (*sliceHeader)(unsafe.Pointer(&s.buf)).data
-}
-
-func (s *Stream) bufptr() unsafe.Pointer {
- return (*sliceHeader)(unsafe.Pointer(&s.buf)).data
-}
-
-func (s *Stream) statForRetry() ([]byte, int64, unsafe.Pointer) {
- s.cursor-- // for retry ( because caller progress cursor position in each loop )
- return s.buf, s.cursor, (*sliceHeader)(unsafe.Pointer(&s.buf)).data
-}
-
-func (s *Stream) Reset() {
- s.reset()
- s.bufSize = int64(len(s.buf))
-}
-
-func (s *Stream) More() bool {
- for {
- switch s.char() {
- case ' ', '\n', '\r', '\t':
- s.cursor++
- continue
- case '}', ']':
- return false
- case nul:
- if s.read() {
- continue
- }
- return false
- }
- break
- }
- return true
-}
-
-func (s *Stream) Token() (interface{}, error) {
- for {
- c := s.char()
- switch c {
- case ' ', '\n', '\r', '\t':
- s.cursor++
- case '{', '[', ']', '}':
- s.cursor++
- return json.Delim(c), nil
- case ',', ':':
- s.cursor++
- case '-', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
- bytes := floatBytes(s)
- str := *(*string)(unsafe.Pointer(&bytes))
- if s.UseNumber {
- return json.Number(str), nil
- }
- f64, err := strconv.ParseFloat(str, 64)
- if err != nil {
- return nil, err
- }
- return f64, nil
- case '"':
- bytes, err := stringBytes(s)
- if err != nil {
- return nil, err
- }
- return string(bytes), nil
- case 't':
- if err := trueBytes(s); err != nil {
- return nil, err
- }
- return true, nil
- case 'f':
- if err := falseBytes(s); err != nil {
- return nil, err
- }
- return false, nil
- case 'n':
- if err := nullBytes(s); err != nil {
- return nil, err
- }
- return nil, nil
- case nul:
- if s.read() {
- continue
- }
- goto END
- default:
- return nil, errors.ErrInvalidCharacter(s.char(), "token", s.totalOffset())
- }
- }
-END:
- return nil, io.EOF
-}
-
-func (s *Stream) reset() {
- s.offset += s.cursor
- s.buf = s.buf[s.cursor:]
- s.length -= s.cursor
- s.cursor = 0
-}
-
-func (s *Stream) readBuf() []byte {
- if s.filledBuffer {
- s.bufSize *= 2
- remainBuf := s.buf
- s.buf = make([]byte, s.bufSize)
- copy(s.buf, remainBuf)
- }
- remainLen := s.length - s.cursor
- remainNotNulCharNum := int64(0)
- for i := int64(0); i < remainLen; i++ {
- if s.buf[s.cursor+i] == nul {
- break
- }
- remainNotNulCharNum++
- }
- s.length = s.cursor + remainNotNulCharNum
- return s.buf[s.cursor+remainNotNulCharNum:]
-}
-
-func (s *Stream) read() bool {
- if s.allRead {
- return false
- }
- buf := s.readBuf()
- last := len(buf) - 1
- buf[last] = nul
- n, err := s.r.Read(buf[:last])
- s.length += int64(n)
- if n == last {
- s.filledBuffer = true
- } else {
- s.filledBuffer = false
- }
- if err == io.EOF {
- s.allRead = true
- } else if err != nil {
- return false
- }
- return true
-}
-
-func (s *Stream) skipWhiteSpace() byte {
- p := s.bufptr()
-LOOP:
- c := char(p, s.cursor)
- switch c {
- case ' ', '\n', '\t', '\r':
- s.cursor++
- goto LOOP
- case nul:
- if s.read() {
- p = s.bufptr()
- goto LOOP
- }
- }
- return c
-}
-
-func (s *Stream) skipObject(depth int64) error {
- braceCount := 1
- _, cursor, p := s.stat()
- for {
- switch char(p, cursor) {
- case '{':
- braceCount++
- depth++
- if depth > maxDecodeNestingDepth {
- return errors.ErrExceededMaxDepth(s.char(), s.cursor)
- }
- case '}':
- braceCount--
- depth--
- if braceCount == 0 {
- s.cursor = cursor + 1
- return nil
- }
- case '[':
- depth++
- if depth > maxDecodeNestingDepth {
- return errors.ErrExceededMaxDepth(s.char(), s.cursor)
- }
- case ']':
- depth--
- case '"':
- for {
- cursor++
- switch char(p, cursor) {
- case '\\':
- cursor++
- if char(p, cursor) == nul {
- s.cursor = cursor
- if s.read() {
- _, cursor, p = s.stat()
- continue
- }
- return errors.ErrUnexpectedEndOfJSON("string of object", cursor)
- }
- case '"':
- goto SWITCH_OUT
- case nul:
- s.cursor = cursor
- if s.read() {
- _, cursor, p = s.statForRetry()
- continue
- }
- return errors.ErrUnexpectedEndOfJSON("string of object", cursor)
- }
- }
- case nul:
- s.cursor = cursor
- if s.read() {
- _, cursor, p = s.stat()
- continue
- }
- return errors.ErrUnexpectedEndOfJSON("object of object", cursor)
- }
- SWITCH_OUT:
- cursor++
- }
-}
-
-func (s *Stream) skipArray(depth int64) error {
- bracketCount := 1
- _, cursor, p := s.stat()
- for {
- switch char(p, cursor) {
- case '[':
- bracketCount++
- depth++
- if depth > maxDecodeNestingDepth {
- return errors.ErrExceededMaxDepth(s.char(), s.cursor)
- }
- case ']':
- bracketCount--
- depth--
- if bracketCount == 0 {
- s.cursor = cursor + 1
- return nil
- }
- case '{':
- depth++
- if depth > maxDecodeNestingDepth {
- return errors.ErrExceededMaxDepth(s.char(), s.cursor)
- }
- case '}':
- depth--
- case '"':
- for {
- cursor++
- switch char(p, cursor) {
- case '\\':
- cursor++
- if char(p, cursor) == nul {
- s.cursor = cursor
- if s.read() {
- _, cursor, p = s.stat()
- continue
- }
- return errors.ErrUnexpectedEndOfJSON("string of object", cursor)
- }
- case '"':
- goto SWITCH_OUT
- case nul:
- s.cursor = cursor
- if s.read() {
- _, cursor, p = s.statForRetry()
- continue
- }
- return errors.ErrUnexpectedEndOfJSON("string of object", cursor)
- }
- }
- case nul:
- s.cursor = cursor
- if s.read() {
- _, cursor, p = s.stat()
- continue
- }
- return errors.ErrUnexpectedEndOfJSON("array of object", cursor)
- }
- SWITCH_OUT:
- cursor++
- }
-}
-
-func (s *Stream) skipValue(depth int64) error {
- _, cursor, p := s.stat()
- for {
- switch char(p, cursor) {
- case ' ', '\n', '\t', '\r':
- cursor++
- continue
- case nul:
- s.cursor = cursor
- if s.read() {
- _, cursor, p = s.stat()
- continue
- }
- return errors.ErrUnexpectedEndOfJSON("value of object", s.totalOffset())
- case '{':
- s.cursor = cursor + 1
- return s.skipObject(depth + 1)
- case '[':
- s.cursor = cursor + 1
- return s.skipArray(depth + 1)
- case '"':
- for {
- cursor++
- switch char(p, cursor) {
- case '\\':
- cursor++
- if char(p, cursor) == nul {
- s.cursor = cursor
- if s.read() {
- _, cursor, p = s.stat()
- continue
- }
- return errors.ErrUnexpectedEndOfJSON("value of string", s.totalOffset())
- }
- case '"':
- s.cursor = cursor + 1
- return nil
- case nul:
- s.cursor = cursor
- if s.read() {
- _, cursor, p = s.statForRetry()
- continue
- }
- return errors.ErrUnexpectedEndOfJSON("value of string", s.totalOffset())
- }
- }
- case '-', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
- for {
- cursor++
- c := char(p, cursor)
- if floatTable[c] {
- continue
- } else if c == nul {
- if s.read() {
- _, cursor, p = s.stat()
- continue
- }
- }
- s.cursor = cursor
- return nil
- }
- case 't':
- s.cursor = cursor
- if err := trueBytes(s); err != nil {
- return err
- }
- return nil
- case 'f':
- s.cursor = cursor
- if err := falseBytes(s); err != nil {
- return err
- }
- return nil
- case 'n':
- s.cursor = cursor
- if err := nullBytes(s); err != nil {
- return err
- }
- return nil
- }
- cursor++
- }
-}
-
-func nullBytes(s *Stream) error {
- // current cursor's character is 'n'
- s.cursor++
- if s.char() != 'u' {
- if err := retryReadNull(s); err != nil {
- return err
- }
- }
- s.cursor++
- if s.char() != 'l' {
- if err := retryReadNull(s); err != nil {
- return err
- }
- }
- s.cursor++
- if s.char() != 'l' {
- if err := retryReadNull(s); err != nil {
- return err
- }
- }
- s.cursor++
- return nil
-}
-
-func retryReadNull(s *Stream) error {
- if s.char() == nul && s.read() {
- return nil
- }
- return errors.ErrInvalidCharacter(s.char(), "null", s.totalOffset())
-}
-
-func trueBytes(s *Stream) error {
- // current cursor's character is 't'
- s.cursor++
- if s.char() != 'r' {
- if err := retryReadTrue(s); err != nil {
- return err
- }
- }
- s.cursor++
- if s.char() != 'u' {
- if err := retryReadTrue(s); err != nil {
- return err
- }
- }
- s.cursor++
- if s.char() != 'e' {
- if err := retryReadTrue(s); err != nil {
- return err
- }
- }
- s.cursor++
- return nil
-}
-
-func retryReadTrue(s *Stream) error {
- if s.char() == nul && s.read() {
- return nil
- }
- return errors.ErrInvalidCharacter(s.char(), "bool(true)", s.totalOffset())
-}
-
-func falseBytes(s *Stream) error {
- // current cursor's character is 'f'
- s.cursor++
- if s.char() != 'a' {
- if err := retryReadFalse(s); err != nil {
- return err
- }
- }
- s.cursor++
- if s.char() != 'l' {
- if err := retryReadFalse(s); err != nil {
- return err
- }
- }
- s.cursor++
- if s.char() != 's' {
- if err := retryReadFalse(s); err != nil {
- return err
- }
- }
- s.cursor++
- if s.char() != 'e' {
- if err := retryReadFalse(s); err != nil {
- return err
- }
- }
- s.cursor++
- return nil
-}
-
-func retryReadFalse(s *Stream) error {
- if s.char() == nul && s.read() {
- return nil
- }
- return errors.ErrInvalidCharacter(s.char(), "bool(false)", s.totalOffset())
-}
diff --git a/vendor/github.com/goccy/go-json/internal/decoder/string.go b/vendor/github.com/goccy/go-json/internal/decoder/string.go
deleted file mode 100644
index 32602c90..00000000
--- a/vendor/github.com/goccy/go-json/internal/decoder/string.go
+++ /dev/null
@@ -1,452 +0,0 @@
-package decoder
-
-import (
- "bytes"
- "fmt"
- "reflect"
- "unicode"
- "unicode/utf16"
- "unicode/utf8"
- "unsafe"
-
- "github.com/goccy/go-json/internal/errors"
-)
-
-type stringDecoder struct {
- structName string
- fieldName string
-}
-
-func newStringDecoder(structName, fieldName string) *stringDecoder {
- return &stringDecoder{
- structName: structName,
- fieldName: fieldName,
- }
-}
-
-func (d *stringDecoder) errUnmarshalType(typeName string, offset int64) *errors.UnmarshalTypeError {
- return &errors.UnmarshalTypeError{
- Value: typeName,
- Type: reflect.TypeOf(""),
- Offset: offset,
- Struct: d.structName,
- Field: d.fieldName,
- }
-}
-
-func (d *stringDecoder) DecodeStream(s *Stream, depth int64, p unsafe.Pointer) error {
- bytes, err := d.decodeStreamByte(s)
- if err != nil {
- return err
- }
- if bytes == nil {
- return nil
- }
- **(**string)(unsafe.Pointer(&p)) = *(*string)(unsafe.Pointer(&bytes))
- s.reset()
- return nil
-}
-
-func (d *stringDecoder) Decode(ctx *RuntimeContext, cursor, depth int64, p unsafe.Pointer) (int64, error) {
- bytes, c, err := d.decodeByte(ctx.Buf, cursor)
- if err != nil {
- return 0, err
- }
- if bytes == nil {
- return c, nil
- }
- cursor = c
- **(**string)(unsafe.Pointer(&p)) = *(*string)(unsafe.Pointer(&bytes))
- return cursor, nil
-}
-
-func (d *stringDecoder) DecodePath(ctx *RuntimeContext, cursor, depth int64) ([][]byte, int64, error) {
- bytes, c, err := d.decodeByte(ctx.Buf, cursor)
- if err != nil {
- return nil, 0, err
- }
- if bytes == nil {
- return [][]byte{nullbytes}, c, nil
- }
- return [][]byte{bytes}, c, nil
-}
-
-var (
- hexToInt = [256]int{
- '0': 0,
- '1': 1,
- '2': 2,
- '3': 3,
- '4': 4,
- '5': 5,
- '6': 6,
- '7': 7,
- '8': 8,
- '9': 9,
- 'A': 10,
- 'B': 11,
- 'C': 12,
- 'D': 13,
- 'E': 14,
- 'F': 15,
- 'a': 10,
- 'b': 11,
- 'c': 12,
- 'd': 13,
- 'e': 14,
- 'f': 15,
- }
-)
-
-func unicodeToRune(code []byte) rune {
- var r rune
- for i := 0; i < len(code); i++ {
- r = r*16 + rune(hexToInt[code[i]])
- }
- return r
-}
-
-func readAtLeast(s *Stream, n int64, p *unsafe.Pointer) bool {
- for s.cursor+n >= s.length {
- if !s.read() {
- return false
- }
- *p = s.bufptr()
- }
- return true
-}
-
-func decodeUnicodeRune(s *Stream, p unsafe.Pointer) (rune, int64, unsafe.Pointer, error) {
- const defaultOffset = 5
- const surrogateOffset = 11
-
- if !readAtLeast(s, defaultOffset, &p) {
- return rune(0), 0, nil, errors.ErrInvalidCharacter(s.char(), "escaped string", s.totalOffset())
- }
-
- r := unicodeToRune(s.buf[s.cursor+1 : s.cursor+defaultOffset])
- if utf16.IsSurrogate(r) {
- if !readAtLeast(s, surrogateOffset, &p) {
- return unicode.ReplacementChar, defaultOffset, p, nil
- }
- if s.buf[s.cursor+defaultOffset] != '\\' || s.buf[s.cursor+defaultOffset+1] != 'u' {
- return unicode.ReplacementChar, defaultOffset, p, nil
- }
- r2 := unicodeToRune(s.buf[s.cursor+defaultOffset+2 : s.cursor+surrogateOffset])
- if r := utf16.DecodeRune(r, r2); r != unicode.ReplacementChar {
- return r, surrogateOffset, p, nil
- }
- }
- return r, defaultOffset, p, nil
-}
-
-func decodeUnicode(s *Stream, p unsafe.Pointer) (unsafe.Pointer, error) {
- const backSlashAndULen = 2 // length of \u
-
- r, offset, pp, err := decodeUnicodeRune(s, p)
- if err != nil {
- return nil, err
- }
- unicode := []byte(string(r))
- unicodeLen := int64(len(unicode))
- s.buf = append(append(s.buf[:s.cursor-1], unicode...), s.buf[s.cursor+offset:]...)
- unicodeOrgLen := offset - 1
- s.length = s.length - (backSlashAndULen + (unicodeOrgLen - unicodeLen))
- s.cursor = s.cursor - backSlashAndULen + unicodeLen
- return pp, nil
-}
-
-func decodeEscapeString(s *Stream, p unsafe.Pointer) (unsafe.Pointer, error) {
- s.cursor++
-RETRY:
- switch s.buf[s.cursor] {
- case '"':
- s.buf[s.cursor] = '"'
- case '\\':
- s.buf[s.cursor] = '\\'
- case '/':
- s.buf[s.cursor] = '/'
- case 'b':
- s.buf[s.cursor] = '\b'
- case 'f':
- s.buf[s.cursor] = '\f'
- case 'n':
- s.buf[s.cursor] = '\n'
- case 'r':
- s.buf[s.cursor] = '\r'
- case 't':
- s.buf[s.cursor] = '\t'
- case 'u':
- return decodeUnicode(s, p)
- case nul:
- if !s.read() {
- return nil, errors.ErrInvalidCharacter(s.char(), "escaped string", s.totalOffset())
- }
- p = s.bufptr()
- goto RETRY
- default:
- return nil, errors.ErrUnexpectedEndOfJSON("string", s.totalOffset())
- }
- s.buf = append(s.buf[:s.cursor-1], s.buf[s.cursor:]...)
- s.length--
- s.cursor--
- p = s.bufptr()
- return p, nil
-}
-
-var (
- runeErrBytes = []byte(string(utf8.RuneError))
- runeErrBytesLen = int64(len(runeErrBytes))
-)
-
-func stringBytes(s *Stream) ([]byte, error) {
- _, cursor, p := s.stat()
- cursor++ // skip double quote char
- start := cursor
- for {
- switch char(p, cursor) {
- case '\\':
- s.cursor = cursor
- pp, err := decodeEscapeString(s, p)
- if err != nil {
- return nil, err
- }
- p = pp
- cursor = s.cursor
- case '"':
- literal := s.buf[start:cursor]
- cursor++
- s.cursor = cursor
- return literal, nil
- case
- // 0x00 is nul, 0x5c is '\\', 0x22 is '"' .
- 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, // 0x00-0x0F
- 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, // 0x10-0x1F
- 0x20, 0x21 /*0x22,*/, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F, // 0x20-0x2F
- 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0x3F, // 0x30-0x3F
- 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F, // 0x40-0x4F
- 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x5B /*0x5C,*/, 0x5D, 0x5E, 0x5F, // 0x50-0x5F
- 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F, // 0x60-0x6F
- 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x7B, 0x7C, 0x7D, 0x7E, 0x7F: // 0x70-0x7F
- // character is ASCII. skip to next char
- case
- 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F, // 0x80-0x8F
- 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9A, 0x9B, 0x9C, 0x9D, 0x9E, 0x9F, // 0x90-0x9F
- 0xA0, 0xA1, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8, 0xA9, 0xAA, 0xAB, 0xAC, 0xAD, 0xAE, 0xAF, // 0xA0-0xAF
- 0xB0, 0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA, 0xBB, 0xBC, 0xBD, 0xBE, 0xBF, // 0xB0-0xBF
- 0xC0, 0xC1, // 0xC0-0xC1
- 0xF5, 0xF6, 0xF7, 0xF8, 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE, 0xFF: // 0xF5-0xFE
- // character is invalid
- s.buf = append(append(append([]byte{}, s.buf[:cursor]...), runeErrBytes...), s.buf[cursor+1:]...)
- _, _, p = s.stat()
- cursor += runeErrBytesLen
- s.length += runeErrBytesLen
- continue
- case nul:
- s.cursor = cursor
- if s.read() {
- _, cursor, p = s.stat()
- continue
- }
- goto ERROR
- case 0xEF:
- // RuneError is {0xEF, 0xBF, 0xBD}
- if s.buf[cursor+1] == 0xBF && s.buf[cursor+2] == 0xBD {
- // found RuneError: skip
- cursor += 2
- break
- }
- fallthrough
- default:
- // multi bytes character
- if !utf8.FullRune(s.buf[cursor : len(s.buf)-1]) {
- s.cursor = cursor
- if s.read() {
- _, cursor, p = s.stat()
- continue
- }
- goto ERROR
- }
- r, size := utf8.DecodeRune(s.buf[cursor:])
- if r == utf8.RuneError {
- s.buf = append(append(append([]byte{}, s.buf[:cursor]...), runeErrBytes...), s.buf[cursor+1:]...)
- cursor += runeErrBytesLen
- s.length += runeErrBytesLen
- _, _, p = s.stat()
- } else {
- cursor += int64(size)
- }
- continue
- }
- cursor++
- }
-ERROR:
- return nil, errors.ErrUnexpectedEndOfJSON("string", s.totalOffset())
-}
-
-func (d *stringDecoder) decodeStreamByte(s *Stream) ([]byte, error) {
- for {
- switch s.char() {
- case ' ', '\n', '\t', '\r':
- s.cursor++
- continue
- case '[':
- return nil, d.errUnmarshalType("array", s.totalOffset())
- case '{':
- return nil, d.errUnmarshalType("object", s.totalOffset())
- case '-', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
- return nil, d.errUnmarshalType("number", s.totalOffset())
- case '"':
- return stringBytes(s)
- case 'n':
- if err := nullBytes(s); err != nil {
- return nil, err
- }
- return nil, nil
- case nul:
- if s.read() {
- continue
- }
- }
- break
- }
- return nil, errors.ErrInvalidBeginningOfValue(s.char(), s.totalOffset())
-}
-
-func (d *stringDecoder) decodeByte(buf []byte, cursor int64) ([]byte, int64, error) {
- for {
- switch buf[cursor] {
- case ' ', '\n', '\t', '\r':
- cursor++
- case '[':
- return nil, 0, d.errUnmarshalType("array", cursor)
- case '{':
- return nil, 0, d.errUnmarshalType("object", cursor)
- case '-', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
- return nil, 0, d.errUnmarshalType("number", cursor)
- case '"':
- cursor++
- start := cursor
- b := (*sliceHeader)(unsafe.Pointer(&buf)).data
- escaped := 0
- for {
- switch char(b, cursor) {
- case '\\':
- escaped++
- cursor++
- switch char(b, cursor) {
- case '"', '\\', '/', 'b', 'f', 'n', 'r', 't':
- cursor++
- case 'u':
- buflen := int64(len(buf))
- if cursor+5 >= buflen {
- return nil, 0, errors.ErrUnexpectedEndOfJSON("escaped string", cursor)
- }
- for i := int64(1); i <= 4; i++ {
- c := char(b, cursor+i)
- if !(('0' <= c && c <= '9') || ('a' <= c && c <= 'f') || ('A' <= c && c <= 'F')) {
- return nil, 0, errors.ErrSyntax(fmt.Sprintf("json: invalid character %c in \\u hexadecimal character escape", c), cursor+i)
- }
- }
- cursor += 5
- default:
- return nil, 0, errors.ErrUnexpectedEndOfJSON("escaped string", cursor)
- }
- continue
- case '"':
- literal := buf[start:cursor]
- if escaped > 0 {
- literal = literal[:unescapeString(literal)]
- }
- cursor++
- return literal, cursor, nil
- case nul:
- return nil, 0, errors.ErrUnexpectedEndOfJSON("string", cursor)
- }
- cursor++
- }
- case 'n':
- if err := validateNull(buf, cursor); err != nil {
- return nil, 0, err
- }
- cursor += 4
- return nil, cursor, nil
- default:
- return nil, 0, errors.ErrInvalidBeginningOfValue(buf[cursor], cursor)
- }
- }
-}
-
-var unescapeMap = [256]byte{
- '"': '"',
- '\\': '\\',
- '/': '/',
- 'b': '\b',
- 'f': '\f',
- 'n': '\n',
- 'r': '\r',
- 't': '\t',
-}
-
-func unsafeAdd(ptr unsafe.Pointer, offset int) unsafe.Pointer {
- return unsafe.Pointer(uintptr(ptr) + uintptr(offset))
-}
-
-func unescapeString(buf []byte) int {
- p := (*sliceHeader)(unsafe.Pointer(&buf)).data
- end := unsafeAdd(p, len(buf))
- src := unsafeAdd(p, bytes.IndexByte(buf, '\\'))
- dst := src
- for src != end {
- c := char(src, 0)
- if c == '\\' {
- escapeChar := char(src, 1)
- if escapeChar != 'u' {
- *(*byte)(dst) = unescapeMap[escapeChar]
- src = unsafeAdd(src, 2)
- dst = unsafeAdd(dst, 1)
- } else {
- v1 := hexToInt[char(src, 2)]
- v2 := hexToInt[char(src, 3)]
- v3 := hexToInt[char(src, 4)]
- v4 := hexToInt[char(src, 5)]
- code := rune((v1 << 12) | (v2 << 8) | (v3 << 4) | v4)
- if code >= 0xd800 && code < 0xdc00 && uintptr(unsafeAdd(src, 11)) < uintptr(end) {
- if char(src, 6) == '\\' && char(src, 7) == 'u' {
- v1 := hexToInt[char(src, 8)]
- v2 := hexToInt[char(src, 9)]
- v3 := hexToInt[char(src, 10)]
- v4 := hexToInt[char(src, 11)]
- lo := rune((v1 << 12) | (v2 << 8) | (v3 << 4) | v4)
- if lo >= 0xdc00 && lo < 0xe000 {
- code = (code-0xd800)<<10 | (lo - 0xdc00) + 0x10000
- src = unsafeAdd(src, 6)
- }
- }
- }
- var b [utf8.UTFMax]byte
- n := utf8.EncodeRune(b[:], code)
- switch n {
- case 4:
- *(*byte)(unsafeAdd(dst, 3)) = b[3]
- fallthrough
- case 3:
- *(*byte)(unsafeAdd(dst, 2)) = b[2]
- fallthrough
- case 2:
- *(*byte)(unsafeAdd(dst, 1)) = b[1]
- fallthrough
- case 1:
- *(*byte)(unsafeAdd(dst, 0)) = b[0]
- }
- src = unsafeAdd(src, 6)
- dst = unsafeAdd(dst, n)
- }
- } else {
- *(*byte)(dst) = c
- src = unsafeAdd(src, 1)
- dst = unsafeAdd(dst, 1)
- }
- }
- return int(uintptr(dst) - uintptr(p))
-}
diff --git a/vendor/github.com/goccy/go-json/internal/decoder/struct.go b/vendor/github.com/goccy/go-json/internal/decoder/struct.go
deleted file mode 100644
index 313da153..00000000
--- a/vendor/github.com/goccy/go-json/internal/decoder/struct.go
+++ /dev/null
@@ -1,845 +0,0 @@
-package decoder
-
-import (
- "fmt"
- "math"
- "math/bits"
- "sort"
- "strings"
- "unicode"
- "unicode/utf16"
- "unsafe"
-
- "github.com/goccy/go-json/internal/errors"
-)
-
-type structFieldSet struct {
- dec Decoder
- offset uintptr
- isTaggedKey bool
- fieldIdx int
- key string
- keyLen int64
- err error
-}
-
-type structDecoder struct {
- fieldMap map[string]*structFieldSet
- fieldUniqueNameNum int
- stringDecoder *stringDecoder
- structName string
- fieldName string
- isTriedOptimize bool
- keyBitmapUint8 [][256]uint8
- keyBitmapUint16 [][256]uint16
- sortedFieldSets []*structFieldSet
- keyDecoder func(*structDecoder, []byte, int64) (int64, *structFieldSet, error)
- keyStreamDecoder func(*structDecoder, *Stream) (*structFieldSet, string, error)
-}
-
-var (
- largeToSmallTable [256]byte
-)
-
-func init() {
- for i := 0; i < 256; i++ {
- c := i
- if 'A' <= c && c <= 'Z' {
- c += 'a' - 'A'
- }
- largeToSmallTable[i] = byte(c)
- }
-}
-
-func toASCIILower(s string) string {
- b := []byte(s)
- for i := range b {
- b[i] = largeToSmallTable[b[i]]
- }
- return string(b)
-}
-
-func newStructDecoder(structName, fieldName string, fieldMap map[string]*structFieldSet) *structDecoder {
- return &structDecoder{
- fieldMap: fieldMap,
- stringDecoder: newStringDecoder(structName, fieldName),
- structName: structName,
- fieldName: fieldName,
- keyDecoder: decodeKey,
- keyStreamDecoder: decodeKeyStream,
- }
-}
-
-const (
- allowOptimizeMaxKeyLen = 64
- allowOptimizeMaxFieldLen = 16
-)
-
-func (d *structDecoder) tryOptimize() {
- fieldUniqueNameMap := map[string]int{}
- fieldIdx := -1
- for k, v := range d.fieldMap {
- lower := strings.ToLower(k)
- idx, exists := fieldUniqueNameMap[lower]
- if exists {
- v.fieldIdx = idx
- } else {
- fieldIdx++
- v.fieldIdx = fieldIdx
- }
- fieldUniqueNameMap[lower] = fieldIdx
- }
- d.fieldUniqueNameNum = len(fieldUniqueNameMap)
-
- if d.isTriedOptimize {
- return
- }
- fieldMap := map[string]*structFieldSet{}
- conflicted := map[string]struct{}{}
- for k, v := range d.fieldMap {
- key := strings.ToLower(k)
- if key != k {
- if key != toASCIILower(k) {
- d.isTriedOptimize = true
- return
- }
- // already exists same key (e.g. Hello and HELLO has same lower case key
- if _, exists := conflicted[key]; exists {
- d.isTriedOptimize = true
- return
- }
- conflicted[key] = struct{}{}
- }
- if field, exists := fieldMap[key]; exists {
- if field != v {
- d.isTriedOptimize = true
- return
- }
- }
- fieldMap[key] = v
- }
-
- if len(fieldMap) > allowOptimizeMaxFieldLen {
- d.isTriedOptimize = true
- return
- }
-
- var maxKeyLen int
- sortedKeys := []string{}
- for key := range fieldMap {
- keyLen := len(key)
- if keyLen > allowOptimizeMaxKeyLen {
- d.isTriedOptimize = true
- return
- }
- if maxKeyLen < keyLen {
- maxKeyLen = keyLen
- }
- sortedKeys = append(sortedKeys, key)
- }
- sort.Strings(sortedKeys)
-
- // By allocating one extra capacity than `maxKeyLen`,
- // it is possible to avoid the process of comparing the index of the key with the length of the bitmap each time.
- bitmapLen := maxKeyLen + 1
- if len(sortedKeys) <= 8 {
- keyBitmap := make([][256]uint8, bitmapLen)
- for i, key := range sortedKeys {
- for j := 0; j < len(key); j++ {
- c := key[j]
- keyBitmap[j][c] |= (1 << uint(i))
- }
- d.sortedFieldSets = append(d.sortedFieldSets, fieldMap[key])
- }
- d.keyBitmapUint8 = keyBitmap
- d.keyDecoder = decodeKeyByBitmapUint8
- d.keyStreamDecoder = decodeKeyByBitmapUint8Stream
- } else {
- keyBitmap := make([][256]uint16, bitmapLen)
- for i, key := range sortedKeys {
- for j := 0; j < len(key); j++ {
- c := key[j]
- keyBitmap[j][c] |= (1 << uint(i))
- }
- d.sortedFieldSets = append(d.sortedFieldSets, fieldMap[key])
- }
- d.keyBitmapUint16 = keyBitmap
- d.keyDecoder = decodeKeyByBitmapUint16
- d.keyStreamDecoder = decodeKeyByBitmapUint16Stream
- }
-}
-
-// decode from '\uXXXX'
-func decodeKeyCharByUnicodeRune(buf []byte, cursor int64) ([]byte, int64, error) {
- const defaultOffset = 4
- const surrogateOffset = 6
-
- if cursor+defaultOffset >= int64(len(buf)) {
- return nil, 0, errors.ErrUnexpectedEndOfJSON("escaped string", cursor)
- }
-
- r := unicodeToRune(buf[cursor : cursor+defaultOffset])
- if utf16.IsSurrogate(r) {
- cursor += defaultOffset
- if cursor+surrogateOffset >= int64(len(buf)) || buf[cursor] != '\\' || buf[cursor+1] != 'u' {
- return []byte(string(unicode.ReplacementChar)), cursor + defaultOffset - 1, nil
- }
- cursor += 2
- r2 := unicodeToRune(buf[cursor : cursor+defaultOffset])
- if r := utf16.DecodeRune(r, r2); r != unicode.ReplacementChar {
- return []byte(string(r)), cursor + defaultOffset - 1, nil
- }
- }
- return []byte(string(r)), cursor + defaultOffset - 1, nil
-}
-
-func decodeKeyCharByEscapedChar(buf []byte, cursor int64) ([]byte, int64, error) {
- c := buf[cursor]
- cursor++
- switch c {
- case '"':
- return []byte{'"'}, cursor, nil
- case '\\':
- return []byte{'\\'}, cursor, nil
- case '/':
- return []byte{'/'}, cursor, nil
- case 'b':
- return []byte{'\b'}, cursor, nil
- case 'f':
- return []byte{'\f'}, cursor, nil
- case 'n':
- return []byte{'\n'}, cursor, nil
- case 'r':
- return []byte{'\r'}, cursor, nil
- case 't':
- return []byte{'\t'}, cursor, nil
- case 'u':
- return decodeKeyCharByUnicodeRune(buf, cursor)
- }
- return nil, cursor, nil
-}
-
-func decodeKeyByBitmapUint8(d *structDecoder, buf []byte, cursor int64) (int64, *structFieldSet, error) {
- var (
- curBit uint8 = math.MaxUint8
- )
- b := (*sliceHeader)(unsafe.Pointer(&buf)).data
- for {
- switch char(b, cursor) {
- case ' ', '\n', '\t', '\r':
- cursor++
- case '"':
- cursor++
- c := char(b, cursor)
- switch c {
- case '"':
- cursor++
- return cursor, nil, nil
- case nul:
- return 0, nil, errors.ErrUnexpectedEndOfJSON("string", cursor)
- }
- keyIdx := 0
- bitmap := d.keyBitmapUint8
- start := cursor
- for {
- c := char(b, cursor)
- switch c {
- case '"':
- fieldSetIndex := bits.TrailingZeros8(curBit)
- field := d.sortedFieldSets[fieldSetIndex]
- keyLen := cursor - start
- cursor++
- if keyLen < field.keyLen {
- // early match
- return cursor, nil, nil
- }
- return cursor, field, nil
- case nul:
- return 0, nil, errors.ErrUnexpectedEndOfJSON("string", cursor)
- case '\\':
- cursor++
- chars, nextCursor, err := decodeKeyCharByEscapedChar(buf, cursor)
- if err != nil {
- return 0, nil, err
- }
- for _, c := range chars {
- curBit &= bitmap[keyIdx][largeToSmallTable[c]]
- if curBit == 0 {
- return decodeKeyNotFound(b, cursor)
- }
- keyIdx++
- }
- cursor = nextCursor
- default:
- curBit &= bitmap[keyIdx][largeToSmallTable[c]]
- if curBit == 0 {
- return decodeKeyNotFound(b, cursor)
- }
- keyIdx++
- }
- cursor++
- }
- default:
- return cursor, nil, errors.ErrInvalidBeginningOfValue(char(b, cursor), cursor)
- }
- }
-}
-
-func decodeKeyByBitmapUint16(d *structDecoder, buf []byte, cursor int64) (int64, *structFieldSet, error) {
- var (
- curBit uint16 = math.MaxUint16
- )
- b := (*sliceHeader)(unsafe.Pointer(&buf)).data
- for {
- switch char(b, cursor) {
- case ' ', '\n', '\t', '\r':
- cursor++
- case '"':
- cursor++
- c := char(b, cursor)
- switch c {
- case '"':
- cursor++
- return cursor, nil, nil
- case nul:
- return 0, nil, errors.ErrUnexpectedEndOfJSON("string", cursor)
- }
- keyIdx := 0
- bitmap := d.keyBitmapUint16
- start := cursor
- for {
- c := char(b, cursor)
- switch c {
- case '"':
- fieldSetIndex := bits.TrailingZeros16(curBit)
- field := d.sortedFieldSets[fieldSetIndex]
- keyLen := cursor - start
- cursor++
- if keyLen < field.keyLen {
- // early match
- return cursor, nil, nil
- }
- return cursor, field, nil
- case nul:
- return 0, nil, errors.ErrUnexpectedEndOfJSON("string", cursor)
- case '\\':
- cursor++
- chars, nextCursor, err := decodeKeyCharByEscapedChar(buf, cursor)
- if err != nil {
- return 0, nil, err
- }
- for _, c := range chars {
- curBit &= bitmap[keyIdx][largeToSmallTable[c]]
- if curBit == 0 {
- return decodeKeyNotFound(b, cursor)
- }
- keyIdx++
- }
- cursor = nextCursor
- default:
- curBit &= bitmap[keyIdx][largeToSmallTable[c]]
- if curBit == 0 {
- return decodeKeyNotFound(b, cursor)
- }
- keyIdx++
- }
- cursor++
- }
- default:
- return cursor, nil, errors.ErrInvalidBeginningOfValue(char(b, cursor), cursor)
- }
- }
-}
-
-func decodeKeyNotFound(b unsafe.Pointer, cursor int64) (int64, *structFieldSet, error) {
- for {
- cursor++
- switch char(b, cursor) {
- case '"':
- cursor++
- return cursor, nil, nil
- case '\\':
- cursor++
- if char(b, cursor) == nul {
- return 0, nil, errors.ErrUnexpectedEndOfJSON("string", cursor)
- }
- case nul:
- return 0, nil, errors.ErrUnexpectedEndOfJSON("string", cursor)
- }
- }
-}
-
-func decodeKey(d *structDecoder, buf []byte, cursor int64) (int64, *structFieldSet, error) {
- key, c, err := d.stringDecoder.decodeByte(buf, cursor)
- if err != nil {
- return 0, nil, err
- }
- cursor = c
- k := *(*string)(unsafe.Pointer(&key))
- field, exists := d.fieldMap[k]
- if !exists {
- return cursor, nil, nil
- }
- return cursor, field, nil
-}
-
-func decodeKeyByBitmapUint8Stream(d *structDecoder, s *Stream) (*structFieldSet, string, error) {
- var (
- curBit uint8 = math.MaxUint8
- )
- _, cursor, p := s.stat()
- for {
- switch char(p, cursor) {
- case ' ', '\n', '\t', '\r':
- cursor++
- case nul:
- s.cursor = cursor
- if s.read() {
- _, cursor, p = s.stat()
- continue
- }
- return nil, "", errors.ErrInvalidBeginningOfValue(char(p, cursor), s.totalOffset())
- case '"':
- cursor++
- FIRST_CHAR:
- start := cursor
- switch char(p, cursor) {
- case '"':
- cursor++
- s.cursor = cursor
- return nil, "", nil
- case nul:
- s.cursor = cursor
- if s.read() {
- _, cursor, p = s.stat()
- goto FIRST_CHAR
- }
- return nil, "", errors.ErrUnexpectedEndOfJSON("string", s.totalOffset())
- }
- keyIdx := 0
- bitmap := d.keyBitmapUint8
- for {
- c := char(p, cursor)
- switch c {
- case '"':
- fieldSetIndex := bits.TrailingZeros8(curBit)
- field := d.sortedFieldSets[fieldSetIndex]
- keyLen := cursor - start
- cursor++
- s.cursor = cursor
- if keyLen < field.keyLen {
- // early match
- return nil, field.key, nil
- }
- return field, field.key, nil
- case nul:
- s.cursor = cursor
- if s.read() {
- _, cursor, p = s.stat()
- continue
- }
- return nil, "", errors.ErrUnexpectedEndOfJSON("string", s.totalOffset())
- case '\\':
- s.cursor = cursor + 1 // skip '\' char
- chars, err := decodeKeyCharByEscapeCharStream(s)
- if err != nil {
- return nil, "", err
- }
- cursor = s.cursor
- for _, c := range chars {
- curBit &= bitmap[keyIdx][largeToSmallTable[c]]
- if curBit == 0 {
- s.cursor = cursor
- return decodeKeyNotFoundStream(s, start)
- }
- keyIdx++
- }
- default:
- curBit &= bitmap[keyIdx][largeToSmallTable[c]]
- if curBit == 0 {
- s.cursor = cursor
- return decodeKeyNotFoundStream(s, start)
- }
- keyIdx++
- }
- cursor++
- }
- default:
- return nil, "", errors.ErrInvalidBeginningOfValue(char(p, cursor), s.totalOffset())
- }
- }
-}
-
-func decodeKeyByBitmapUint16Stream(d *structDecoder, s *Stream) (*structFieldSet, string, error) {
- var (
- curBit uint16 = math.MaxUint16
- )
- _, cursor, p := s.stat()
- for {
- switch char(p, cursor) {
- case ' ', '\n', '\t', '\r':
- cursor++
- case nul:
- s.cursor = cursor
- if s.read() {
- _, cursor, p = s.stat()
- continue
- }
- return nil, "", errors.ErrInvalidBeginningOfValue(char(p, cursor), s.totalOffset())
- case '"':
- cursor++
- FIRST_CHAR:
- start := cursor
- switch char(p, cursor) {
- case '"':
- cursor++
- s.cursor = cursor
- return nil, "", nil
- case nul:
- s.cursor = cursor
- if s.read() {
- _, cursor, p = s.stat()
- goto FIRST_CHAR
- }
- return nil, "", errors.ErrUnexpectedEndOfJSON("string", s.totalOffset())
- }
- keyIdx := 0
- bitmap := d.keyBitmapUint16
- for {
- c := char(p, cursor)
- switch c {
- case '"':
- fieldSetIndex := bits.TrailingZeros16(curBit)
- field := d.sortedFieldSets[fieldSetIndex]
- keyLen := cursor - start
- cursor++
- s.cursor = cursor
- if keyLen < field.keyLen {
- // early match
- return nil, field.key, nil
- }
- return field, field.key, nil
- case nul:
- s.cursor = cursor
- if s.read() {
- _, cursor, p = s.stat()
- continue
- }
- return nil, "", errors.ErrUnexpectedEndOfJSON("string", s.totalOffset())
- case '\\':
- s.cursor = cursor + 1 // skip '\' char
- chars, err := decodeKeyCharByEscapeCharStream(s)
- if err != nil {
- return nil, "", err
- }
- cursor = s.cursor
- for _, c := range chars {
- curBit &= bitmap[keyIdx][largeToSmallTable[c]]
- if curBit == 0 {
- s.cursor = cursor
- return decodeKeyNotFoundStream(s, start)
- }
- keyIdx++
- }
- default:
- curBit &= bitmap[keyIdx][largeToSmallTable[c]]
- if curBit == 0 {
- s.cursor = cursor
- return decodeKeyNotFoundStream(s, start)
- }
- keyIdx++
- }
- cursor++
- }
- default:
- return nil, "", errors.ErrInvalidBeginningOfValue(char(p, cursor), s.totalOffset())
- }
- }
-}
-
-// decode from '\uXXXX'
-func decodeKeyCharByUnicodeRuneStream(s *Stream) ([]byte, error) {
- const defaultOffset = 4
- const surrogateOffset = 6
-
- if s.cursor+defaultOffset >= s.length {
- if !s.read() {
- return nil, errors.ErrInvalidCharacter(s.char(), "escaped unicode char", s.totalOffset())
- }
- }
-
- r := unicodeToRune(s.buf[s.cursor : s.cursor+defaultOffset])
- if utf16.IsSurrogate(r) {
- s.cursor += defaultOffset
- if s.cursor+surrogateOffset >= s.length {
- s.read()
- }
- if s.cursor+surrogateOffset >= s.length || s.buf[s.cursor] != '\\' || s.buf[s.cursor+1] != 'u' {
- s.cursor += defaultOffset - 1
- return []byte(string(unicode.ReplacementChar)), nil
- }
- r2 := unicodeToRune(s.buf[s.cursor+defaultOffset+2 : s.cursor+surrogateOffset])
- if r := utf16.DecodeRune(r, r2); r != unicode.ReplacementChar {
- s.cursor += defaultOffset - 1
- return []byte(string(r)), nil
- }
- }
- s.cursor += defaultOffset - 1
- return []byte(string(r)), nil
-}
-
-func decodeKeyCharByEscapeCharStream(s *Stream) ([]byte, error) {
- c := s.buf[s.cursor]
- s.cursor++
-RETRY:
- switch c {
- case '"':
- return []byte{'"'}, nil
- case '\\':
- return []byte{'\\'}, nil
- case '/':
- return []byte{'/'}, nil
- case 'b':
- return []byte{'\b'}, nil
- case 'f':
- return []byte{'\f'}, nil
- case 'n':
- return []byte{'\n'}, nil
- case 'r':
- return []byte{'\r'}, nil
- case 't':
- return []byte{'\t'}, nil
- case 'u':
- return decodeKeyCharByUnicodeRuneStream(s)
- case nul:
- if !s.read() {
- return nil, errors.ErrInvalidCharacter(s.char(), "escaped char", s.totalOffset())
- }
- goto RETRY
- default:
- return nil, errors.ErrUnexpectedEndOfJSON("struct field", s.totalOffset())
- }
-}
-
-func decodeKeyNotFoundStream(s *Stream, start int64) (*structFieldSet, string, error) {
- buf, cursor, p := s.stat()
- for {
- cursor++
- switch char(p, cursor) {
- case '"':
- b := buf[start:cursor]
- key := *(*string)(unsafe.Pointer(&b))
- cursor++
- s.cursor = cursor
- return nil, key, nil
- case '\\':
- cursor++
- if char(p, cursor) == nul {
- s.cursor = cursor
- if !s.read() {
- return nil, "", errors.ErrUnexpectedEndOfJSON("string", s.totalOffset())
- }
- buf, cursor, p = s.statForRetry()
- }
- case nul:
- s.cursor = cursor
- if !s.read() {
- return nil, "", errors.ErrUnexpectedEndOfJSON("string", s.totalOffset())
- }
- buf, cursor, p = s.statForRetry()
- }
- }
-}
-
-func decodeKeyStream(d *structDecoder, s *Stream) (*structFieldSet, string, error) {
- key, err := d.stringDecoder.decodeStreamByte(s)
- if err != nil {
- return nil, "", err
- }
- k := *(*string)(unsafe.Pointer(&key))
- return d.fieldMap[k], k, nil
-}
-
-func (d *structDecoder) DecodeStream(s *Stream, depth int64, p unsafe.Pointer) error {
- depth++
- if depth > maxDecodeNestingDepth {
- return errors.ErrExceededMaxDepth(s.char(), s.cursor)
- }
-
- c := s.skipWhiteSpace()
- switch c {
- case 'n':
- if err := nullBytes(s); err != nil {
- return err
- }
- return nil
- default:
- if s.char() != '{' {
- return errors.ErrInvalidBeginningOfValue(s.char(), s.totalOffset())
- }
- }
- s.cursor++
- if s.skipWhiteSpace() == '}' {
- s.cursor++
- return nil
- }
- var (
- seenFields map[int]struct{}
- seenFieldNum int
- )
- firstWin := (s.Option.Flags & FirstWinOption) != 0
- if firstWin {
- seenFields = make(map[int]struct{}, d.fieldUniqueNameNum)
- }
- for {
- s.reset()
- field, key, err := d.keyStreamDecoder(d, s)
- if err != nil {
- return err
- }
- if s.skipWhiteSpace() != ':' {
- return errors.ErrExpected("colon after object key", s.totalOffset())
- }
- s.cursor++
- if field != nil {
- if field.err != nil {
- return field.err
- }
- if firstWin {
- if _, exists := seenFields[field.fieldIdx]; exists {
- if err := s.skipValue(depth); err != nil {
- return err
- }
- } else {
- if err := field.dec.DecodeStream(s, depth, unsafe.Pointer(uintptr(p)+field.offset)); err != nil {
- return err
- }
- seenFieldNum++
- if d.fieldUniqueNameNum <= seenFieldNum {
- return s.skipObject(depth)
- }
- seenFields[field.fieldIdx] = struct{}{}
- }
- } else {
- if err := field.dec.DecodeStream(s, depth, unsafe.Pointer(uintptr(p)+field.offset)); err != nil {
- return err
- }
- }
- } else if s.DisallowUnknownFields {
- return fmt.Errorf("json: unknown field %q", key)
- } else {
- if err := s.skipValue(depth); err != nil {
- return err
- }
- }
- c := s.skipWhiteSpace()
- if c == '}' {
- s.cursor++
- return nil
- }
- if c != ',' {
- return errors.ErrExpected("comma after object element", s.totalOffset())
- }
- s.cursor++
- }
-}
-
-func (d *structDecoder) Decode(ctx *RuntimeContext, cursor, depth int64, p unsafe.Pointer) (int64, error) {
- buf := ctx.Buf
- depth++
- if depth > maxDecodeNestingDepth {
- return 0, errors.ErrExceededMaxDepth(buf[cursor], cursor)
- }
- buflen := int64(len(buf))
- cursor = skipWhiteSpace(buf, cursor)
- b := (*sliceHeader)(unsafe.Pointer(&buf)).data
- switch char(b, cursor) {
- case 'n':
- if err := validateNull(buf, cursor); err != nil {
- return 0, err
- }
- cursor += 4
- return cursor, nil
- case '{':
- default:
- return 0, errors.ErrInvalidBeginningOfValue(char(b, cursor), cursor)
- }
- cursor++
- cursor = skipWhiteSpace(buf, cursor)
- if buf[cursor] == '}' {
- cursor++
- return cursor, nil
- }
- var (
- seenFields map[int]struct{}
- seenFieldNum int
- )
- firstWin := (ctx.Option.Flags & FirstWinOption) != 0
- if firstWin {
- seenFields = make(map[int]struct{}, d.fieldUniqueNameNum)
- }
- for {
- c, field, err := d.keyDecoder(d, buf, cursor)
- if err != nil {
- return 0, err
- }
- cursor = skipWhiteSpace(buf, c)
- if char(b, cursor) != ':' {
- return 0, errors.ErrExpected("colon after object key", cursor)
- }
- cursor++
- if cursor >= buflen {
- return 0, errors.ErrExpected("object value after colon", cursor)
- }
- if field != nil {
- if field.err != nil {
- return 0, field.err
- }
- if firstWin {
- if _, exists := seenFields[field.fieldIdx]; exists {
- c, err := skipValue(buf, cursor, depth)
- if err != nil {
- return 0, err
- }
- cursor = c
- } else {
- c, err := field.dec.Decode(ctx, cursor, depth, unsafe.Pointer(uintptr(p)+field.offset))
- if err != nil {
- return 0, err
- }
- cursor = c
- seenFieldNum++
- if d.fieldUniqueNameNum <= seenFieldNum {
- return skipObject(buf, cursor, depth)
- }
- seenFields[field.fieldIdx] = struct{}{}
- }
- } else {
- c, err := field.dec.Decode(ctx, cursor, depth, unsafe.Pointer(uintptr(p)+field.offset))
- if err != nil {
- return 0, err
- }
- cursor = c
- }
- } else {
- c, err := skipValue(buf, cursor, depth)
- if err != nil {
- return 0, err
- }
- cursor = c
- }
- cursor = skipWhiteSpace(buf, cursor)
- if char(b, cursor) == '}' {
- cursor++
- return cursor, nil
- }
- if char(b, cursor) != ',' {
- return 0, errors.ErrExpected("comma after object element", cursor)
- }
- cursor++
- }
-}
-
-func (d *structDecoder) DecodePath(ctx *RuntimeContext, cursor, depth int64) ([][]byte, int64, error) {
- return nil, 0, fmt.Errorf("json: struct decoder does not support decode path")
-}
diff --git a/vendor/github.com/goccy/go-json/internal/decoder/type.go b/vendor/github.com/goccy/go-json/internal/decoder/type.go
deleted file mode 100644
index beaf3ab8..00000000
--- a/vendor/github.com/goccy/go-json/internal/decoder/type.go
+++ /dev/null
@@ -1,30 +0,0 @@
-package decoder
-
-import (
- "context"
- "encoding"
- "encoding/json"
- "reflect"
- "unsafe"
-)
-
-type Decoder interface {
- Decode(*RuntimeContext, int64, int64, unsafe.Pointer) (int64, error)
- DecodePath(*RuntimeContext, int64, int64) ([][]byte, int64, error)
- DecodeStream(*Stream, int64, unsafe.Pointer) error
-}
-
-const (
- nul = '\000'
- maxDecodeNestingDepth = 10000
-)
-
-type unmarshalerContext interface {
- UnmarshalJSON(context.Context, []byte) error
-}
-
-var (
- unmarshalJSONType = reflect.TypeOf((*json.Unmarshaler)(nil)).Elem()
- unmarshalJSONContextType = reflect.TypeOf((*unmarshalerContext)(nil)).Elem()
- unmarshalTextType = reflect.TypeOf((*encoding.TextUnmarshaler)(nil)).Elem()
-)
diff --git a/vendor/github.com/goccy/go-json/internal/decoder/uint.go b/vendor/github.com/goccy/go-json/internal/decoder/uint.go
deleted file mode 100644
index 4131731b..00000000
--- a/vendor/github.com/goccy/go-json/internal/decoder/uint.go
+++ /dev/null
@@ -1,194 +0,0 @@
-package decoder
-
-import (
- "fmt"
- "reflect"
- "unsafe"
-
- "github.com/goccy/go-json/internal/errors"
- "github.com/goccy/go-json/internal/runtime"
-)
-
-type uintDecoder struct {
- typ *runtime.Type
- kind reflect.Kind
- op func(unsafe.Pointer, uint64)
- structName string
- fieldName string
-}
-
-func newUintDecoder(typ *runtime.Type, structName, fieldName string, op func(unsafe.Pointer, uint64)) *uintDecoder {
- return &uintDecoder{
- typ: typ,
- kind: typ.Kind(),
- op: op,
- structName: structName,
- fieldName: fieldName,
- }
-}
-
-func (d *uintDecoder) typeError(buf []byte, offset int64) *errors.UnmarshalTypeError {
- return &errors.UnmarshalTypeError{
- Value: fmt.Sprintf("number %s", string(buf)),
- Type: runtime.RType2Type(d.typ),
- Offset: offset,
- }
-}
-
-var (
- pow10u64 = [...]uint64{
- 1e00, 1e01, 1e02, 1e03, 1e04, 1e05, 1e06, 1e07, 1e08, 1e09,
- 1e10, 1e11, 1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19,
- }
- pow10u64Len = len(pow10u64)
-)
-
-func (d *uintDecoder) parseUint(b []byte) (uint64, error) {
- maxDigit := len(b)
- if maxDigit > pow10u64Len {
- return 0, fmt.Errorf("invalid length of number")
- }
- sum := uint64(0)
- for i := 0; i < maxDigit; i++ {
- c := uint64(b[i]) - 48
- digitValue := pow10u64[maxDigit-i-1]
- sum += c * digitValue
- }
- return sum, nil
-}
-
-func (d *uintDecoder) decodeStreamByte(s *Stream) ([]byte, error) {
- for {
- switch s.char() {
- case ' ', '\n', '\t', '\r':
- s.cursor++
- continue
- case '0':
- s.cursor++
- return numZeroBuf, nil
- case '1', '2', '3', '4', '5', '6', '7', '8', '9':
- start := s.cursor
- for {
- s.cursor++
- if numTable[s.char()] {
- continue
- } else if s.char() == nul {
- if s.read() {
- s.cursor-- // for retry current character
- continue
- }
- }
- break
- }
- num := s.buf[start:s.cursor]
- return num, nil
- case 'n':
- if err := nullBytes(s); err != nil {
- return nil, err
- }
- return nil, nil
- case nul:
- if s.read() {
- continue
- }
- default:
- return nil, d.typeError([]byte{s.char()}, s.totalOffset())
- }
- break
- }
- return nil, errors.ErrUnexpectedEndOfJSON("number(unsigned integer)", s.totalOffset())
-}
-
-func (d *uintDecoder) decodeByte(buf []byte, cursor int64) ([]byte, int64, error) {
- for {
- switch buf[cursor] {
- case ' ', '\n', '\t', '\r':
- cursor++
- continue
- case '0':
- cursor++
- return numZeroBuf, cursor, nil
- case '1', '2', '3', '4', '5', '6', '7', '8', '9':
- start := cursor
- cursor++
- for numTable[buf[cursor]] {
- cursor++
- }
- num := buf[start:cursor]
- return num, cursor, nil
- case 'n':
- if err := validateNull(buf, cursor); err != nil {
- return nil, 0, err
- }
- cursor += 4
- return nil, cursor, nil
- default:
- return nil, 0, d.typeError([]byte{buf[cursor]}, cursor)
- }
- }
-}
-
-func (d *uintDecoder) DecodeStream(s *Stream, depth int64, p unsafe.Pointer) error {
- bytes, err := d.decodeStreamByte(s)
- if err != nil {
- return err
- }
- if bytes == nil {
- return nil
- }
- u64, err := d.parseUint(bytes)
- if err != nil {
- return d.typeError(bytes, s.totalOffset())
- }
- switch d.kind {
- case reflect.Uint8:
- if (1 << 8) <= u64 {
- return d.typeError(bytes, s.totalOffset())
- }
- case reflect.Uint16:
- if (1 << 16) <= u64 {
- return d.typeError(bytes, s.totalOffset())
- }
- case reflect.Uint32:
- if (1 << 32) <= u64 {
- return d.typeError(bytes, s.totalOffset())
- }
- }
- d.op(p, u64)
- return nil
-}
-
-func (d *uintDecoder) Decode(ctx *RuntimeContext, cursor, depth int64, p unsafe.Pointer) (int64, error) {
- bytes, c, err := d.decodeByte(ctx.Buf, cursor)
- if err != nil {
- return 0, err
- }
- if bytes == nil {
- return c, nil
- }
- cursor = c
- u64, err := d.parseUint(bytes)
- if err != nil {
- return 0, d.typeError(bytes, cursor)
- }
- switch d.kind {
- case reflect.Uint8:
- if (1 << 8) <= u64 {
- return 0, d.typeError(bytes, cursor)
- }
- case reflect.Uint16:
- if (1 << 16) <= u64 {
- return 0, d.typeError(bytes, cursor)
- }
- case reflect.Uint32:
- if (1 << 32) <= u64 {
- return 0, d.typeError(bytes, cursor)
- }
- }
- d.op(p, u64)
- return cursor, nil
-}
-
-func (d *uintDecoder) DecodePath(ctx *RuntimeContext, cursor, depth int64) ([][]byte, int64, error) {
- return nil, 0, fmt.Errorf("json: uint decoder does not support decode path")
-}
diff --git a/vendor/github.com/goccy/go-json/internal/decoder/unmarshal_json.go b/vendor/github.com/goccy/go-json/internal/decoder/unmarshal_json.go
deleted file mode 100644
index 4cd6dbd5..00000000
--- a/vendor/github.com/goccy/go-json/internal/decoder/unmarshal_json.go
+++ /dev/null
@@ -1,104 +0,0 @@
-package decoder
-
-import (
- "context"
- "encoding/json"
- "fmt"
- "unsafe"
-
- "github.com/goccy/go-json/internal/errors"
- "github.com/goccy/go-json/internal/runtime"
-)
-
-type unmarshalJSONDecoder struct {
- typ *runtime.Type
- structName string
- fieldName string
-}
-
-func newUnmarshalJSONDecoder(typ *runtime.Type, structName, fieldName string) *unmarshalJSONDecoder {
- return &unmarshalJSONDecoder{
- typ: typ,
- structName: structName,
- fieldName: fieldName,
- }
-}
-
-func (d *unmarshalJSONDecoder) annotateError(cursor int64, err error) {
- switch e := err.(type) {
- case *errors.UnmarshalTypeError:
- e.Struct = d.structName
- e.Field = d.fieldName
- case *errors.SyntaxError:
- e.Offset = cursor
- }
-}
-
-func (d *unmarshalJSONDecoder) DecodeStream(s *Stream, depth int64, p unsafe.Pointer) error {
- s.skipWhiteSpace()
- start := s.cursor
- if err := s.skipValue(depth); err != nil {
- return err
- }
- src := s.buf[start:s.cursor]
- dst := make([]byte, len(src))
- copy(dst, src)
-
- v := *(*interface{})(unsafe.Pointer(&emptyInterface{
- typ: d.typ,
- ptr: p,
- }))
- switch v := v.(type) {
- case unmarshalerContext:
- var ctx context.Context
- if (s.Option.Flags & ContextOption) != 0 {
- ctx = s.Option.Context
- } else {
- ctx = context.Background()
- }
- if err := v.UnmarshalJSON(ctx, dst); err != nil {
- d.annotateError(s.cursor, err)
- return err
- }
- case json.Unmarshaler:
- if err := v.UnmarshalJSON(dst); err != nil {
- d.annotateError(s.cursor, err)
- return err
- }
- }
- return nil
-}
-
-func (d *unmarshalJSONDecoder) Decode(ctx *RuntimeContext, cursor, depth int64, p unsafe.Pointer) (int64, error) {
- buf := ctx.Buf
- cursor = skipWhiteSpace(buf, cursor)
- start := cursor
- end, err := skipValue(buf, cursor, depth)
- if err != nil {
- return 0, err
- }
- src := buf[start:end]
- dst := make([]byte, len(src))
- copy(dst, src)
-
- v := *(*interface{})(unsafe.Pointer(&emptyInterface{
- typ: d.typ,
- ptr: p,
- }))
- if (ctx.Option.Flags & ContextOption) != 0 {
- if err := v.(unmarshalerContext).UnmarshalJSON(ctx.Option.Context, dst); err != nil {
- d.annotateError(cursor, err)
- return 0, err
- }
- } else {
- if err := v.(json.Unmarshaler).UnmarshalJSON(dst); err != nil {
- d.annotateError(cursor, err)
- return 0, err
- }
- }
- return end, nil
-}
-
-func (d *unmarshalJSONDecoder) DecodePath(ctx *RuntimeContext, cursor, depth int64) ([][]byte, int64, error) {
- return nil, 0, fmt.Errorf("json: unmarshal json decoder does not support decode path")
-}
diff --git a/vendor/github.com/goccy/go-json/internal/decoder/unmarshal_text.go b/vendor/github.com/goccy/go-json/internal/decoder/unmarshal_text.go
deleted file mode 100644
index d711d0f8..00000000
--- a/vendor/github.com/goccy/go-json/internal/decoder/unmarshal_text.go
+++ /dev/null
@@ -1,285 +0,0 @@
-package decoder
-
-import (
- "bytes"
- "encoding"
- "fmt"
- "unicode"
- "unicode/utf16"
- "unicode/utf8"
- "unsafe"
-
- "github.com/goccy/go-json/internal/errors"
- "github.com/goccy/go-json/internal/runtime"
-)
-
-type unmarshalTextDecoder struct {
- typ *runtime.Type
- structName string
- fieldName string
-}
-
-func newUnmarshalTextDecoder(typ *runtime.Type, structName, fieldName string) *unmarshalTextDecoder {
- return &unmarshalTextDecoder{
- typ: typ,
- structName: structName,
- fieldName: fieldName,
- }
-}
-
-func (d *unmarshalTextDecoder) annotateError(cursor int64, err error) {
- switch e := err.(type) {
- case *errors.UnmarshalTypeError:
- e.Struct = d.structName
- e.Field = d.fieldName
- case *errors.SyntaxError:
- e.Offset = cursor
- }
-}
-
-var (
- nullbytes = []byte(`null`)
-)
-
-func (d *unmarshalTextDecoder) DecodeStream(s *Stream, depth int64, p unsafe.Pointer) error {
- s.skipWhiteSpace()
- start := s.cursor
- if err := s.skipValue(depth); err != nil {
- return err
- }
- src := s.buf[start:s.cursor]
- if len(src) > 0 {
- switch src[0] {
- case '[':
- return &errors.UnmarshalTypeError{
- Value: "array",
- Type: runtime.RType2Type(d.typ),
- Offset: s.totalOffset(),
- }
- case '{':
- return &errors.UnmarshalTypeError{
- Value: "object",
- Type: runtime.RType2Type(d.typ),
- Offset: s.totalOffset(),
- }
- case '-', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
- return &errors.UnmarshalTypeError{
- Value: "number",
- Type: runtime.RType2Type(d.typ),
- Offset: s.totalOffset(),
- }
- case 'n':
- if bytes.Equal(src, nullbytes) {
- *(*unsafe.Pointer)(p) = nil
- return nil
- }
- }
- }
- dst := make([]byte, len(src))
- copy(dst, src)
-
- if b, ok := unquoteBytes(dst); ok {
- dst = b
- }
- v := *(*interface{})(unsafe.Pointer(&emptyInterface{
- typ: d.typ,
- ptr: p,
- }))
- if err := v.(encoding.TextUnmarshaler).UnmarshalText(dst); err != nil {
- d.annotateError(s.cursor, err)
- return err
- }
- return nil
-}
-
-func (d *unmarshalTextDecoder) Decode(ctx *RuntimeContext, cursor, depth int64, p unsafe.Pointer) (int64, error) {
- buf := ctx.Buf
- cursor = skipWhiteSpace(buf, cursor)
- start := cursor
- end, err := skipValue(buf, cursor, depth)
- if err != nil {
- return 0, err
- }
- src := buf[start:end]
- if len(src) > 0 {
- switch src[0] {
- case '[':
- return 0, &errors.UnmarshalTypeError{
- Value: "array",
- Type: runtime.RType2Type(d.typ),
- Offset: start,
- }
- case '{':
- return 0, &errors.UnmarshalTypeError{
- Value: "object",
- Type: runtime.RType2Type(d.typ),
- Offset: start,
- }
- case '-', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
- return 0, &errors.UnmarshalTypeError{
- Value: "number",
- Type: runtime.RType2Type(d.typ),
- Offset: start,
- }
- case 'n':
- if bytes.Equal(src, nullbytes) {
- *(*unsafe.Pointer)(p) = nil
- return end, nil
- }
- }
- }
-
- if s, ok := unquoteBytes(src); ok {
- src = s
- }
- v := *(*interface{})(unsafe.Pointer(&emptyInterface{
- typ: d.typ,
- ptr: *(*unsafe.Pointer)(unsafe.Pointer(&p)),
- }))
- if err := v.(encoding.TextUnmarshaler).UnmarshalText(src); err != nil {
- d.annotateError(cursor, err)
- return 0, err
- }
- return end, nil
-}
-
-func (d *unmarshalTextDecoder) DecodePath(ctx *RuntimeContext, cursor, depth int64) ([][]byte, int64, error) {
- return nil, 0, fmt.Errorf("json: unmarshal text decoder does not support decode path")
-}
-
-func unquoteBytes(s []byte) (t []byte, ok bool) { //nolint: nonamedreturns
- length := len(s)
- if length < 2 || s[0] != '"' || s[length-1] != '"' {
- return
- }
- s = s[1 : length-1]
- length -= 2
-
- // Check for unusual characters. If there are none,
- // then no unquoting is needed, so return a slice of the
- // original bytes.
- r := 0
- for r < length {
- c := s[r]
- if c == '\\' || c == '"' || c < ' ' {
- break
- }
- if c < utf8.RuneSelf {
- r++
- continue
- }
- rr, size := utf8.DecodeRune(s[r:])
- if rr == utf8.RuneError && size == 1 {
- break
- }
- r += size
- }
- if r == length {
- return s, true
- }
-
- b := make([]byte, length+2*utf8.UTFMax)
- w := copy(b, s[0:r])
- for r < length {
- // Out of room? Can only happen if s is full of
- // malformed UTF-8 and we're replacing each
- // byte with RuneError.
- if w >= len(b)-2*utf8.UTFMax {
- nb := make([]byte, (len(b)+utf8.UTFMax)*2)
- copy(nb, b[0:w])
- b = nb
- }
- switch c := s[r]; {
- case c == '\\':
- r++
- if r >= length {
- return
- }
- switch s[r] {
- default:
- return
- case '"', '\\', '/', '\'':
- b[w] = s[r]
- r++
- w++
- case 'b':
- b[w] = '\b'
- r++
- w++
- case 'f':
- b[w] = '\f'
- r++
- w++
- case 'n':
- b[w] = '\n'
- r++
- w++
- case 'r':
- b[w] = '\r'
- r++
- w++
- case 't':
- b[w] = '\t'
- r++
- w++
- case 'u':
- r--
- rr := getu4(s[r:])
- if rr < 0 {
- return
- }
- r += 6
- if utf16.IsSurrogate(rr) {
- rr1 := getu4(s[r:])
- if dec := utf16.DecodeRune(rr, rr1); dec != unicode.ReplacementChar {
- // A valid pair; consume.
- r += 6
- w += utf8.EncodeRune(b[w:], dec)
- break
- }
- // Invalid surrogate; fall back to replacement rune.
- rr = unicode.ReplacementChar
- }
- w += utf8.EncodeRune(b[w:], rr)
- }
-
- // Quote, control characters are invalid.
- case c == '"', c < ' ':
- return
-
- // ASCII
- case c < utf8.RuneSelf:
- b[w] = c
- r++
- w++
-
- // Coerce to well-formed UTF-8.
- default:
- rr, size := utf8.DecodeRune(s[r:])
- r += size
- w += utf8.EncodeRune(b[w:], rr)
- }
- }
- return b[0:w], true
-}
-
-func getu4(s []byte) rune {
- if len(s) < 6 || s[0] != '\\' || s[1] != 'u' {
- return -1
- }
- var r rune
- for _, c := range s[2:6] {
- switch {
- case '0' <= c && c <= '9':
- c = c - '0'
- case 'a' <= c && c <= 'f':
- c = c - 'a' + 10
- case 'A' <= c && c <= 'F':
- c = c - 'A' + 10
- default:
- return -1
- }
- r = r*16 + rune(c)
- }
- return r
-}
diff --git a/vendor/github.com/goccy/go-json/internal/decoder/wrapped_string.go b/vendor/github.com/goccy/go-json/internal/decoder/wrapped_string.go
deleted file mode 100644
index 0c4e2e6e..00000000
--- a/vendor/github.com/goccy/go-json/internal/decoder/wrapped_string.go
+++ /dev/null
@@ -1,73 +0,0 @@
-package decoder
-
-import (
- "fmt"
- "reflect"
- "unsafe"
-
- "github.com/goccy/go-json/internal/runtime"
-)
-
-type wrappedStringDecoder struct {
- typ *runtime.Type
- dec Decoder
- stringDecoder *stringDecoder
- structName string
- fieldName string
- isPtrType bool
-}
-
-func newWrappedStringDecoder(typ *runtime.Type, dec Decoder, structName, fieldName string) *wrappedStringDecoder {
- return &wrappedStringDecoder{
- typ: typ,
- dec: dec,
- stringDecoder: newStringDecoder(structName, fieldName),
- structName: structName,
- fieldName: fieldName,
- isPtrType: typ.Kind() == reflect.Ptr,
- }
-}
-
-func (d *wrappedStringDecoder) DecodeStream(s *Stream, depth int64, p unsafe.Pointer) error {
- bytes, err := d.stringDecoder.decodeStreamByte(s)
- if err != nil {
- return err
- }
- if bytes == nil {
- if d.isPtrType {
- *(*unsafe.Pointer)(p) = nil
- }
- return nil
- }
- b := make([]byte, len(bytes)+1)
- copy(b, bytes)
- if _, err := d.dec.Decode(&RuntimeContext{Buf: b}, 0, depth, p); err != nil {
- return err
- }
- return nil
-}
-
-func (d *wrappedStringDecoder) Decode(ctx *RuntimeContext, cursor, depth int64, p unsafe.Pointer) (int64, error) {
- bytes, c, err := d.stringDecoder.decodeByte(ctx.Buf, cursor)
- if err != nil {
- return 0, err
- }
- if bytes == nil {
- if d.isPtrType {
- *(*unsafe.Pointer)(p) = nil
- }
- return c, nil
- }
- bytes = append(bytes, nul)
- oldBuf := ctx.Buf
- ctx.Buf = bytes
- if _, err := d.dec.Decode(ctx, 0, depth, p); err != nil {
- return 0, err
- }
- ctx.Buf = oldBuf
- return c, nil
-}
-
-func (d *wrappedStringDecoder) DecodePath(ctx *RuntimeContext, cursor, depth int64) ([][]byte, int64, error) {
- return nil, 0, fmt.Errorf("json: wrapped string decoder does not support decode path")
-}
diff --git a/vendor/github.com/goccy/go-json/internal/encoder/code.go b/vendor/github.com/goccy/go-json/internal/encoder/code.go
deleted file mode 100644
index 5b08faef..00000000
--- a/vendor/github.com/goccy/go-json/internal/encoder/code.go
+++ /dev/null
@@ -1,1023 +0,0 @@
-package encoder
-
-import (
- "fmt"
- "reflect"
- "unsafe"
-
- "github.com/goccy/go-json/internal/runtime"
-)
-
-type Code interface {
- Kind() CodeKind
- ToOpcode(*compileContext) Opcodes
- Filter(*FieldQuery) Code
-}
-
-type AnonymousCode interface {
- ToAnonymousOpcode(*compileContext) Opcodes
-}
-
-type Opcodes []*Opcode
-
-func (o Opcodes) First() *Opcode {
- if len(o) == 0 {
- return nil
- }
- return o[0]
-}
-
-func (o Opcodes) Last() *Opcode {
- if len(o) == 0 {
- return nil
- }
- return o[len(o)-1]
-}
-
-func (o Opcodes) Add(codes ...*Opcode) Opcodes {
- return append(o, codes...)
-}
-
-type CodeKind int
-
-const (
- CodeKindInterface CodeKind = iota
- CodeKindPtr
- CodeKindInt
- CodeKindUint
- CodeKindFloat
- CodeKindString
- CodeKindBool
- CodeKindStruct
- CodeKindMap
- CodeKindSlice
- CodeKindArray
- CodeKindBytes
- CodeKindMarshalJSON
- CodeKindMarshalText
- CodeKindRecursive
-)
-
-type IntCode struct {
- typ *runtime.Type
- bitSize uint8
- isString bool
- isPtr bool
-}
-
-func (c *IntCode) Kind() CodeKind {
- return CodeKindInt
-}
-
-func (c *IntCode) ToOpcode(ctx *compileContext) Opcodes {
- var code *Opcode
- switch {
- case c.isPtr:
- code = newOpCode(ctx, c.typ, OpIntPtr)
- case c.isString:
- code = newOpCode(ctx, c.typ, OpIntString)
- default:
- code = newOpCode(ctx, c.typ, OpInt)
- }
- code.NumBitSize = c.bitSize
- ctx.incIndex()
- return Opcodes{code}
-}
-
-func (c *IntCode) Filter(_ *FieldQuery) Code {
- return c
-}
-
-type UintCode struct {
- typ *runtime.Type
- bitSize uint8
- isString bool
- isPtr bool
-}
-
-func (c *UintCode) Kind() CodeKind {
- return CodeKindUint
-}
-
-func (c *UintCode) ToOpcode(ctx *compileContext) Opcodes {
- var code *Opcode
- switch {
- case c.isPtr:
- code = newOpCode(ctx, c.typ, OpUintPtr)
- case c.isString:
- code = newOpCode(ctx, c.typ, OpUintString)
- default:
- code = newOpCode(ctx, c.typ, OpUint)
- }
- code.NumBitSize = c.bitSize
- ctx.incIndex()
- return Opcodes{code}
-}
-
-func (c *UintCode) Filter(_ *FieldQuery) Code {
- return c
-}
-
-type FloatCode struct {
- typ *runtime.Type
- bitSize uint8
- isPtr bool
-}
-
-func (c *FloatCode) Kind() CodeKind {
- return CodeKindFloat
-}
-
-func (c *FloatCode) ToOpcode(ctx *compileContext) Opcodes {
- var code *Opcode
- switch {
- case c.isPtr:
- switch c.bitSize {
- case 32:
- code = newOpCode(ctx, c.typ, OpFloat32Ptr)
- default:
- code = newOpCode(ctx, c.typ, OpFloat64Ptr)
- }
- default:
- switch c.bitSize {
- case 32:
- code = newOpCode(ctx, c.typ, OpFloat32)
- default:
- code = newOpCode(ctx, c.typ, OpFloat64)
- }
- }
- ctx.incIndex()
- return Opcodes{code}
-}
-
-func (c *FloatCode) Filter(_ *FieldQuery) Code {
- return c
-}
-
-type StringCode struct {
- typ *runtime.Type
- isPtr bool
-}
-
-func (c *StringCode) Kind() CodeKind {
- return CodeKindString
-}
-
-func (c *StringCode) ToOpcode(ctx *compileContext) Opcodes {
- isJSONNumberType := c.typ == runtime.Type2RType(jsonNumberType)
- var code *Opcode
- if c.isPtr {
- if isJSONNumberType {
- code = newOpCode(ctx, c.typ, OpNumberPtr)
- } else {
- code = newOpCode(ctx, c.typ, OpStringPtr)
- }
- } else {
- if isJSONNumberType {
- code = newOpCode(ctx, c.typ, OpNumber)
- } else {
- code = newOpCode(ctx, c.typ, OpString)
- }
- }
- ctx.incIndex()
- return Opcodes{code}
-}
-
-func (c *StringCode) Filter(_ *FieldQuery) Code {
- return c
-}
-
-type BoolCode struct {
- typ *runtime.Type
- isPtr bool
-}
-
-func (c *BoolCode) Kind() CodeKind {
- return CodeKindBool
-}
-
-func (c *BoolCode) ToOpcode(ctx *compileContext) Opcodes {
- var code *Opcode
- switch {
- case c.isPtr:
- code = newOpCode(ctx, c.typ, OpBoolPtr)
- default:
- code = newOpCode(ctx, c.typ, OpBool)
- }
- ctx.incIndex()
- return Opcodes{code}
-}
-
-func (c *BoolCode) Filter(_ *FieldQuery) Code {
- return c
-}
-
-type BytesCode struct {
- typ *runtime.Type
- isPtr bool
-}
-
-func (c *BytesCode) Kind() CodeKind {
- return CodeKindBytes
-}
-
-func (c *BytesCode) ToOpcode(ctx *compileContext) Opcodes {
- var code *Opcode
- switch {
- case c.isPtr:
- code = newOpCode(ctx, c.typ, OpBytesPtr)
- default:
- code = newOpCode(ctx, c.typ, OpBytes)
- }
- ctx.incIndex()
- return Opcodes{code}
-}
-
-func (c *BytesCode) Filter(_ *FieldQuery) Code {
- return c
-}
-
-type SliceCode struct {
- typ *runtime.Type
- value Code
-}
-
-func (c *SliceCode) Kind() CodeKind {
- return CodeKindSlice
-}
-
-func (c *SliceCode) ToOpcode(ctx *compileContext) Opcodes {
- // header => opcode => elem => end
- // ^ |
- // |________|
- size := c.typ.Elem().Size()
- header := newSliceHeaderCode(ctx, c.typ)
- ctx.incIndex()
-
- ctx.incIndent()
- codes := c.value.ToOpcode(ctx)
- ctx.decIndent()
-
- codes.First().Flags |= IndirectFlags
- elemCode := newSliceElemCode(ctx, c.typ.Elem(), header, size)
- ctx.incIndex()
- end := newOpCode(ctx, c.typ, OpSliceEnd)
- ctx.incIndex()
- header.End = end
- header.Next = codes.First()
- codes.Last().Next = elemCode
- elemCode.Next = codes.First()
- elemCode.End = end
- return Opcodes{header}.Add(codes...).Add(elemCode).Add(end)
-}
-
-func (c *SliceCode) Filter(_ *FieldQuery) Code {
- return c
-}
-
-type ArrayCode struct {
- typ *runtime.Type
- value Code
-}
-
-func (c *ArrayCode) Kind() CodeKind {
- return CodeKindArray
-}
-
-func (c *ArrayCode) ToOpcode(ctx *compileContext) Opcodes {
- // header => opcode => elem => end
- // ^ |
- // |________|
- elem := c.typ.Elem()
- alen := c.typ.Len()
- size := elem.Size()
-
- header := newArrayHeaderCode(ctx, c.typ, alen)
- ctx.incIndex()
-
- ctx.incIndent()
- codes := c.value.ToOpcode(ctx)
- ctx.decIndent()
-
- codes.First().Flags |= IndirectFlags
-
- elemCode := newArrayElemCode(ctx, elem, header, alen, size)
- ctx.incIndex()
-
- end := newOpCode(ctx, c.typ, OpArrayEnd)
- ctx.incIndex()
-
- header.End = end
- header.Next = codes.First()
- codes.Last().Next = elemCode
- elemCode.Next = codes.First()
- elemCode.End = end
-
- return Opcodes{header}.Add(codes...).Add(elemCode).Add(end)
-}
-
-func (c *ArrayCode) Filter(_ *FieldQuery) Code {
- return c
-}
-
-type MapCode struct {
- typ *runtime.Type
- key Code
- value Code
-}
-
-func (c *MapCode) Kind() CodeKind {
- return CodeKindMap
-}
-
-func (c *MapCode) ToOpcode(ctx *compileContext) Opcodes {
- // header => code => value => code => key => code => value => code => end
- // ^ |
- // |_______________________|
- header := newMapHeaderCode(ctx, c.typ)
- ctx.incIndex()
-
- keyCodes := c.key.ToOpcode(ctx)
-
- value := newMapValueCode(ctx, c.typ.Elem(), header)
- ctx.incIndex()
-
- ctx.incIndent()
- valueCodes := c.value.ToOpcode(ctx)
- ctx.decIndent()
-
- valueCodes.First().Flags |= IndirectFlags
-
- key := newMapKeyCode(ctx, c.typ.Key(), header)
- ctx.incIndex()
-
- end := newMapEndCode(ctx, c.typ, header)
- ctx.incIndex()
-
- header.Next = keyCodes.First()
- keyCodes.Last().Next = value
- value.Next = valueCodes.First()
- valueCodes.Last().Next = key
- key.Next = keyCodes.First()
-
- header.End = end
- key.End = end
- value.End = end
- return Opcodes{header}.Add(keyCodes...).Add(value).Add(valueCodes...).Add(key).Add(end)
-}
-
-func (c *MapCode) Filter(_ *FieldQuery) Code {
- return c
-}
-
-type StructCode struct {
- typ *runtime.Type
- fields []*StructFieldCode
- isPtr bool
- disableIndirectConversion bool
- isIndirect bool
- isRecursive bool
-}
-
-func (c *StructCode) Kind() CodeKind {
- return CodeKindStruct
-}
-
-func (c *StructCode) lastFieldCode(field *StructFieldCode, firstField *Opcode) *Opcode {
- if isEmbeddedStruct(field) {
- return c.lastAnonymousFieldCode(firstField)
- }
- lastField := firstField
- for lastField.NextField != nil {
- lastField = lastField.NextField
- }
- return lastField
-}
-
-func (c *StructCode) lastAnonymousFieldCode(firstField *Opcode) *Opcode {
- // firstField is special StructHead operation for anonymous structure.
- // So, StructHead's next operation is truly struct head operation.
- for firstField.Op == OpStructHead || firstField.Op == OpStructField {
- firstField = firstField.Next
- }
- lastField := firstField
- for lastField.NextField != nil {
- lastField = lastField.NextField
- }
- return lastField
-}
-
-func (c *StructCode) ToOpcode(ctx *compileContext) Opcodes {
- // header => code => structField => code => end
- // ^ |
- // |__________|
- if c.isRecursive {
- recursive := newRecursiveCode(ctx, c.typ, &CompiledCode{})
- recursive.Type = c.typ
- ctx.incIndex()
- *ctx.recursiveCodes = append(*ctx.recursiveCodes, recursive)
- return Opcodes{recursive}
- }
- codes := Opcodes{}
- var prevField *Opcode
- ctx.incIndent()
- for idx, field := range c.fields {
- isFirstField := idx == 0
- isEndField := idx == len(c.fields)-1
- fieldCodes := field.ToOpcode(ctx, isFirstField, isEndField)
- for _, code := range fieldCodes {
- if c.isIndirect {
- code.Flags |= IndirectFlags
- }
- }
- firstField := fieldCodes.First()
- if len(codes) > 0 {
- codes.Last().Next = firstField
- firstField.Idx = codes.First().Idx
- }
- if prevField != nil {
- prevField.NextField = firstField
- }
- if isEndField {
- endField := fieldCodes.Last()
- if len(codes) > 0 {
- codes.First().End = endField
- } else {
- firstField.End = endField
- }
- codes = codes.Add(fieldCodes...)
- break
- }
- prevField = c.lastFieldCode(field, firstField)
- codes = codes.Add(fieldCodes...)
- }
- if len(codes) == 0 {
- head := &Opcode{
- Op: OpStructHead,
- Idx: opcodeOffset(ctx.ptrIndex),
- Type: c.typ,
- DisplayIdx: ctx.opcodeIndex,
- Indent: ctx.indent,
- }
- ctx.incOpcodeIndex()
- end := &Opcode{
- Op: OpStructEnd,
- Idx: opcodeOffset(ctx.ptrIndex),
- DisplayIdx: ctx.opcodeIndex,
- Indent: ctx.indent,
- }
- head.NextField = end
- head.Next = end
- head.End = end
- codes = codes.Add(head, end)
- ctx.incIndex()
- }
- ctx.decIndent()
- ctx.structTypeToCodes[uintptr(unsafe.Pointer(c.typ))] = codes
- return codes
-}
-
-func (c *StructCode) ToAnonymousOpcode(ctx *compileContext) Opcodes {
- // header => code => structField => code => end
- // ^ |
- // |__________|
- if c.isRecursive {
- recursive := newRecursiveCode(ctx, c.typ, &CompiledCode{})
- recursive.Type = c.typ
- ctx.incIndex()
- *ctx.recursiveCodes = append(*ctx.recursiveCodes, recursive)
- return Opcodes{recursive}
- }
- codes := Opcodes{}
- var prevField *Opcode
- for idx, field := range c.fields {
- isFirstField := idx == 0
- isEndField := idx == len(c.fields)-1
- fieldCodes := field.ToAnonymousOpcode(ctx, isFirstField, isEndField)
- for _, code := range fieldCodes {
- if c.isIndirect {
- code.Flags |= IndirectFlags
- }
- }
- firstField := fieldCodes.First()
- if len(codes) > 0 {
- codes.Last().Next = firstField
- firstField.Idx = codes.First().Idx
- }
- if prevField != nil {
- prevField.NextField = firstField
- }
- if isEndField {
- lastField := fieldCodes.Last()
- if len(codes) > 0 {
- codes.First().End = lastField
- } else {
- firstField.End = lastField
- }
- }
- prevField = firstField
- codes = codes.Add(fieldCodes...)
- }
- return codes
-}
-
-func (c *StructCode) removeFieldsByTags(tags runtime.StructTags) {
- fields := make([]*StructFieldCode, 0, len(c.fields))
- for _, field := range c.fields {
- if field.isAnonymous {
- structCode := field.getAnonymousStruct()
- if structCode != nil && !structCode.isRecursive {
- structCode.removeFieldsByTags(tags)
- if len(structCode.fields) > 0 {
- fields = append(fields, field)
- }
- continue
- }
- }
- if tags.ExistsKey(field.key) {
- continue
- }
- fields = append(fields, field)
- }
- c.fields = fields
-}
-
-func (c *StructCode) enableIndirect() {
- if c.isIndirect {
- return
- }
- c.isIndirect = true
- if len(c.fields) == 0 {
- return
- }
- structCode := c.fields[0].getStruct()
- if structCode == nil {
- return
- }
- structCode.enableIndirect()
-}
-
-func (c *StructCode) Filter(query *FieldQuery) Code {
- fieldMap := map[string]*FieldQuery{}
- for _, field := range query.Fields {
- fieldMap[field.Name] = field
- }
- fields := make([]*StructFieldCode, 0, len(c.fields))
- for _, field := range c.fields {
- query, exists := fieldMap[field.key]
- if !exists {
- continue
- }
- fieldCode := &StructFieldCode{
- typ: field.typ,
- key: field.key,
- tag: field.tag,
- value: field.value,
- offset: field.offset,
- isAnonymous: field.isAnonymous,
- isTaggedKey: field.isTaggedKey,
- isNilableType: field.isNilableType,
- isNilCheck: field.isNilCheck,
- isAddrForMarshaler: field.isAddrForMarshaler,
- isNextOpPtrType: field.isNextOpPtrType,
- }
- if len(query.Fields) > 0 {
- fieldCode.value = fieldCode.value.Filter(query)
- }
- fields = append(fields, fieldCode)
- }
- return &StructCode{
- typ: c.typ,
- fields: fields,
- isPtr: c.isPtr,
- disableIndirectConversion: c.disableIndirectConversion,
- isIndirect: c.isIndirect,
- isRecursive: c.isRecursive,
- }
-}
-
-type StructFieldCode struct {
- typ *runtime.Type
- key string
- tag *runtime.StructTag
- value Code
- offset uintptr
- isAnonymous bool
- isTaggedKey bool
- isNilableType bool
- isNilCheck bool
- isAddrForMarshaler bool
- isNextOpPtrType bool
- isMarshalerContext bool
-}
-
-func (c *StructFieldCode) getStruct() *StructCode {
- value := c.value
- ptr, ok := value.(*PtrCode)
- if ok {
- value = ptr.value
- }
- structCode, ok := value.(*StructCode)
- if ok {
- return structCode
- }
- return nil
-}
-
-func (c *StructFieldCode) getAnonymousStruct() *StructCode {
- if !c.isAnonymous {
- return nil
- }
- return c.getStruct()
-}
-
-func optimizeStructHeader(code *Opcode, tag *runtime.StructTag) OpType {
- headType := code.ToHeaderType(tag.IsString)
- if tag.IsOmitEmpty {
- headType = headType.HeadToOmitEmptyHead()
- }
- return headType
-}
-
-func optimizeStructField(code *Opcode, tag *runtime.StructTag) OpType {
- fieldType := code.ToFieldType(tag.IsString)
- if tag.IsOmitEmpty {
- fieldType = fieldType.FieldToOmitEmptyField()
- }
- return fieldType
-}
-
-func (c *StructFieldCode) headerOpcodes(ctx *compileContext, field *Opcode, valueCodes Opcodes) Opcodes {
- value := valueCodes.First()
- op := optimizeStructHeader(value, c.tag)
- field.Op = op
- if value.Flags&MarshalerContextFlags != 0 {
- field.Flags |= MarshalerContextFlags
- }
- field.NumBitSize = value.NumBitSize
- field.PtrNum = value.PtrNum
- field.FieldQuery = value.FieldQuery
- fieldCodes := Opcodes{field}
- if op.IsMultipleOpHead() {
- field.Next = value
- fieldCodes = fieldCodes.Add(valueCodes...)
- } else {
- ctx.decIndex()
- }
- return fieldCodes
-}
-
-func (c *StructFieldCode) fieldOpcodes(ctx *compileContext, field *Opcode, valueCodes Opcodes) Opcodes {
- value := valueCodes.First()
- op := optimizeStructField(value, c.tag)
- field.Op = op
- if value.Flags&MarshalerContextFlags != 0 {
- field.Flags |= MarshalerContextFlags
- }
- field.NumBitSize = value.NumBitSize
- field.PtrNum = value.PtrNum
- field.FieldQuery = value.FieldQuery
-
- fieldCodes := Opcodes{field}
- if op.IsMultipleOpField() {
- field.Next = value
- fieldCodes = fieldCodes.Add(valueCodes...)
- } else {
- ctx.decIndex()
- }
- return fieldCodes
-}
-
-func (c *StructFieldCode) addStructEndCode(ctx *compileContext, codes Opcodes) Opcodes {
- end := &Opcode{
- Op: OpStructEnd,
- Idx: opcodeOffset(ctx.ptrIndex),
- DisplayIdx: ctx.opcodeIndex,
- Indent: ctx.indent,
- }
- codes.Last().Next = end
- code := codes.First()
- for code.Op == OpStructField || code.Op == OpStructHead {
- code = code.Next
- }
- for code.NextField != nil {
- code = code.NextField
- }
- code.NextField = end
-
- codes = codes.Add(end)
- ctx.incOpcodeIndex()
- return codes
-}
-
-func (c *StructFieldCode) structKey(ctx *compileContext) string {
- if ctx.escapeKey {
- rctx := &RuntimeContext{Option: &Option{Flag: HTMLEscapeOption}}
- return fmt.Sprintf(`%s:`, string(AppendString(rctx, []byte{}, c.key)))
- }
- return fmt.Sprintf(`"%s":`, c.key)
-}
-
-func (c *StructFieldCode) flags() OpFlags {
- var flags OpFlags
- if c.isTaggedKey {
- flags |= IsTaggedKeyFlags
- }
- if c.isNilableType {
- flags |= IsNilableTypeFlags
- }
- if c.isNilCheck {
- flags |= NilCheckFlags
- }
- if c.isAddrForMarshaler {
- flags |= AddrForMarshalerFlags
- }
- if c.isNextOpPtrType {
- flags |= IsNextOpPtrTypeFlags
- }
- if c.isAnonymous {
- flags |= AnonymousKeyFlags
- }
- if c.isMarshalerContext {
- flags |= MarshalerContextFlags
- }
- return flags
-}
-
-func (c *StructFieldCode) toValueOpcodes(ctx *compileContext) Opcodes {
- if c.isAnonymous {
- anonymCode, ok := c.value.(AnonymousCode)
- if ok {
- return anonymCode.ToAnonymousOpcode(ctx)
- }
- }
- return c.value.ToOpcode(ctx)
-}
-
-func (c *StructFieldCode) ToOpcode(ctx *compileContext, isFirstField, isEndField bool) Opcodes {
- field := &Opcode{
- Idx: opcodeOffset(ctx.ptrIndex),
- Flags: c.flags(),
- Key: c.structKey(ctx),
- Offset: uint32(c.offset),
- Type: c.typ,
- DisplayIdx: ctx.opcodeIndex,
- Indent: ctx.indent,
- DisplayKey: c.key,
- }
- ctx.incIndex()
- valueCodes := c.toValueOpcodes(ctx)
- if isFirstField {
- codes := c.headerOpcodes(ctx, field, valueCodes)
- if isEndField {
- codes = c.addStructEndCode(ctx, codes)
- }
- return codes
- }
- codes := c.fieldOpcodes(ctx, field, valueCodes)
- if isEndField {
- if isEnableStructEndOptimization(c.value) {
- field.Op = field.Op.FieldToEnd()
- } else {
- codes = c.addStructEndCode(ctx, codes)
- }
- }
- return codes
-}
-
-func (c *StructFieldCode) ToAnonymousOpcode(ctx *compileContext, isFirstField, isEndField bool) Opcodes {
- field := &Opcode{
- Idx: opcodeOffset(ctx.ptrIndex),
- Flags: c.flags() | AnonymousHeadFlags,
- Key: c.structKey(ctx),
- Offset: uint32(c.offset),
- Type: c.typ,
- DisplayIdx: ctx.opcodeIndex,
- Indent: ctx.indent,
- DisplayKey: c.key,
- }
- ctx.incIndex()
- valueCodes := c.toValueOpcodes(ctx)
- if isFirstField {
- return c.headerOpcodes(ctx, field, valueCodes)
- }
- return c.fieldOpcodes(ctx, field, valueCodes)
-}
-
-func isEnableStructEndOptimization(value Code) bool {
- switch value.Kind() {
- case CodeKindInt,
- CodeKindUint,
- CodeKindFloat,
- CodeKindString,
- CodeKindBool,
- CodeKindBytes:
- return true
- case CodeKindPtr:
- return isEnableStructEndOptimization(value.(*PtrCode).value)
- default:
- return false
- }
-}
-
-type InterfaceCode struct {
- typ *runtime.Type
- fieldQuery *FieldQuery
- isPtr bool
-}
-
-func (c *InterfaceCode) Kind() CodeKind {
- return CodeKindInterface
-}
-
-func (c *InterfaceCode) ToOpcode(ctx *compileContext) Opcodes {
- var code *Opcode
- switch {
- case c.isPtr:
- code = newOpCode(ctx, c.typ, OpInterfacePtr)
- default:
- code = newOpCode(ctx, c.typ, OpInterface)
- }
- code.FieldQuery = c.fieldQuery
- if c.typ.NumMethod() > 0 {
- code.Flags |= NonEmptyInterfaceFlags
- }
- ctx.incIndex()
- return Opcodes{code}
-}
-
-func (c *InterfaceCode) Filter(query *FieldQuery) Code {
- return &InterfaceCode{
- typ: c.typ,
- fieldQuery: query,
- isPtr: c.isPtr,
- }
-}
-
-type MarshalJSONCode struct {
- typ *runtime.Type
- fieldQuery *FieldQuery
- isAddrForMarshaler bool
- isNilableType bool
- isMarshalerContext bool
-}
-
-func (c *MarshalJSONCode) Kind() CodeKind {
- return CodeKindMarshalJSON
-}
-
-func (c *MarshalJSONCode) ToOpcode(ctx *compileContext) Opcodes {
- code := newOpCode(ctx, c.typ, OpMarshalJSON)
- code.FieldQuery = c.fieldQuery
- if c.isAddrForMarshaler {
- code.Flags |= AddrForMarshalerFlags
- }
- if c.isMarshalerContext {
- code.Flags |= MarshalerContextFlags
- }
- if c.isNilableType {
- code.Flags |= IsNilableTypeFlags
- } else {
- code.Flags &= ^IsNilableTypeFlags
- }
- ctx.incIndex()
- return Opcodes{code}
-}
-
-func (c *MarshalJSONCode) Filter(query *FieldQuery) Code {
- return &MarshalJSONCode{
- typ: c.typ,
- fieldQuery: query,
- isAddrForMarshaler: c.isAddrForMarshaler,
- isNilableType: c.isNilableType,
- isMarshalerContext: c.isMarshalerContext,
- }
-}
-
-type MarshalTextCode struct {
- typ *runtime.Type
- fieldQuery *FieldQuery
- isAddrForMarshaler bool
- isNilableType bool
-}
-
-func (c *MarshalTextCode) Kind() CodeKind {
- return CodeKindMarshalText
-}
-
-func (c *MarshalTextCode) ToOpcode(ctx *compileContext) Opcodes {
- code := newOpCode(ctx, c.typ, OpMarshalText)
- code.FieldQuery = c.fieldQuery
- if c.isAddrForMarshaler {
- code.Flags |= AddrForMarshalerFlags
- }
- if c.isNilableType {
- code.Flags |= IsNilableTypeFlags
- } else {
- code.Flags &= ^IsNilableTypeFlags
- }
- ctx.incIndex()
- return Opcodes{code}
-}
-
-func (c *MarshalTextCode) Filter(query *FieldQuery) Code {
- return &MarshalTextCode{
- typ: c.typ,
- fieldQuery: query,
- isAddrForMarshaler: c.isAddrForMarshaler,
- isNilableType: c.isNilableType,
- }
-}
-
-type PtrCode struct {
- typ *runtime.Type
- value Code
- ptrNum uint8
-}
-
-func (c *PtrCode) Kind() CodeKind {
- return CodeKindPtr
-}
-
-func (c *PtrCode) ToOpcode(ctx *compileContext) Opcodes {
- codes := c.value.ToOpcode(ctx)
- codes.First().Op = convertPtrOp(codes.First())
- codes.First().PtrNum = c.ptrNum
- return codes
-}
-
-func (c *PtrCode) ToAnonymousOpcode(ctx *compileContext) Opcodes {
- var codes Opcodes
- anonymCode, ok := c.value.(AnonymousCode)
- if ok {
- codes = anonymCode.ToAnonymousOpcode(ctx)
- } else {
- codes = c.value.ToOpcode(ctx)
- }
- codes.First().Op = convertPtrOp(codes.First())
- codes.First().PtrNum = c.ptrNum
- return codes
-}
-
-func (c *PtrCode) Filter(query *FieldQuery) Code {
- return &PtrCode{
- typ: c.typ,
- value: c.value.Filter(query),
- ptrNum: c.ptrNum,
- }
-}
-
-func convertPtrOp(code *Opcode) OpType {
- ptrHeadOp := code.Op.HeadToPtrHead()
- if code.Op != ptrHeadOp {
- if code.PtrNum > 0 {
- // ptr field and ptr head
- code.PtrNum--
- }
- return ptrHeadOp
- }
- switch code.Op {
- case OpInt:
- return OpIntPtr
- case OpUint:
- return OpUintPtr
- case OpFloat32:
- return OpFloat32Ptr
- case OpFloat64:
- return OpFloat64Ptr
- case OpString:
- return OpStringPtr
- case OpBool:
- return OpBoolPtr
- case OpBytes:
- return OpBytesPtr
- case OpNumber:
- return OpNumberPtr
- case OpArray:
- return OpArrayPtr
- case OpSlice:
- return OpSlicePtr
- case OpMap:
- return OpMapPtr
- case OpMarshalJSON:
- return OpMarshalJSONPtr
- case OpMarshalText:
- return OpMarshalTextPtr
- case OpInterface:
- return OpInterfacePtr
- case OpRecursive:
- return OpRecursivePtr
- }
- return code.Op
-}
-
-func isEmbeddedStruct(field *StructFieldCode) bool {
- if !field.isAnonymous {
- return false
- }
- t := field.typ
- if t.Kind() == reflect.Ptr {
- t = t.Elem()
- }
- return t.Kind() == reflect.Struct
-}
diff --git a/vendor/github.com/goccy/go-json/internal/encoder/compact.go b/vendor/github.com/goccy/go-json/internal/encoder/compact.go
deleted file mode 100644
index e287a6c0..00000000
--- a/vendor/github.com/goccy/go-json/internal/encoder/compact.go
+++ /dev/null
@@ -1,286 +0,0 @@
-package encoder
-
-import (
- "bytes"
- "fmt"
- "strconv"
- "unsafe"
-
- "github.com/goccy/go-json/internal/errors"
-)
-
-var (
- isWhiteSpace = [256]bool{
- ' ': true,
- '\n': true,
- '\t': true,
- '\r': true,
- }
- isHTMLEscapeChar = [256]bool{
- '<': true,
- '>': true,
- '&': true,
- }
- nul = byte('\000')
-)
-
-func Compact(buf *bytes.Buffer, src []byte, escape bool) error {
- if len(src) == 0 {
- return errors.ErrUnexpectedEndOfJSON("", 0)
- }
- buf.Grow(len(src))
- dst := buf.Bytes()
-
- ctx := TakeRuntimeContext()
- ctxBuf := ctx.Buf[:0]
- ctxBuf = append(append(ctxBuf, src...), nul)
- ctx.Buf = ctxBuf
-
- if err := compactAndWrite(buf, dst, ctxBuf, escape); err != nil {
- ReleaseRuntimeContext(ctx)
- return err
- }
- ReleaseRuntimeContext(ctx)
- return nil
-}
-
-func compactAndWrite(buf *bytes.Buffer, dst []byte, src []byte, escape bool) error {
- dst, err := compact(dst, src, escape)
- if err != nil {
- return err
- }
- if _, err := buf.Write(dst); err != nil {
- return err
- }
- return nil
-}
-
-func compact(dst, src []byte, escape bool) ([]byte, error) {
- buf, cursor, err := compactValue(dst, src, 0, escape)
- if err != nil {
- return nil, err
- }
- if err := validateEndBuf(src, cursor); err != nil {
- return nil, err
- }
- return buf, nil
-}
-
-func validateEndBuf(src []byte, cursor int64) error {
- for {
- switch src[cursor] {
- case ' ', '\t', '\n', '\r':
- cursor++
- continue
- case nul:
- return nil
- }
- return errors.ErrSyntax(
- fmt.Sprintf("invalid character '%c' after top-level value", src[cursor]),
- cursor+1,
- )
- }
-}
-
-func skipWhiteSpace(buf []byte, cursor int64) int64 {
-LOOP:
- if isWhiteSpace[buf[cursor]] {
- cursor++
- goto LOOP
- }
- return cursor
-}
-
-func compactValue(dst, src []byte, cursor int64, escape bool) ([]byte, int64, error) {
- for {
- switch src[cursor] {
- case ' ', '\t', '\n', '\r':
- cursor++
- continue
- case '{':
- return compactObject(dst, src, cursor, escape)
- case '}':
- return nil, 0, errors.ErrSyntax("unexpected character '}'", cursor)
- case '[':
- return compactArray(dst, src, cursor, escape)
- case ']':
- return nil, 0, errors.ErrSyntax("unexpected character ']'", cursor)
- case '"':
- return compactString(dst, src, cursor, escape)
- case '-', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
- return compactNumber(dst, src, cursor)
- case 't':
- return compactTrue(dst, src, cursor)
- case 'f':
- return compactFalse(dst, src, cursor)
- case 'n':
- return compactNull(dst, src, cursor)
- default:
- return nil, 0, errors.ErrSyntax(fmt.Sprintf("unexpected character '%c'", src[cursor]), cursor)
- }
- }
-}
-
-func compactObject(dst, src []byte, cursor int64, escape bool) ([]byte, int64, error) {
- if src[cursor] == '{' {
- dst = append(dst, '{')
- } else {
- return nil, 0, errors.ErrExpected("expected { character for object value", cursor)
- }
- cursor = skipWhiteSpace(src, cursor+1)
- if src[cursor] == '}' {
- dst = append(dst, '}')
- return dst, cursor + 1, nil
- }
- var err error
- for {
- cursor = skipWhiteSpace(src, cursor)
- dst, cursor, err = compactString(dst, src, cursor, escape)
- if err != nil {
- return nil, 0, err
- }
- cursor = skipWhiteSpace(src, cursor)
- if src[cursor] != ':' {
- return nil, 0, errors.ErrExpected("colon after object key", cursor)
- }
- dst = append(dst, ':')
- dst, cursor, err = compactValue(dst, src, cursor+1, escape)
- if err != nil {
- return nil, 0, err
- }
- cursor = skipWhiteSpace(src, cursor)
- switch src[cursor] {
- case '}':
- dst = append(dst, '}')
- cursor++
- return dst, cursor, nil
- case ',':
- dst = append(dst, ',')
- default:
- return nil, 0, errors.ErrExpected("comma after object value", cursor)
- }
- cursor++
- }
-}
-
-func compactArray(dst, src []byte, cursor int64, escape bool) ([]byte, int64, error) {
- if src[cursor] == '[' {
- dst = append(dst, '[')
- } else {
- return nil, 0, errors.ErrExpected("expected [ character for array value", cursor)
- }
- cursor = skipWhiteSpace(src, cursor+1)
- if src[cursor] == ']' {
- dst = append(dst, ']')
- return dst, cursor + 1, nil
- }
- var err error
- for {
- dst, cursor, err = compactValue(dst, src, cursor, escape)
- if err != nil {
- return nil, 0, err
- }
- cursor = skipWhiteSpace(src, cursor)
- switch src[cursor] {
- case ']':
- dst = append(dst, ']')
- cursor++
- return dst, cursor, nil
- case ',':
- dst = append(dst, ',')
- default:
- return nil, 0, errors.ErrExpected("comma after array value", cursor)
- }
- cursor++
- }
-}
-
-func compactString(dst, src []byte, cursor int64, escape bool) ([]byte, int64, error) {
- if src[cursor] != '"' {
- return nil, 0, errors.ErrInvalidCharacter(src[cursor], "string", cursor)
- }
- start := cursor
- for {
- cursor++
- c := src[cursor]
- if escape {
- if isHTMLEscapeChar[c] {
- dst = append(dst, src[start:cursor]...)
- dst = append(dst, `\u00`...)
- dst = append(dst, hex[c>>4], hex[c&0xF])
- start = cursor + 1
- } else if c == 0xE2 && cursor+2 < int64(len(src)) && src[cursor+1] == 0x80 && src[cursor+2]&^1 == 0xA8 {
- dst = append(dst, src[start:cursor]...)
- dst = append(dst, `\u202`...)
- dst = append(dst, hex[src[cursor+2]&0xF])
- start = cursor + 3
- cursor += 2
- }
- }
- switch c {
- case '\\':
- cursor++
- if src[cursor] == nul {
- return nil, 0, errors.ErrUnexpectedEndOfJSON("string", int64(len(src)))
- }
- case '"':
- cursor++
- return append(dst, src[start:cursor]...), cursor, nil
- case nul:
- return nil, 0, errors.ErrUnexpectedEndOfJSON("string", int64(len(src)))
- }
- }
-}
-
-func compactNumber(dst, src []byte, cursor int64) ([]byte, int64, error) {
- start := cursor
- for {
- cursor++
- if floatTable[src[cursor]] {
- continue
- }
- break
- }
- num := src[start:cursor]
- if _, err := strconv.ParseFloat(*(*string)(unsafe.Pointer(&num)), 64); err != nil {
- return nil, 0, err
- }
- dst = append(dst, num...)
- return dst, cursor, nil
-}
-
-func compactTrue(dst, src []byte, cursor int64) ([]byte, int64, error) {
- if cursor+3 >= int64(len(src)) {
- return nil, 0, errors.ErrUnexpectedEndOfJSON("true", cursor)
- }
- if !bytes.Equal(src[cursor:cursor+4], []byte(`true`)) {
- return nil, 0, errors.ErrInvalidCharacter(src[cursor], "true", cursor)
- }
- dst = append(dst, "true"...)
- cursor += 4
- return dst, cursor, nil
-}
-
-func compactFalse(dst, src []byte, cursor int64) ([]byte, int64, error) {
- if cursor+4 >= int64(len(src)) {
- return nil, 0, errors.ErrUnexpectedEndOfJSON("false", cursor)
- }
- if !bytes.Equal(src[cursor:cursor+5], []byte(`false`)) {
- return nil, 0, errors.ErrInvalidCharacter(src[cursor], "false", cursor)
- }
- dst = append(dst, "false"...)
- cursor += 5
- return dst, cursor, nil
-}
-
-func compactNull(dst, src []byte, cursor int64) ([]byte, int64, error) {
- if cursor+3 >= int64(len(src)) {
- return nil, 0, errors.ErrUnexpectedEndOfJSON("null", cursor)
- }
- if !bytes.Equal(src[cursor:cursor+4], []byte(`null`)) {
- return nil, 0, errors.ErrInvalidCharacter(src[cursor], "null", cursor)
- }
- dst = append(dst, "null"...)
- cursor += 4
- return dst, cursor, nil
-}
diff --git a/vendor/github.com/goccy/go-json/internal/encoder/compiler.go b/vendor/github.com/goccy/go-json/internal/encoder/compiler.go
deleted file mode 100644
index b1076368..00000000
--- a/vendor/github.com/goccy/go-json/internal/encoder/compiler.go
+++ /dev/null
@@ -1,939 +0,0 @@
-package encoder
-
-import (
- "context"
- "encoding"
- "encoding/json"
- "reflect"
- "sync"
- "sync/atomic"
- "unsafe"
-
- "github.com/goccy/go-json/internal/errors"
- "github.com/goccy/go-json/internal/runtime"
-)
-
-type marshalerContext interface {
- MarshalJSON(context.Context) ([]byte, error)
-}
-
-var (
- marshalJSONType = reflect.TypeOf((*json.Marshaler)(nil)).Elem()
- marshalJSONContextType = reflect.TypeOf((*marshalerContext)(nil)).Elem()
- marshalTextType = reflect.TypeOf((*encoding.TextMarshaler)(nil)).Elem()
- jsonNumberType = reflect.TypeOf(json.Number(""))
- cachedOpcodeSets []*OpcodeSet
- cachedOpcodeMap unsafe.Pointer // map[uintptr]*OpcodeSet
- typeAddr *runtime.TypeAddr
- initEncoderOnce sync.Once
-)
-
-func initEncoder() {
- initEncoderOnce.Do(func() {
- typeAddr = runtime.AnalyzeTypeAddr()
- if typeAddr == nil {
- typeAddr = &runtime.TypeAddr{}
- }
- cachedOpcodeSets = make([]*OpcodeSet, typeAddr.AddrRange>>typeAddr.AddrShift+1)
- })
-}
-
-func loadOpcodeMap() map[uintptr]*OpcodeSet {
- p := atomic.LoadPointer(&cachedOpcodeMap)
- return *(*map[uintptr]*OpcodeSet)(unsafe.Pointer(&p))
-}
-
-func storeOpcodeSet(typ uintptr, set *OpcodeSet, m map[uintptr]*OpcodeSet) {
- newOpcodeMap := make(map[uintptr]*OpcodeSet, len(m)+1)
- newOpcodeMap[typ] = set
-
- for k, v := range m {
- newOpcodeMap[k] = v
- }
-
- atomic.StorePointer(&cachedOpcodeMap, *(*unsafe.Pointer)(unsafe.Pointer(&newOpcodeMap)))
-}
-
-func compileToGetCodeSetSlowPath(typeptr uintptr) (*OpcodeSet, error) {
- opcodeMap := loadOpcodeMap()
- if codeSet, exists := opcodeMap[typeptr]; exists {
- return codeSet, nil
- }
- codeSet, err := newCompiler().compile(typeptr)
- if err != nil {
- return nil, err
- }
- storeOpcodeSet(typeptr, codeSet, opcodeMap)
- return codeSet, nil
-}
-
-func getFilteredCodeSetIfNeeded(ctx *RuntimeContext, codeSet *OpcodeSet) (*OpcodeSet, error) {
- if (ctx.Option.Flag & ContextOption) == 0 {
- return codeSet, nil
- }
- query := FieldQueryFromContext(ctx.Option.Context)
- if query == nil {
- return codeSet, nil
- }
- ctx.Option.Flag |= FieldQueryOption
- cacheCodeSet := codeSet.getQueryCache(query.Hash())
- if cacheCodeSet != nil {
- return cacheCodeSet, nil
- }
- queryCodeSet, err := newCompiler().codeToOpcodeSet(codeSet.Type, codeSet.Code.Filter(query))
- if err != nil {
- return nil, err
- }
- codeSet.setQueryCache(query.Hash(), queryCodeSet)
- return queryCodeSet, nil
-}
-
-type Compiler struct {
- structTypeToCode map[uintptr]*StructCode
-}
-
-func newCompiler() *Compiler {
- return &Compiler{
- structTypeToCode: map[uintptr]*StructCode{},
- }
-}
-
-func (c *Compiler) compile(typeptr uintptr) (*OpcodeSet, error) {
- // noescape trick for header.typ ( reflect.*rtype )
- typ := *(**runtime.Type)(unsafe.Pointer(&typeptr))
- code, err := c.typeToCode(typ)
- if err != nil {
- return nil, err
- }
- return c.codeToOpcodeSet(typ, code)
-}
-
-func (c *Compiler) codeToOpcodeSet(typ *runtime.Type, code Code) (*OpcodeSet, error) {
- noescapeKeyCode := c.codeToOpcode(&compileContext{
- structTypeToCodes: map[uintptr]Opcodes{},
- recursiveCodes: &Opcodes{},
- }, typ, code)
- if err := noescapeKeyCode.Validate(); err != nil {
- return nil, err
- }
- escapeKeyCode := c.codeToOpcode(&compileContext{
- structTypeToCodes: map[uintptr]Opcodes{},
- recursiveCodes: &Opcodes{},
- escapeKey: true,
- }, typ, code)
- noescapeKeyCode = copyOpcode(noescapeKeyCode)
- escapeKeyCode = copyOpcode(escapeKeyCode)
- setTotalLengthToInterfaceOp(noescapeKeyCode)
- setTotalLengthToInterfaceOp(escapeKeyCode)
- interfaceNoescapeKeyCode := copyToInterfaceOpcode(noescapeKeyCode)
- interfaceEscapeKeyCode := copyToInterfaceOpcode(escapeKeyCode)
- codeLength := noescapeKeyCode.TotalLength()
- return &OpcodeSet{
- Type: typ,
- NoescapeKeyCode: noescapeKeyCode,
- EscapeKeyCode: escapeKeyCode,
- InterfaceNoescapeKeyCode: interfaceNoescapeKeyCode,
- InterfaceEscapeKeyCode: interfaceEscapeKeyCode,
- CodeLength: codeLength,
- EndCode: ToEndCode(interfaceNoescapeKeyCode),
- Code: code,
- QueryCache: map[string]*OpcodeSet{},
- }, nil
-}
-
-func (c *Compiler) typeToCode(typ *runtime.Type) (Code, error) {
- switch {
- case c.implementsMarshalJSON(typ):
- return c.marshalJSONCode(typ)
- case c.implementsMarshalText(typ):
- return c.marshalTextCode(typ)
- }
-
- isPtr := false
- orgType := typ
- if typ.Kind() == reflect.Ptr {
- typ = typ.Elem()
- isPtr = true
- }
- switch {
- case c.implementsMarshalJSON(typ):
- return c.marshalJSONCode(orgType)
- case c.implementsMarshalText(typ):
- return c.marshalTextCode(orgType)
- }
- switch typ.Kind() {
- case reflect.Slice:
- elem := typ.Elem()
- if elem.Kind() == reflect.Uint8 {
- p := runtime.PtrTo(elem)
- if !c.implementsMarshalJSONType(p) && !p.Implements(marshalTextType) {
- return c.bytesCode(typ, isPtr)
- }
- }
- return c.sliceCode(typ)
- case reflect.Map:
- if isPtr {
- return c.ptrCode(runtime.PtrTo(typ))
- }
- return c.mapCode(typ)
- case reflect.Struct:
- return c.structCode(typ, isPtr)
- case reflect.Int:
- return c.intCode(typ, isPtr)
- case reflect.Int8:
- return c.int8Code(typ, isPtr)
- case reflect.Int16:
- return c.int16Code(typ, isPtr)
- case reflect.Int32:
- return c.int32Code(typ, isPtr)
- case reflect.Int64:
- return c.int64Code(typ, isPtr)
- case reflect.Uint, reflect.Uintptr:
- return c.uintCode(typ, isPtr)
- case reflect.Uint8:
- return c.uint8Code(typ, isPtr)
- case reflect.Uint16:
- return c.uint16Code(typ, isPtr)
- case reflect.Uint32:
- return c.uint32Code(typ, isPtr)
- case reflect.Uint64:
- return c.uint64Code(typ, isPtr)
- case reflect.Float32:
- return c.float32Code(typ, isPtr)
- case reflect.Float64:
- return c.float64Code(typ, isPtr)
- case reflect.String:
- return c.stringCode(typ, isPtr)
- case reflect.Bool:
- return c.boolCode(typ, isPtr)
- case reflect.Interface:
- return c.interfaceCode(typ, isPtr)
- default:
- if isPtr && typ.Implements(marshalTextType) {
- typ = orgType
- }
- return c.typeToCodeWithPtr(typ, isPtr)
- }
-}
-
-func (c *Compiler) typeToCodeWithPtr(typ *runtime.Type, isPtr bool) (Code, error) {
- switch {
- case c.implementsMarshalJSON(typ):
- return c.marshalJSONCode(typ)
- case c.implementsMarshalText(typ):
- return c.marshalTextCode(typ)
- }
- switch typ.Kind() {
- case reflect.Ptr:
- return c.ptrCode(typ)
- case reflect.Slice:
- elem := typ.Elem()
- if elem.Kind() == reflect.Uint8 {
- p := runtime.PtrTo(elem)
- if !c.implementsMarshalJSONType(p) && !p.Implements(marshalTextType) {
- return c.bytesCode(typ, false)
- }
- }
- return c.sliceCode(typ)
- case reflect.Array:
- return c.arrayCode(typ)
- case reflect.Map:
- return c.mapCode(typ)
- case reflect.Struct:
- return c.structCode(typ, isPtr)
- case reflect.Interface:
- return c.interfaceCode(typ, false)
- case reflect.Int:
- return c.intCode(typ, false)
- case reflect.Int8:
- return c.int8Code(typ, false)
- case reflect.Int16:
- return c.int16Code(typ, false)
- case reflect.Int32:
- return c.int32Code(typ, false)
- case reflect.Int64:
- return c.int64Code(typ, false)
- case reflect.Uint:
- return c.uintCode(typ, false)
- case reflect.Uint8:
- return c.uint8Code(typ, false)
- case reflect.Uint16:
- return c.uint16Code(typ, false)
- case reflect.Uint32:
- return c.uint32Code(typ, false)
- case reflect.Uint64:
- return c.uint64Code(typ, false)
- case reflect.Uintptr:
- return c.uintCode(typ, false)
- case reflect.Float32:
- return c.float32Code(typ, false)
- case reflect.Float64:
- return c.float64Code(typ, false)
- case reflect.String:
- return c.stringCode(typ, false)
- case reflect.Bool:
- return c.boolCode(typ, false)
- }
- return nil, &errors.UnsupportedTypeError{Type: runtime.RType2Type(typ)}
-}
-
-const intSize = 32 << (^uint(0) >> 63)
-
-//nolint:unparam
-func (c *Compiler) intCode(typ *runtime.Type, isPtr bool) (*IntCode, error) {
- return &IntCode{typ: typ, bitSize: intSize, isPtr: isPtr}, nil
-}
-
-//nolint:unparam
-func (c *Compiler) int8Code(typ *runtime.Type, isPtr bool) (*IntCode, error) {
- return &IntCode{typ: typ, bitSize: 8, isPtr: isPtr}, nil
-}
-
-//nolint:unparam
-func (c *Compiler) int16Code(typ *runtime.Type, isPtr bool) (*IntCode, error) {
- return &IntCode{typ: typ, bitSize: 16, isPtr: isPtr}, nil
-}
-
-//nolint:unparam
-func (c *Compiler) int32Code(typ *runtime.Type, isPtr bool) (*IntCode, error) {
- return &IntCode{typ: typ, bitSize: 32, isPtr: isPtr}, nil
-}
-
-//nolint:unparam
-func (c *Compiler) int64Code(typ *runtime.Type, isPtr bool) (*IntCode, error) {
- return &IntCode{typ: typ, bitSize: 64, isPtr: isPtr}, nil
-}
-
-//nolint:unparam
-func (c *Compiler) uintCode(typ *runtime.Type, isPtr bool) (*UintCode, error) {
- return &UintCode{typ: typ, bitSize: intSize, isPtr: isPtr}, nil
-}
-
-//nolint:unparam
-func (c *Compiler) uint8Code(typ *runtime.Type, isPtr bool) (*UintCode, error) {
- return &UintCode{typ: typ, bitSize: 8, isPtr: isPtr}, nil
-}
-
-//nolint:unparam
-func (c *Compiler) uint16Code(typ *runtime.Type, isPtr bool) (*UintCode, error) {
- return &UintCode{typ: typ, bitSize: 16, isPtr: isPtr}, nil
-}
-
-//nolint:unparam
-func (c *Compiler) uint32Code(typ *runtime.Type, isPtr bool) (*UintCode, error) {
- return &UintCode{typ: typ, bitSize: 32, isPtr: isPtr}, nil
-}
-
-//nolint:unparam
-func (c *Compiler) uint64Code(typ *runtime.Type, isPtr bool) (*UintCode, error) {
- return &UintCode{typ: typ, bitSize: 64, isPtr: isPtr}, nil
-}
-
-//nolint:unparam
-func (c *Compiler) float32Code(typ *runtime.Type, isPtr bool) (*FloatCode, error) {
- return &FloatCode{typ: typ, bitSize: 32, isPtr: isPtr}, nil
-}
-
-//nolint:unparam
-func (c *Compiler) float64Code(typ *runtime.Type, isPtr bool) (*FloatCode, error) {
- return &FloatCode{typ: typ, bitSize: 64, isPtr: isPtr}, nil
-}
-
-//nolint:unparam
-func (c *Compiler) stringCode(typ *runtime.Type, isPtr bool) (*StringCode, error) {
- return &StringCode{typ: typ, isPtr: isPtr}, nil
-}
-
-//nolint:unparam
-func (c *Compiler) boolCode(typ *runtime.Type, isPtr bool) (*BoolCode, error) {
- return &BoolCode{typ: typ, isPtr: isPtr}, nil
-}
-
-//nolint:unparam
-func (c *Compiler) intStringCode(typ *runtime.Type) (*IntCode, error) {
- return &IntCode{typ: typ, bitSize: intSize, isString: true}, nil
-}
-
-//nolint:unparam
-func (c *Compiler) int8StringCode(typ *runtime.Type) (*IntCode, error) {
- return &IntCode{typ: typ, bitSize: 8, isString: true}, nil
-}
-
-//nolint:unparam
-func (c *Compiler) int16StringCode(typ *runtime.Type) (*IntCode, error) {
- return &IntCode{typ: typ, bitSize: 16, isString: true}, nil
-}
-
-//nolint:unparam
-func (c *Compiler) int32StringCode(typ *runtime.Type) (*IntCode, error) {
- return &IntCode{typ: typ, bitSize: 32, isString: true}, nil
-}
-
-//nolint:unparam
-func (c *Compiler) int64StringCode(typ *runtime.Type) (*IntCode, error) {
- return &IntCode{typ: typ, bitSize: 64, isString: true}, nil
-}
-
-//nolint:unparam
-func (c *Compiler) uintStringCode(typ *runtime.Type) (*UintCode, error) {
- return &UintCode{typ: typ, bitSize: intSize, isString: true}, nil
-}
-
-//nolint:unparam
-func (c *Compiler) uint8StringCode(typ *runtime.Type) (*UintCode, error) {
- return &UintCode{typ: typ, bitSize: 8, isString: true}, nil
-}
-
-//nolint:unparam
-func (c *Compiler) uint16StringCode(typ *runtime.Type) (*UintCode, error) {
- return &UintCode{typ: typ, bitSize: 16, isString: true}, nil
-}
-
-//nolint:unparam
-func (c *Compiler) uint32StringCode(typ *runtime.Type) (*UintCode, error) {
- return &UintCode{typ: typ, bitSize: 32, isString: true}, nil
-}
-
-//nolint:unparam
-func (c *Compiler) uint64StringCode(typ *runtime.Type) (*UintCode, error) {
- return &UintCode{typ: typ, bitSize: 64, isString: true}, nil
-}
-
-//nolint:unparam
-func (c *Compiler) bytesCode(typ *runtime.Type, isPtr bool) (*BytesCode, error) {
- return &BytesCode{typ: typ, isPtr: isPtr}, nil
-}
-
-//nolint:unparam
-func (c *Compiler) interfaceCode(typ *runtime.Type, isPtr bool) (*InterfaceCode, error) {
- return &InterfaceCode{typ: typ, isPtr: isPtr}, nil
-}
-
-//nolint:unparam
-func (c *Compiler) marshalJSONCode(typ *runtime.Type) (*MarshalJSONCode, error) {
- return &MarshalJSONCode{
- typ: typ,
- isAddrForMarshaler: c.isPtrMarshalJSONType(typ),
- isNilableType: c.isNilableType(typ),
- isMarshalerContext: typ.Implements(marshalJSONContextType) || runtime.PtrTo(typ).Implements(marshalJSONContextType),
- }, nil
-}
-
-//nolint:unparam
-func (c *Compiler) marshalTextCode(typ *runtime.Type) (*MarshalTextCode, error) {
- return &MarshalTextCode{
- typ: typ,
- isAddrForMarshaler: c.isPtrMarshalTextType(typ),
- isNilableType: c.isNilableType(typ),
- }, nil
-}
-
-func (c *Compiler) ptrCode(typ *runtime.Type) (*PtrCode, error) {
- code, err := c.typeToCodeWithPtr(typ.Elem(), true)
- if err != nil {
- return nil, err
- }
- ptr, ok := code.(*PtrCode)
- if ok {
- return &PtrCode{typ: typ, value: ptr.value, ptrNum: ptr.ptrNum + 1}, nil
- }
- return &PtrCode{typ: typ, value: code, ptrNum: 1}, nil
-}
-
-func (c *Compiler) sliceCode(typ *runtime.Type) (*SliceCode, error) {
- elem := typ.Elem()
- code, err := c.listElemCode(elem)
- if err != nil {
- return nil, err
- }
- if code.Kind() == CodeKindStruct {
- structCode := code.(*StructCode)
- structCode.enableIndirect()
- }
- return &SliceCode{typ: typ, value: code}, nil
-}
-
-func (c *Compiler) arrayCode(typ *runtime.Type) (*ArrayCode, error) {
- elem := typ.Elem()
- code, err := c.listElemCode(elem)
- if err != nil {
- return nil, err
- }
- if code.Kind() == CodeKindStruct {
- structCode := code.(*StructCode)
- structCode.enableIndirect()
- }
- return &ArrayCode{typ: typ, value: code}, nil
-}
-
-func (c *Compiler) mapCode(typ *runtime.Type) (*MapCode, error) {
- keyCode, err := c.mapKeyCode(typ.Key())
- if err != nil {
- return nil, err
- }
- valueCode, err := c.mapValueCode(typ.Elem())
- if err != nil {
- return nil, err
- }
- if valueCode.Kind() == CodeKindStruct {
- structCode := valueCode.(*StructCode)
- structCode.enableIndirect()
- }
- return &MapCode{typ: typ, key: keyCode, value: valueCode}, nil
-}
-
-func (c *Compiler) listElemCode(typ *runtime.Type) (Code, error) {
- switch {
- case c.implementsMarshalJSONType(typ) || c.implementsMarshalJSONType(runtime.PtrTo(typ)):
- return c.marshalJSONCode(typ)
- case !typ.Implements(marshalTextType) && runtime.PtrTo(typ).Implements(marshalTextType):
- return c.marshalTextCode(typ)
- case typ.Kind() == reflect.Map:
- return c.ptrCode(runtime.PtrTo(typ))
- default:
- // isPtr was originally used to indicate whether the type of top level is pointer.
- // However, since the slice/array element is a specification that can get the pointer address, explicitly set isPtr to true.
- // See here for related issues: https://github.com/goccy/go-json/issues/370
- code, err := c.typeToCodeWithPtr(typ, true)
- if err != nil {
- return nil, err
- }
- ptr, ok := code.(*PtrCode)
- if ok {
- if ptr.value.Kind() == CodeKindMap {
- ptr.ptrNum++
- }
- }
- return code, nil
- }
-}
-
-func (c *Compiler) mapKeyCode(typ *runtime.Type) (Code, error) {
- switch {
- case c.implementsMarshalText(typ):
- return c.marshalTextCode(typ)
- }
- switch typ.Kind() {
- case reflect.Ptr:
- return c.ptrCode(typ)
- case reflect.String:
- return c.stringCode(typ, false)
- case reflect.Int:
- return c.intStringCode(typ)
- case reflect.Int8:
- return c.int8StringCode(typ)
- case reflect.Int16:
- return c.int16StringCode(typ)
- case reflect.Int32:
- return c.int32StringCode(typ)
- case reflect.Int64:
- return c.int64StringCode(typ)
- case reflect.Uint:
- return c.uintStringCode(typ)
- case reflect.Uint8:
- return c.uint8StringCode(typ)
- case reflect.Uint16:
- return c.uint16StringCode(typ)
- case reflect.Uint32:
- return c.uint32StringCode(typ)
- case reflect.Uint64:
- return c.uint64StringCode(typ)
- case reflect.Uintptr:
- return c.uintStringCode(typ)
- }
- return nil, &errors.UnsupportedTypeError{Type: runtime.RType2Type(typ)}
-}
-
-func (c *Compiler) mapValueCode(typ *runtime.Type) (Code, error) {
- switch typ.Kind() {
- case reflect.Map:
- return c.ptrCode(runtime.PtrTo(typ))
- default:
- code, err := c.typeToCodeWithPtr(typ, false)
- if err != nil {
- return nil, err
- }
- ptr, ok := code.(*PtrCode)
- if ok {
- if ptr.value.Kind() == CodeKindMap {
- ptr.ptrNum++
- }
- }
- return code, nil
- }
-}
-
-func (c *Compiler) structCode(typ *runtime.Type, isPtr bool) (*StructCode, error) {
- typeptr := uintptr(unsafe.Pointer(typ))
- if code, exists := c.structTypeToCode[typeptr]; exists {
- derefCode := *code
- derefCode.isRecursive = true
- return &derefCode, nil
- }
- indirect := runtime.IfaceIndir(typ)
- code := &StructCode{typ: typ, isPtr: isPtr, isIndirect: indirect}
- c.structTypeToCode[typeptr] = code
-
- fieldNum := typ.NumField()
- tags := c.typeToStructTags(typ)
- fields := []*StructFieldCode{}
- for i, tag := range tags {
- isOnlyOneFirstField := i == 0 && fieldNum == 1
- field, err := c.structFieldCode(code, tag, isPtr, isOnlyOneFirstField)
- if err != nil {
- return nil, err
- }
- if field.isAnonymous {
- structCode := field.getAnonymousStruct()
- if structCode != nil {
- structCode.removeFieldsByTags(tags)
- if c.isAssignableIndirect(field, isPtr) {
- if indirect {
- structCode.isIndirect = true
- } else {
- structCode.isIndirect = false
- }
- }
- }
- } else {
- structCode := field.getStruct()
- if structCode != nil {
- if indirect {
- // if parent is indirect type, set child indirect property to true
- structCode.isIndirect = true
- } else {
- // if parent is not indirect type, set child indirect property to false.
- // but if parent's indirect is false and isPtr is true, then indirect must be true.
- // Do this only if indirectConversion is enabled at the end of compileStruct.
- structCode.isIndirect = false
- }
- }
- }
- fields = append(fields, field)
- }
- fieldMap := c.getFieldMap(fields)
- duplicatedFieldMap := c.getDuplicatedFieldMap(fieldMap)
- code.fields = c.filteredDuplicatedFields(fields, duplicatedFieldMap)
- if !code.disableIndirectConversion && !indirect && isPtr {
- code.enableIndirect()
- }
- delete(c.structTypeToCode, typeptr)
- return code, nil
-}
-
-func toElemType(t *runtime.Type) *runtime.Type {
- for t.Kind() == reflect.Ptr {
- t = t.Elem()
- }
- return t
-}
-
-func (c *Compiler) structFieldCode(structCode *StructCode, tag *runtime.StructTag, isPtr, isOnlyOneFirstField bool) (*StructFieldCode, error) {
- field := tag.Field
- fieldType := runtime.Type2RType(field.Type)
- isIndirectSpecialCase := isPtr && isOnlyOneFirstField
- fieldCode := &StructFieldCode{
- typ: fieldType,
- key: tag.Key,
- tag: tag,
- offset: field.Offset,
- isAnonymous: field.Anonymous && !tag.IsTaggedKey && toElemType(fieldType).Kind() == reflect.Struct,
- isTaggedKey: tag.IsTaggedKey,
- isNilableType: c.isNilableType(fieldType),
- isNilCheck: true,
- }
- switch {
- case c.isMovePointerPositionFromHeadToFirstMarshalJSONFieldCase(fieldType, isIndirectSpecialCase):
- code, err := c.marshalJSONCode(fieldType)
- if err != nil {
- return nil, err
- }
- fieldCode.value = code
- fieldCode.isAddrForMarshaler = true
- fieldCode.isNilCheck = false
- structCode.isIndirect = false
- structCode.disableIndirectConversion = true
- case c.isMovePointerPositionFromHeadToFirstMarshalTextFieldCase(fieldType, isIndirectSpecialCase):
- code, err := c.marshalTextCode(fieldType)
- if err != nil {
- return nil, err
- }
- fieldCode.value = code
- fieldCode.isAddrForMarshaler = true
- fieldCode.isNilCheck = false
- structCode.isIndirect = false
- structCode.disableIndirectConversion = true
- case isPtr && c.isPtrMarshalJSONType(fieldType):
- // *struct{ field T }
- // func (*T) MarshalJSON() ([]byte, error)
- code, err := c.marshalJSONCode(fieldType)
- if err != nil {
- return nil, err
- }
- fieldCode.value = code
- fieldCode.isAddrForMarshaler = true
- fieldCode.isNilCheck = false
- case isPtr && c.isPtrMarshalTextType(fieldType):
- // *struct{ field T }
- // func (*T) MarshalText() ([]byte, error)
- code, err := c.marshalTextCode(fieldType)
- if err != nil {
- return nil, err
- }
- fieldCode.value = code
- fieldCode.isAddrForMarshaler = true
- fieldCode.isNilCheck = false
- default:
- code, err := c.typeToCodeWithPtr(fieldType, isPtr)
- if err != nil {
- return nil, err
- }
- switch code.Kind() {
- case CodeKindPtr, CodeKindInterface:
- fieldCode.isNextOpPtrType = true
- }
- fieldCode.value = code
- }
- return fieldCode, nil
-}
-
-func (c *Compiler) isAssignableIndirect(fieldCode *StructFieldCode, isPtr bool) bool {
- if isPtr {
- return false
- }
- codeType := fieldCode.value.Kind()
- if codeType == CodeKindMarshalJSON {
- return false
- }
- if codeType == CodeKindMarshalText {
- return false
- }
- return true
-}
-
-func (c *Compiler) getFieldMap(fields []*StructFieldCode) map[string][]*StructFieldCode {
- fieldMap := map[string][]*StructFieldCode{}
- for _, field := range fields {
- if field.isAnonymous {
- for k, v := range c.getAnonymousFieldMap(field) {
- fieldMap[k] = append(fieldMap[k], v...)
- }
- continue
- }
- fieldMap[field.key] = append(fieldMap[field.key], field)
- }
- return fieldMap
-}
-
-func (c *Compiler) getAnonymousFieldMap(field *StructFieldCode) map[string][]*StructFieldCode {
- fieldMap := map[string][]*StructFieldCode{}
- structCode := field.getAnonymousStruct()
- if structCode == nil || structCode.isRecursive {
- fieldMap[field.key] = append(fieldMap[field.key], field)
- return fieldMap
- }
- for k, v := range c.getFieldMapFromAnonymousParent(structCode.fields) {
- fieldMap[k] = append(fieldMap[k], v...)
- }
- return fieldMap
-}
-
-func (c *Compiler) getFieldMapFromAnonymousParent(fields []*StructFieldCode) map[string][]*StructFieldCode {
- fieldMap := map[string][]*StructFieldCode{}
- for _, field := range fields {
- if field.isAnonymous {
- for k, v := range c.getAnonymousFieldMap(field) {
- // Do not handle tagged key when embedding more than once
- for _, vv := range v {
- vv.isTaggedKey = false
- }
- fieldMap[k] = append(fieldMap[k], v...)
- }
- continue
- }
- fieldMap[field.key] = append(fieldMap[field.key], field)
- }
- return fieldMap
-}
-
-func (c *Compiler) getDuplicatedFieldMap(fieldMap map[string][]*StructFieldCode) map[*StructFieldCode]struct{} {
- duplicatedFieldMap := map[*StructFieldCode]struct{}{}
- for _, fields := range fieldMap {
- if len(fields) == 1 {
- continue
- }
- if c.isTaggedKeyOnly(fields) {
- for _, field := range fields {
- if field.isTaggedKey {
- continue
- }
- duplicatedFieldMap[field] = struct{}{}
- }
- } else {
- for _, field := range fields {
- duplicatedFieldMap[field] = struct{}{}
- }
- }
- }
- return duplicatedFieldMap
-}
-
-func (c *Compiler) filteredDuplicatedFields(fields []*StructFieldCode, duplicatedFieldMap map[*StructFieldCode]struct{}) []*StructFieldCode {
- filteredFields := make([]*StructFieldCode, 0, len(fields))
- for _, field := range fields {
- if field.isAnonymous {
- structCode := field.getAnonymousStruct()
- if structCode != nil && !structCode.isRecursive {
- structCode.fields = c.filteredDuplicatedFields(structCode.fields, duplicatedFieldMap)
- if len(structCode.fields) > 0 {
- filteredFields = append(filteredFields, field)
- }
- continue
- }
- }
- if _, exists := duplicatedFieldMap[field]; exists {
- continue
- }
- filteredFields = append(filteredFields, field)
- }
- return filteredFields
-}
-
-func (c *Compiler) isTaggedKeyOnly(fields []*StructFieldCode) bool {
- var taggedKeyFieldCount int
- for _, field := range fields {
- if field.isTaggedKey {
- taggedKeyFieldCount++
- }
- }
- return taggedKeyFieldCount == 1
-}
-
-func (c *Compiler) typeToStructTags(typ *runtime.Type) runtime.StructTags {
- tags := runtime.StructTags{}
- fieldNum := typ.NumField()
- for i := 0; i < fieldNum; i++ {
- field := typ.Field(i)
- if runtime.IsIgnoredStructField(field) {
- continue
- }
- tags = append(tags, runtime.StructTagFromField(field))
- }
- return tags
-}
-
-// *struct{ field T } => struct { field *T }
-// func (*T) MarshalJSON() ([]byte, error)
-func (c *Compiler) isMovePointerPositionFromHeadToFirstMarshalJSONFieldCase(typ *runtime.Type, isIndirectSpecialCase bool) bool {
- return isIndirectSpecialCase && !c.isNilableType(typ) && c.isPtrMarshalJSONType(typ)
-}
-
-// *struct{ field T } => struct { field *T }
-// func (*T) MarshalText() ([]byte, error)
-func (c *Compiler) isMovePointerPositionFromHeadToFirstMarshalTextFieldCase(typ *runtime.Type, isIndirectSpecialCase bool) bool {
- return isIndirectSpecialCase && !c.isNilableType(typ) && c.isPtrMarshalTextType(typ)
-}
-
-func (c *Compiler) implementsMarshalJSON(typ *runtime.Type) bool {
- if !c.implementsMarshalJSONType(typ) {
- return false
- }
- if typ.Kind() != reflect.Ptr {
- return true
- }
- // type kind is reflect.Ptr
- if !c.implementsMarshalJSONType(typ.Elem()) {
- return true
- }
- // needs to dereference
- return false
-}
-
-func (c *Compiler) implementsMarshalText(typ *runtime.Type) bool {
- if !typ.Implements(marshalTextType) {
- return false
- }
- if typ.Kind() != reflect.Ptr {
- return true
- }
- // type kind is reflect.Ptr
- if !typ.Elem().Implements(marshalTextType) {
- return true
- }
- // needs to dereference
- return false
-}
-
-func (c *Compiler) isNilableType(typ *runtime.Type) bool {
- if !runtime.IfaceIndir(typ) {
- return true
- }
- switch typ.Kind() {
- case reflect.Ptr:
- return true
- case reflect.Map:
- return true
- case reflect.Func:
- return true
- default:
- return false
- }
-}
-
-func (c *Compiler) implementsMarshalJSONType(typ *runtime.Type) bool {
- return typ.Implements(marshalJSONType) || typ.Implements(marshalJSONContextType)
-}
-
-func (c *Compiler) isPtrMarshalJSONType(typ *runtime.Type) bool {
- return !c.implementsMarshalJSONType(typ) && c.implementsMarshalJSONType(runtime.PtrTo(typ))
-}
-
-func (c *Compiler) isPtrMarshalTextType(typ *runtime.Type) bool {
- return !typ.Implements(marshalTextType) && runtime.PtrTo(typ).Implements(marshalTextType)
-}
-
-func (c *Compiler) codeToOpcode(ctx *compileContext, typ *runtime.Type, code Code) *Opcode {
- codes := code.ToOpcode(ctx)
- codes.Last().Next = newEndOp(ctx, typ)
- c.linkRecursiveCode(ctx)
- return codes.First()
-}
-
-func (c *Compiler) linkRecursiveCode(ctx *compileContext) {
- recursiveCodes := map[uintptr]*CompiledCode{}
- for _, recursive := range *ctx.recursiveCodes {
- typeptr := uintptr(unsafe.Pointer(recursive.Type))
- codes := ctx.structTypeToCodes[typeptr]
- if recursiveCode, ok := recursiveCodes[typeptr]; ok {
- *recursive.Jmp = *recursiveCode
- continue
- }
-
- code := copyOpcode(codes.First())
- code.Op = code.Op.PtrHeadToHead()
- lastCode := newEndOp(&compileContext{}, recursive.Type)
- lastCode.Op = OpRecursiveEnd
-
- // OpRecursiveEnd must set before call TotalLength
- code.End.Next = lastCode
-
- totalLength := code.TotalLength()
-
- // Idx, ElemIdx, Length must set after call TotalLength
- lastCode.Idx = uint32((totalLength + 1) * uintptrSize)
- lastCode.ElemIdx = lastCode.Idx + uintptrSize
- lastCode.Length = lastCode.Idx + 2*uintptrSize
-
- // extend length to alloc slot for elemIdx + length
- curTotalLength := uintptr(recursive.TotalLength()) + 3
- nextTotalLength := uintptr(totalLength) + 3
-
- compiled := recursive.Jmp
- compiled.Code = code
- compiled.CurLen = curTotalLength
- compiled.NextLen = nextTotalLength
- compiled.Linked = true
-
- recursiveCodes[typeptr] = compiled
- }
-}
diff --git a/vendor/github.com/goccy/go-json/internal/encoder/compiler_norace.go b/vendor/github.com/goccy/go-json/internal/encoder/compiler_norace.go
deleted file mode 100644
index b6f45a49..00000000
--- a/vendor/github.com/goccy/go-json/internal/encoder/compiler_norace.go
+++ /dev/null
@@ -1,33 +0,0 @@
-//go:build !race
-// +build !race
-
-package encoder
-
-func CompileToGetCodeSet(ctx *RuntimeContext, typeptr uintptr) (*OpcodeSet, error) {
- initEncoder()
- if typeptr > typeAddr.MaxTypeAddr || typeptr < typeAddr.BaseTypeAddr {
- codeSet, err := compileToGetCodeSetSlowPath(typeptr)
- if err != nil {
- return nil, err
- }
- return getFilteredCodeSetIfNeeded(ctx, codeSet)
- }
- index := (typeptr - typeAddr.BaseTypeAddr) >> typeAddr.AddrShift
- if codeSet := cachedOpcodeSets[index]; codeSet != nil {
- filtered, err := getFilteredCodeSetIfNeeded(ctx, codeSet)
- if err != nil {
- return nil, err
- }
- return filtered, nil
- }
- codeSet, err := newCompiler().compile(typeptr)
- if err != nil {
- return nil, err
- }
- filtered, err := getFilteredCodeSetIfNeeded(ctx, codeSet)
- if err != nil {
- return nil, err
- }
- cachedOpcodeSets[index] = codeSet
- return filtered, nil
-}
diff --git a/vendor/github.com/goccy/go-json/internal/encoder/compiler_race.go b/vendor/github.com/goccy/go-json/internal/encoder/compiler_race.go
deleted file mode 100644
index 47b482f7..00000000
--- a/vendor/github.com/goccy/go-json/internal/encoder/compiler_race.go
+++ /dev/null
@@ -1,46 +0,0 @@
-//go:build race
-// +build race
-
-package encoder
-
-import (
- "sync"
-)
-
-var setsMu sync.RWMutex
-
-func CompileToGetCodeSet(ctx *RuntimeContext, typeptr uintptr) (*OpcodeSet, error) {
- initEncoder()
- if typeptr > typeAddr.MaxTypeAddr || typeptr < typeAddr.BaseTypeAddr {
- codeSet, err := compileToGetCodeSetSlowPath(typeptr)
- if err != nil {
- return nil, err
- }
- return getFilteredCodeSetIfNeeded(ctx, codeSet)
- }
- index := (typeptr - typeAddr.BaseTypeAddr) >> typeAddr.AddrShift
- setsMu.RLock()
- if codeSet := cachedOpcodeSets[index]; codeSet != nil {
- filtered, err := getFilteredCodeSetIfNeeded(ctx, codeSet)
- if err != nil {
- setsMu.RUnlock()
- return nil, err
- }
- setsMu.RUnlock()
- return filtered, nil
- }
- setsMu.RUnlock()
-
- codeSet, err := newCompiler().compile(typeptr)
- if err != nil {
- return nil, err
- }
- filtered, err := getFilteredCodeSetIfNeeded(ctx, codeSet)
- if err != nil {
- return nil, err
- }
- setsMu.Lock()
- cachedOpcodeSets[index] = codeSet
- setsMu.Unlock()
- return filtered, nil
-}
diff --git a/vendor/github.com/goccy/go-json/internal/encoder/context.go b/vendor/github.com/goccy/go-json/internal/encoder/context.go
deleted file mode 100644
index 3833d0c8..00000000
--- a/vendor/github.com/goccy/go-json/internal/encoder/context.go
+++ /dev/null
@@ -1,105 +0,0 @@
-package encoder
-
-import (
- "context"
- "sync"
- "unsafe"
-
- "github.com/goccy/go-json/internal/runtime"
-)
-
-type compileContext struct {
- opcodeIndex uint32
- ptrIndex int
- indent uint32
- escapeKey bool
- structTypeToCodes map[uintptr]Opcodes
- recursiveCodes *Opcodes
-}
-
-func (c *compileContext) incIndent() {
- c.indent++
-}
-
-func (c *compileContext) decIndent() {
- c.indent--
-}
-
-func (c *compileContext) incIndex() {
- c.incOpcodeIndex()
- c.incPtrIndex()
-}
-
-func (c *compileContext) decIndex() {
- c.decOpcodeIndex()
- c.decPtrIndex()
-}
-
-func (c *compileContext) incOpcodeIndex() {
- c.opcodeIndex++
-}
-
-func (c *compileContext) decOpcodeIndex() {
- c.opcodeIndex--
-}
-
-func (c *compileContext) incPtrIndex() {
- c.ptrIndex++
-}
-
-func (c *compileContext) decPtrIndex() {
- c.ptrIndex--
-}
-
-const (
- bufSize = 1024
-)
-
-var (
- runtimeContextPool = sync.Pool{
- New: func() interface{} {
- return &RuntimeContext{
- Buf: make([]byte, 0, bufSize),
- Ptrs: make([]uintptr, 128),
- KeepRefs: make([]unsafe.Pointer, 0, 8),
- Option: &Option{},
- }
- },
- }
-)
-
-type RuntimeContext struct {
- Context context.Context
- Buf []byte
- MarshalBuf []byte
- Ptrs []uintptr
- KeepRefs []unsafe.Pointer
- SeenPtr []uintptr
- BaseIndent uint32
- Prefix []byte
- IndentStr []byte
- Option *Option
-}
-
-func (c *RuntimeContext) Init(p uintptr, codelen int) {
- if len(c.Ptrs) < codelen {
- c.Ptrs = make([]uintptr, codelen)
- }
- c.Ptrs[0] = p
- c.KeepRefs = c.KeepRefs[:0]
- c.SeenPtr = c.SeenPtr[:0]
- c.BaseIndent = 0
-}
-
-func (c *RuntimeContext) Ptr() uintptr {
- header := (*runtime.SliceHeader)(unsafe.Pointer(&c.Ptrs))
- return uintptr(header.Data)
-}
-
-func TakeRuntimeContext() *RuntimeContext {
- return runtimeContextPool.Get().(*RuntimeContext)
-}
-
-func ReleaseRuntimeContext(ctx *RuntimeContext) {
- runtimeContextPool.Put(ctx)
-}
diff --git a/vendor/github.com/goccy/go-json/internal/encoder/decode_rune.go b/vendor/github.com/goccy/go-json/internal/encoder/decode_rune.go
deleted file mode 100644
index 35c959d4..00000000
--- a/vendor/github.com/goccy/go-json/internal/encoder/decode_rune.go
+++ /dev/null
@@ -1,126 +0,0 @@
-package encoder
-
-import "unicode/utf8"
-
-const (
- // The default lowest and highest continuation byte.
- locb = 128 //0b10000000
- hicb = 191 //0b10111111
-
- // These names of these constants are chosen to give nice alignment in the
- // table below. The first nibble is an index into acceptRanges or F for
- // special one-byte cases. The second nibble is the Rune length or the
- // Status for the special one-byte case.
- xx = 0xF1 // invalid: size 1
- as = 0xF0 // ASCII: size 1
- s1 = 0x02 // accept 0, size 2
- s2 = 0x13 // accept 1, size 3
- s3 = 0x03 // accept 0, size 3
- s4 = 0x23 // accept 2, size 3
- s5 = 0x34 // accept 3, size 4
- s6 = 0x04 // accept 0, size 4
- s7 = 0x44 // accept 4, size 4
-)
-
-// first is information about the first byte in a UTF-8 sequence.
-var first = [256]uint8{
- // 1 2 3 4 5 6 7 8 9 A B C D E F
- as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, // 0x00-0x0F
- as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, // 0x10-0x1F
- as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, // 0x20-0x2F
- as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, // 0x30-0x3F
- as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, // 0x40-0x4F
- as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, // 0x50-0x5F
- as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, // 0x60-0x6F
- as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, as, // 0x70-0x7F
- // 1 2 3 4 5 6 7 8 9 A B C D E F
- xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, // 0x80-0x8F
- xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, // 0x90-0x9F
- xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, // 0xA0-0xAF
- xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, // 0xB0-0xBF
- xx, xx, s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, // 0xC0-0xCF
- s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, s1, // 0xD0-0xDF
- s2, s3, s3, s3, s3, s3, s3, s3, s3, s3, s3, s3, s3, s4, s3, s3, // 0xE0-0xEF
- s5, s6, s6, s6, s7, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, xx, // 0xF0-0xFF
-}
-
-const (
- lineSep = byte(168) //'\u2028'
- paragraphSep = byte(169) //'\u2029'
-)
-
-type decodeRuneState int
-
-const (
- validUTF8State decodeRuneState = iota
- runeErrorState
- lineSepState
- paragraphSepState
-)
-
-func decodeRuneInString(s string) (decodeRuneState, int) {
- n := len(s)
- s0 := s[0]
- x := first[s0]
- if x >= as {
- // The following code simulates an additional check for x == xx and
- // handling the ASCII and invalid cases accordingly. This mask-and-or
- // approach prevents an additional branch.
- mask := rune(x) << 31 >> 31 // Create 0x0000 or 0xFFFF.
- if rune(s[0])&^mask|utf8.RuneError&mask == utf8.RuneError {
- return runeErrorState, 1
- }
- return validUTF8State, 1
- }
- sz := int(x & 7)
- if n < sz {
- return runeErrorState, 1
- }
- s1 := s[1]
- switch x >> 4 {
- case 0:
- if s1 < locb || hicb < s1 {
- return runeErrorState, 1
- }
- case 1:
- if s1 < 0xA0 || hicb < s1 {
- return runeErrorState, 1
- }
- case 2:
- if s1 < locb || 0x9F < s1 {
- return runeErrorState, 1
- }
- case 3:
- if s1 < 0x90 || hicb < s1 {
- return runeErrorState, 1
- }
- case 4:
- if s1 < locb || 0x8F < s1 {
- return runeErrorState, 1
- }
- }
- if sz <= 2 {
- return validUTF8State, 2
- }
- s2 := s[2]
- if s2 < locb || hicb < s2 {
- return runeErrorState, 1
- }
- if sz <= 3 {
- // separator character prefixes: [2]byte{226, 128}
- if s0 == 226 && s1 == 128 {
- switch s2 {
- case lineSep:
- return lineSepState, 3
- case paragraphSep:
- return paragraphSepState, 3
- }
- }
- return validUTF8State, 3
- }
- s3 := s[3]
- if s3 < locb || hicb < s3 {
- return runeErrorState, 1
- }
- return validUTF8State, 4
-}
diff --git a/vendor/github.com/goccy/go-json/internal/encoder/encoder.go b/vendor/github.com/goccy/go-json/internal/encoder/encoder.go
deleted file mode 100644
index b436f5b2..00000000
--- a/vendor/github.com/goccy/go-json/internal/encoder/encoder.go
+++ /dev/null
@@ -1,601 +0,0 @@
-package encoder
-
-import (
- "bytes"
- "encoding"
- "encoding/base64"
- "encoding/json"
- "fmt"
- "math"
- "reflect"
- "strconv"
- "strings"
- "sync"
- "unsafe"
-
- "github.com/goccy/go-json/internal/errors"
- "github.com/goccy/go-json/internal/runtime"
-)
-
-func (t OpType) IsMultipleOpHead() bool {
- switch t {
- case OpStructHead:
- return true
- case OpStructHeadSlice:
- return true
- case OpStructHeadArray:
- return true
- case OpStructHeadMap:
- return true
- case OpStructHeadStruct:
- return true
- case OpStructHeadOmitEmpty:
- return true
- case OpStructHeadOmitEmptySlice:
- return true
- case OpStructHeadOmitEmptyArray:
- return true
- case OpStructHeadOmitEmptyMap:
- return true
- case OpStructHeadOmitEmptyStruct:
- return true
- case OpStructHeadSlicePtr:
- return true
- case OpStructHeadOmitEmptySlicePtr:
- return true
- case OpStructHeadArrayPtr:
- return true
- case OpStructHeadOmitEmptyArrayPtr:
- return true
- case OpStructHeadMapPtr:
- return true
- case OpStructHeadOmitEmptyMapPtr:
- return true
- }
- return false
-}
-
-func (t OpType) IsMultipleOpField() bool {
- switch t {
- case OpStructField:
- return true
- case OpStructFieldSlice:
- return true
- case OpStructFieldArray:
- return true
- case OpStructFieldMap:
- return true
- case OpStructFieldStruct:
- return true
- case OpStructFieldOmitEmpty:
- return true
- case OpStructFieldOmitEmptySlice:
- return true
- case OpStructFieldOmitEmptyArray:
- return true
- case OpStructFieldOmitEmptyMap:
- return true
- case OpStructFieldOmitEmptyStruct:
- return true
- case OpStructFieldSlicePtr:
- return true
- case OpStructFieldOmitEmptySlicePtr:
- return true
- case OpStructFieldArrayPtr:
- return true
- case OpStructFieldOmitEmptyArrayPtr:
- return true
- case OpStructFieldMapPtr:
- return true
- case OpStructFieldOmitEmptyMapPtr:
- return true
- }
- return false
-}
-
-type OpcodeSet struct {
- Type *runtime.Type
- NoescapeKeyCode *Opcode
- EscapeKeyCode *Opcode
- InterfaceNoescapeKeyCode *Opcode
- InterfaceEscapeKeyCode *Opcode
- CodeLength int
- EndCode *Opcode
- Code Code
- QueryCache map[string]*OpcodeSet
- cacheMu sync.RWMutex
-}
-
-func (s *OpcodeSet) getQueryCache(hash string) *OpcodeSet {
- s.cacheMu.RLock()
- codeSet := s.QueryCache[hash]
- s.cacheMu.RUnlock()
- return codeSet
-}
-
-func (s *OpcodeSet) setQueryCache(hash string, codeSet *OpcodeSet) {
- s.cacheMu.Lock()
- s.QueryCache[hash] = codeSet
- s.cacheMu.Unlock()
-}
-
-type CompiledCode struct {
- Code *Opcode
- Linked bool // whether recursive code already have linked
- CurLen uintptr
- NextLen uintptr
-}
-
-const StartDetectingCyclesAfter = 1000
-
-func Load(base uintptr, idx uintptr) uintptr {
- addr := base + idx
- return **(**uintptr)(unsafe.Pointer(&addr))
-}
-
-func Store(base uintptr, idx uintptr, p uintptr) {
- addr := base + idx
- **(**uintptr)(unsafe.Pointer(&addr)) = p
-}
-
-func LoadNPtr(base uintptr, idx uintptr, ptrNum int) uintptr {
- addr := base + idx
- p := **(**uintptr)(unsafe.Pointer(&addr))
- if p == 0 {
- return 0
- }
- return PtrToPtr(p)
- /*
- for i := 0; i < ptrNum; i++ {
- if p == 0 {
- return p
- }
- p = PtrToPtr(p)
- }
- return p
- */
-}
-
-func PtrToUint64(p uintptr) uint64 { return **(**uint64)(unsafe.Pointer(&p)) }
-func PtrToFloat32(p uintptr) float32 { return **(**float32)(unsafe.Pointer(&p)) }
-func PtrToFloat64(p uintptr) float64 { return **(**float64)(unsafe.Pointer(&p)) }
-func PtrToBool(p uintptr) bool { return **(**bool)(unsafe.Pointer(&p)) }
-func PtrToBytes(p uintptr) []byte { return **(**[]byte)(unsafe.Pointer(&p)) }
-func PtrToNumber(p uintptr) json.Number { return **(**json.Number)(unsafe.Pointer(&p)) }
-func PtrToString(p uintptr) string { return **(**string)(unsafe.Pointer(&p)) }
-func PtrToSlice(p uintptr) *runtime.SliceHeader { return *(**runtime.SliceHeader)(unsafe.Pointer(&p)) }
-func PtrToPtr(p uintptr) uintptr {
- return uintptr(**(**unsafe.Pointer)(unsafe.Pointer(&p)))
-}
-func PtrToNPtr(p uintptr, ptrNum int) uintptr {
- for i := 0; i < ptrNum; i++ {
- if p == 0 {
- return 0
- }
- p = PtrToPtr(p)
- }
- return p
-}
-
-func PtrToUnsafePtr(p uintptr) unsafe.Pointer {
- return *(*unsafe.Pointer)(unsafe.Pointer(&p))
-}
-func PtrToInterface(code *Opcode, p uintptr) interface{} {
- return *(*interface{})(unsafe.Pointer(&emptyInterface{
- typ: code.Type,
- ptr: *(*unsafe.Pointer)(unsafe.Pointer(&p)),
- }))
-}
-
-func ErrUnsupportedValue(code *Opcode, ptr uintptr) *errors.UnsupportedValueError {
- v := *(*interface{})(unsafe.Pointer(&emptyInterface{
- typ: code.Type,
- ptr: *(*unsafe.Pointer)(unsafe.Pointer(&ptr)),
- }))
- return &errors.UnsupportedValueError{
- Value: reflect.ValueOf(v),
- Str: fmt.Sprintf("encountered a cycle via %s", code.Type),
- }
-}
-
-func ErrUnsupportedFloat(v float64) *errors.UnsupportedValueError {
- return &errors.UnsupportedValueError{
- Value: reflect.ValueOf(v),
- Str: strconv.FormatFloat(v, 'g', -1, 64),
- }
-}
-
-func ErrMarshalerWithCode(code *Opcode, err error) *errors.MarshalerError {
- return &errors.MarshalerError{
- Type: runtime.RType2Type(code.Type),
- Err: err,
- }
-}
-
-type emptyInterface struct {
- typ *runtime.Type
- ptr unsafe.Pointer
-}
-
-type MapItem struct {
- Key []byte
- Value []byte
-}
-
-type Mapslice struct {
- Items []MapItem
-}
-
-func (m *Mapslice) Len() int {
- return len(m.Items)
-}
-
-func (m *Mapslice) Less(i, j int) bool {
- return bytes.Compare(m.Items[i].Key, m.Items[j].Key) < 0
-}
-
-func (m *Mapslice) Swap(i, j int) {
- m.Items[i], m.Items[j] = m.Items[j], m.Items[i]
-}
-
-//nolint:structcheck,unused
-type mapIter struct {
- key unsafe.Pointer
- elem unsafe.Pointer
- t unsafe.Pointer
- h unsafe.Pointer
- buckets unsafe.Pointer
- bptr unsafe.Pointer
- overflow unsafe.Pointer
- oldoverflow unsafe.Pointer
- startBucket uintptr
- offset uint8
- wrapped bool
- B uint8
- i uint8
- bucket uintptr
- checkBucket uintptr
-}
-
-type MapContext struct {
- Start int
- First int
- Idx int
- Slice *Mapslice
- Buf []byte
- Len int
- Iter mapIter
-}
-
-var mapContextPool = sync.Pool{
- New: func() interface{} {
- return &MapContext{
- Slice: &Mapslice{},
- }
- },
-}
-
-func NewMapContext(mapLen int, unorderedMap bool) *MapContext {
- ctx := mapContextPool.Get().(*MapContext)
- if !unorderedMap {
- if len(ctx.Slice.Items) < mapLen {
- ctx.Slice.Items = make([]MapItem, mapLen)
- } else {
- ctx.Slice.Items = ctx.Slice.Items[:mapLen]
- }
- }
- ctx.Buf = ctx.Buf[:0]
- ctx.Iter = mapIter{}
- ctx.Idx = 0
- ctx.Len = mapLen
- return ctx
-}
-
-func ReleaseMapContext(c *MapContext) {
- mapContextPool.Put(c)
-}
-
-//go:linkname MapIterInit runtime.mapiterinit
-//go:noescape
-func MapIterInit(mapType *runtime.Type, m unsafe.Pointer, it *mapIter)
-
-//go:linkname MapIterKey reflect.mapiterkey
-//go:noescape
-func MapIterKey(it *mapIter) unsafe.Pointer
-
-//go:linkname MapIterNext reflect.mapiternext
-//go:noescape
-func MapIterNext(it *mapIter)
-
-//go:linkname MapLen reflect.maplen
-//go:noescape
-func MapLen(m unsafe.Pointer) int
-
-func AppendByteSlice(_ *RuntimeContext, b []byte, src []byte) []byte {
- if src == nil {
- return append(b, `null`...)
- }
- encodedLen := base64.StdEncoding.EncodedLen(len(src))
- b = append(b, '"')
- pos := len(b)
- remainLen := cap(b[pos:])
- var buf []byte
- if remainLen > encodedLen {
- buf = b[pos : pos+encodedLen]
- } else {
- buf = make([]byte, encodedLen)
- }
- base64.StdEncoding.Encode(buf, src)
- return append(append(b, buf...), '"')
-}
-
-func AppendFloat32(_ *RuntimeContext, b []byte, v float32) []byte {
- f64 := float64(v)
- abs := math.Abs(f64)
- fmt := byte('f')
- // Note: Must use float32 comparisons for underlying float32 value to get precise cutoffs right.
- if abs != 0 {
- f32 := float32(abs)
- if f32 < 1e-6 || f32 >= 1e21 {
- fmt = 'e'
- }
- }
- return strconv.AppendFloat(b, f64, fmt, -1, 32)
-}
-
-func AppendFloat64(_ *RuntimeContext, b []byte, v float64) []byte {
- abs := math.Abs(v)
- fmt := byte('f')
- // Note: Must use float32 comparisons for underlying float32 value to get precise cutoffs right.
- if abs != 0 {
- if abs < 1e-6 || abs >= 1e21 {
- fmt = 'e'
- }
- }
- return strconv.AppendFloat(b, v, fmt, -1, 64)
-}
-
-func AppendBool(_ *RuntimeContext, b []byte, v bool) []byte {
- if v {
- return append(b, "true"...)
- }
- return append(b, "false"...)
-}
-
-var (
- floatTable = [256]bool{
- '0': true,
- '1': true,
- '2': true,
- '3': true,
- '4': true,
- '5': true,
- '6': true,
- '7': true,
- '8': true,
- '9': true,
- '.': true,
- 'e': true,
- 'E': true,
- '+': true,
- '-': true,
- }
-)
-
-func AppendNumber(_ *RuntimeContext, b []byte, n json.Number) ([]byte, error) {
- if len(n) == 0 {
- return append(b, '0'), nil
- }
- for i := 0; i < len(n); i++ {
- if !floatTable[n[i]] {
- return nil, fmt.Errorf("json: invalid number literal %q", n)
- }
- }
- b = append(b, n...)
- return b, nil
-}
-
-func AppendMarshalJSON(ctx *RuntimeContext, code *Opcode, b []byte, v interface{}) ([]byte, error) {
- rv := reflect.ValueOf(v) // convert by dynamic interface type
- if (code.Flags & AddrForMarshalerFlags) != 0 {
- if rv.CanAddr() {
- rv = rv.Addr()
- } else {
- newV := reflect.New(rv.Type())
- newV.Elem().Set(rv)
- rv = newV
- }
- }
-
- if rv.Kind() == reflect.Ptr && rv.IsNil() {
- return AppendNull(ctx, b), nil
- }
-
- v = rv.Interface()
- var bb []byte
- if (code.Flags & MarshalerContextFlags) != 0 {
- marshaler, ok := v.(marshalerContext)
- if !ok {
- return AppendNull(ctx, b), nil
- }
- stdctx := ctx.Option.Context
- if ctx.Option.Flag&FieldQueryOption != 0 {
- stdctx = SetFieldQueryToContext(stdctx, code.FieldQuery)
- }
- b, err := marshaler.MarshalJSON(stdctx)
- if err != nil {
- return nil, &errors.MarshalerError{Type: reflect.TypeOf(v), Err: err}
- }
- bb = b
- } else {
- marshaler, ok := v.(json.Marshaler)
- if !ok {
- return AppendNull(ctx, b), nil
- }
- b, err := marshaler.MarshalJSON()
- if err != nil {
- return nil, &errors.MarshalerError{Type: reflect.TypeOf(v), Err: err}
- }
- bb = b
- }
- marshalBuf := ctx.MarshalBuf[:0]
- marshalBuf = append(append(marshalBuf, bb...), nul)
- compactedBuf, err := compact(b, marshalBuf, (ctx.Option.Flag&HTMLEscapeOption) != 0)
- if err != nil {
- return nil, &errors.MarshalerError{Type: reflect.TypeOf(v), Err: err}
- }
- ctx.MarshalBuf = marshalBuf
- return compactedBuf, nil
-}
-
-func AppendMarshalJSONIndent(ctx *RuntimeContext, code *Opcode, b []byte, v interface{}) ([]byte, error) {
- rv := reflect.ValueOf(v) // convert by dynamic interface type
- if (code.Flags & AddrForMarshalerFlags) != 0 {
- if rv.CanAddr() {
- rv = rv.Addr()
- } else {
- newV := reflect.New(rv.Type())
- newV.Elem().Set(rv)
- rv = newV
- }
- }
- v = rv.Interface()
- var bb []byte
- if (code.Flags & MarshalerContextFlags) != 0 {
- marshaler, ok := v.(marshalerContext)
- if !ok {
- return AppendNull(ctx, b), nil
- }
- b, err := marshaler.MarshalJSON(ctx.Option.Context)
- if err != nil {
- return nil, &errors.MarshalerError{Type: reflect.TypeOf(v), Err: err}
- }
- bb = b
- } else {
- marshaler, ok := v.(json.Marshaler)
- if !ok {
- return AppendNull(ctx, b), nil
- }
- b, err := marshaler.MarshalJSON()
- if err != nil {
- return nil, &errors.MarshalerError{Type: reflect.TypeOf(v), Err: err}
- }
- bb = b
- }
- marshalBuf := ctx.MarshalBuf[:0]
- marshalBuf = append(append(marshalBuf, bb...), nul)
- indentedBuf, err := doIndent(
- b,
- marshalBuf,
- string(ctx.Prefix)+strings.Repeat(string(ctx.IndentStr), int(ctx.BaseIndent+code.Indent)),
- string(ctx.IndentStr),
- (ctx.Option.Flag&HTMLEscapeOption) != 0,
- )
- if err != nil {
- return nil, &errors.MarshalerError{Type: reflect.TypeOf(v), Err: err}
- }
- ctx.MarshalBuf = marshalBuf
- return indentedBuf, nil
-}
-
-func AppendMarshalText(ctx *RuntimeContext, code *Opcode, b []byte, v interface{}) ([]byte, error) {
- rv := reflect.ValueOf(v) // convert by dynamic interface type
- if (code.Flags & AddrForMarshalerFlags) != 0 {
- if rv.CanAddr() {
- rv = rv.Addr()
- } else {
- newV := reflect.New(rv.Type())
- newV.Elem().Set(rv)
- rv = newV
- }
- }
- v = rv.Interface()
- marshaler, ok := v.(encoding.TextMarshaler)
- if !ok {
- return AppendNull(ctx, b), nil
- }
- bytes, err := marshaler.MarshalText()
- if err != nil {
- return nil, &errors.MarshalerError{Type: reflect.TypeOf(v), Err: err}
- }
- return AppendString(ctx, b, *(*string)(unsafe.Pointer(&bytes))), nil
-}
-
-func AppendMarshalTextIndent(ctx *RuntimeContext, code *Opcode, b []byte, v interface{}) ([]byte, error) {
- rv := reflect.ValueOf(v) // convert by dynamic interface type
- if (code.Flags & AddrForMarshalerFlags) != 0 {
- if rv.CanAddr() {
- rv = rv.Addr()
- } else {
- newV := reflect.New(rv.Type())
- newV.Elem().Set(rv)
- rv = newV
- }
- }
- v = rv.Interface()
- marshaler, ok := v.(encoding.TextMarshaler)
- if !ok {
- return AppendNull(ctx, b), nil
- }
- bytes, err := marshaler.MarshalText()
- if err != nil {
- return nil, &errors.MarshalerError{Type: reflect.TypeOf(v), Err: err}
- }
- return AppendString(ctx, b, *(*string)(unsafe.Pointer(&bytes))), nil
-}
-
-func AppendNull(_ *RuntimeContext, b []byte) []byte {
- return append(b, "null"...)
-}
-
-func AppendComma(_ *RuntimeContext, b []byte) []byte {
- return append(b, ',')
-}
-
-func AppendCommaIndent(_ *RuntimeContext, b []byte) []byte {
- return append(b, ',', '\n')
-}
-
-func AppendStructEnd(_ *RuntimeContext, b []byte) []byte {
- return append(b, '}', ',')
-}
-
-func AppendStructEndIndent(ctx *RuntimeContext, code *Opcode, b []byte) []byte {
- b = append(b, '\n')
- b = append(b, ctx.Prefix...)
- indentNum := ctx.BaseIndent + code.Indent - 1
- for i := uint32(0); i < indentNum; i++ {
- b = append(b, ctx.IndentStr...)
- }
- return append(b, '}', ',', '\n')
-}
-
-func AppendIndent(ctx *RuntimeContext, b []byte, indent uint32) []byte {
- b = append(b, ctx.Prefix...)
- indentNum := ctx.BaseIndent + indent
- for i := uint32(0); i < indentNum; i++ {
- b = append(b, ctx.IndentStr...)
- }
- return b
-}
-
-func IsNilForMarshaler(v interface{}) bool {
- rv := reflect.ValueOf(v)
- switch rv.Kind() {
- case reflect.Bool:
- return !rv.Bool()
- case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
- return rv.Int() == 0
- case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
- return rv.Uint() == 0
- case reflect.Float32, reflect.Float64:
- return math.Float64bits(rv.Float()) == 0
- case reflect.Interface, reflect.Map, reflect.Ptr, reflect.Func:
- return rv.IsNil()
- case reflect.Slice:
- return rv.IsNil() || rv.Len() == 0
- case reflect.String:
- return rv.Len() == 0
- }
- return false
-}
diff --git a/vendor/github.com/goccy/go-json/internal/encoder/indent.go b/vendor/github.com/goccy/go-json/internal/encoder/indent.go
deleted file mode 100644
index dfe04b5e..00000000
--- a/vendor/github.com/goccy/go-json/internal/encoder/indent.go
+++ /dev/null
@@ -1,211 +0,0 @@
-package encoder
-
-import (
- "bytes"
- "fmt"
-
- "github.com/goccy/go-json/internal/errors"
-)
-
-func takeIndentSrcRuntimeContext(src []byte) (*RuntimeContext, []byte) {
- ctx := TakeRuntimeContext()
- buf := ctx.Buf[:0]
- buf = append(append(buf, src...), nul)
- ctx.Buf = buf
- return ctx, buf
-}
-
-func Indent(buf *bytes.Buffer, src []byte, prefix, indentStr string) error {
- if len(src) == 0 {
- return errors.ErrUnexpectedEndOfJSON("", 0)
- }
-
- srcCtx, srcBuf := takeIndentSrcRuntimeContext(src)
- dstCtx := TakeRuntimeContext()
- dst := dstCtx.Buf[:0]
-
- dst, err := indentAndWrite(buf, dst, srcBuf, prefix, indentStr)
- if err != nil {
- ReleaseRuntimeContext(srcCtx)
- ReleaseRuntimeContext(dstCtx)
- return err
- }
- dstCtx.Buf = dst
- ReleaseRuntimeContext(srcCtx)
- ReleaseRuntimeContext(dstCtx)
- return nil
-}
-
-func indentAndWrite(buf *bytes.Buffer, dst []byte, src []byte, prefix, indentStr string) ([]byte, error) {
- dst, err := doIndent(dst, src, prefix, indentStr, false)
- if err != nil {
- return nil, err
- }
- if _, err := buf.Write(dst); err != nil {
- return nil, err
- }
- return dst, nil
-}
-
-func doIndent(dst, src []byte, prefix, indentStr string, escape bool) ([]byte, error) {
- buf, cursor, err := indentValue(dst, src, 0, 0, []byte(prefix), []byte(indentStr), escape)
- if err != nil {
- return nil, err
- }
- if err := validateEndBuf(src, cursor); err != nil {
- return nil, err
- }
- return buf, nil
-}
-
-func indentValue(
- dst []byte,
- src []byte,
- indentNum int,
- cursor int64,
- prefix []byte,
- indentBytes []byte,
- escape bool) ([]byte, int64, error) {
- for {
- switch src[cursor] {
- case ' ', '\t', '\n', '\r':
- cursor++
- continue
- case '{':
- return indentObject(dst, src, indentNum, cursor, prefix, indentBytes, escape)
- case '}':
- return nil, 0, errors.ErrSyntax("unexpected character '}'", cursor)
- case '[':
- return indentArray(dst, src, indentNum, cursor, prefix, indentBytes, escape)
- case ']':
- return nil, 0, errors.ErrSyntax("unexpected character ']'", cursor)
- case '"':
- return compactString(dst, src, cursor, escape)
- case '-', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
- return compactNumber(dst, src, cursor)
- case 't':
- return compactTrue(dst, src, cursor)
- case 'f':
- return compactFalse(dst, src, cursor)
- case 'n':
- return compactNull(dst, src, cursor)
- default:
- return nil, 0, errors.ErrSyntax(fmt.Sprintf("unexpected character '%c'", src[cursor]), cursor)
- }
- }
-}
-
-func indentObject(
- dst []byte,
- src []byte,
- indentNum int,
- cursor int64,
- prefix []byte,
- indentBytes []byte,
- escape bool) ([]byte, int64, error) {
- if src[cursor] == '{' {
- dst = append(dst, '{')
- } else {
- return nil, 0, errors.ErrExpected("expected { character for object value", cursor)
- }
- cursor = skipWhiteSpace(src, cursor+1)
- if src[cursor] == '}' {
- dst = append(dst, '}')
- return dst, cursor + 1, nil
- }
- indentNum++
- var err error
- for {
- dst = append(append(dst, '\n'), prefix...)
- for i := 0; i < indentNum; i++ {
- dst = append(dst, indentBytes...)
- }
- cursor = skipWhiteSpace(src, cursor)
- dst, cursor, err = compactString(dst, src, cursor, escape)
- if err != nil {
- return nil, 0, err
- }
- cursor = skipWhiteSpace(src, cursor)
- if src[cursor] != ':' {
- return nil, 0, errors.ErrSyntax(
- fmt.Sprintf("invalid character '%c' after object key", src[cursor]),
- cursor+1,
- )
- }
- dst = append(dst, ':', ' ')
- dst, cursor, err = indentValue(dst, src, indentNum, cursor+1, prefix, indentBytes, escape)
- if err != nil {
- return nil, 0, err
- }
- cursor = skipWhiteSpace(src, cursor)
- switch src[cursor] {
- case '}':
- dst = append(append(dst, '\n'), prefix...)
- for i := 0; i < indentNum-1; i++ {
- dst = append(dst, indentBytes...)
- }
- dst = append(dst, '}')
- cursor++
- return dst, cursor, nil
- case ',':
- dst = append(dst, ',')
- default:
- return nil, 0, errors.ErrSyntax(
- fmt.Sprintf("invalid character '%c' after object key:value pair", src[cursor]),
- cursor+1,
- )
- }
- cursor++
- }
-}
-
-func indentArray(
- dst []byte,
- src []byte,
- indentNum int,
- cursor int64,
- prefix []byte,
- indentBytes []byte,
- escape bool) ([]byte, int64, error) {
- if src[cursor] == '[' {
- dst = append(dst, '[')
- } else {
- return nil, 0, errors.ErrExpected("expected [ character for array value", cursor)
- }
- cursor = skipWhiteSpace(src, cursor+1)
- if src[cursor] == ']' {
- dst = append(dst, ']')
- return dst, cursor + 1, nil
- }
- indentNum++
- var err error
- for {
- dst = append(append(dst, '\n'), prefix...)
- for i := 0; i < indentNum; i++ {
- dst = append(dst, indentBytes...)
- }
- dst, cursor, err = indentValue(dst, src, indentNum, cursor, prefix, indentBytes, escape)
- if err != nil {
- return nil, 0, err
- }
- cursor = skipWhiteSpace(src, cursor)
- switch src[cursor] {
- case ']':
- dst = append(append(dst, '\n'), prefix...)
- for i := 0; i < indentNum-1; i++ {
- dst = append(dst, indentBytes...)
- }
- dst = append(dst, ']')
- cursor++
- return dst, cursor, nil
- case ',':
- dst = append(dst, ',')
- default:
- return nil, 0, errors.ErrSyntax(
- fmt.Sprintf("invalid character '%c' after array value", src[cursor]),
- cursor+1,
- )
- }
- cursor++
- }
-}
diff --git a/vendor/github.com/goccy/go-json/internal/encoder/int.go b/vendor/github.com/goccy/go-json/internal/encoder/int.go
deleted file mode 100644
index 8b5febea..00000000
--- a/vendor/github.com/goccy/go-json/internal/encoder/int.go
+++ /dev/null
@@ -1,176 +0,0 @@
-// This files's processing codes are inspired by https://github.com/segmentio/encoding.
-// The license notation is as follows.
-//
-// # MIT License
-//
-// Copyright (c) 2019 Segment.io, Inc.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-package encoder
-
-import (
- "unsafe"
-)
-
-var endianness int
-
-func init() {
- var b [2]byte
- *(*uint16)(unsafe.Pointer(&b)) = uint16(0xABCD)
-
- switch b[0] {
- case 0xCD:
- endianness = 0 // LE
- case 0xAB:
- endianness = 1 // BE
- default:
- panic("could not determine endianness")
- }
-}
-
-// "00010203...96979899" cast to []uint16
-var intLELookup = [100]uint16{
- 0x3030, 0x3130, 0x3230, 0x3330, 0x3430, 0x3530, 0x3630, 0x3730, 0x3830, 0x3930,
- 0x3031, 0x3131, 0x3231, 0x3331, 0x3431, 0x3531, 0x3631, 0x3731, 0x3831, 0x3931,
- 0x3032, 0x3132, 0x3232, 0x3332, 0x3432, 0x3532, 0x3632, 0x3732, 0x3832, 0x3932,
- 0x3033, 0x3133, 0x3233, 0x3333, 0x3433, 0x3533, 0x3633, 0x3733, 0x3833, 0x3933,
- 0x3034, 0x3134, 0x3234, 0x3334, 0x3434, 0x3534, 0x3634, 0x3734, 0x3834, 0x3934,
- 0x3035, 0x3135, 0x3235, 0x3335, 0x3435, 0x3535, 0x3635, 0x3735, 0x3835, 0x3935,
- 0x3036, 0x3136, 0x3236, 0x3336, 0x3436, 0x3536, 0x3636, 0x3736, 0x3836, 0x3936,
- 0x3037, 0x3137, 0x3237, 0x3337, 0x3437, 0x3537, 0x3637, 0x3737, 0x3837, 0x3937,
- 0x3038, 0x3138, 0x3238, 0x3338, 0x3438, 0x3538, 0x3638, 0x3738, 0x3838, 0x3938,
- 0x3039, 0x3139, 0x3239, 0x3339, 0x3439, 0x3539, 0x3639, 0x3739, 0x3839, 0x3939,
-}
-
-var intBELookup = [100]uint16{
- 0x3030, 0x3031, 0x3032, 0x3033, 0x3034, 0x3035, 0x3036, 0x3037, 0x3038, 0x3039,
- 0x3130, 0x3131, 0x3132, 0x3133, 0x3134, 0x3135, 0x3136, 0x3137, 0x3138, 0x3139,
- 0x3230, 0x3231, 0x3232, 0x3233, 0x3234, 0x3235, 0x3236, 0x3237, 0x3238, 0x3239,
- 0x3330, 0x3331, 0x3332, 0x3333, 0x3334, 0x3335, 0x3336, 0x3337, 0x3338, 0x3339,
- 0x3430, 0x3431, 0x3432, 0x3433, 0x3434, 0x3435, 0x3436, 0x3437, 0x3438, 0x3439,
- 0x3530, 0x3531, 0x3532, 0x3533, 0x3534, 0x3535, 0x3536, 0x3537, 0x3538, 0x3539,
- 0x3630, 0x3631, 0x3632, 0x3633, 0x3634, 0x3635, 0x3636, 0x3637, 0x3638, 0x3639,
- 0x3730, 0x3731, 0x3732, 0x3733, 0x3734, 0x3735, 0x3736, 0x3737, 0x3738, 0x3739,
- 0x3830, 0x3831, 0x3832, 0x3833, 0x3834, 0x3835, 0x3836, 0x3837, 0x3838, 0x3839,
- 0x3930, 0x3931, 0x3932, 0x3933, 0x3934, 0x3935, 0x3936, 0x3937, 0x3938, 0x3939,
-}
-
-var intLookup = [2]*[100]uint16{&intLELookup, &intBELookup}
-
-func numMask(numBitSize uint8) uint64 {
- return 1<