diff options
Diffstat (limited to 'vendor/github.com/mailru/easyjson')
63 files changed, 22888 insertions, 0 deletions
diff --git a/vendor/github.com/mailru/easyjson/.gitignore b/vendor/github.com/mailru/easyjson/.gitignore new file mode 100644 index 000000000..db8c66edf --- /dev/null +++ b/vendor/github.com/mailru/easyjson/.gitignore @@ -0,0 +1,4 @@ +.root +*_easyjson.go +*.iml +.idea diff --git a/vendor/github.com/mailru/easyjson/.travis.yml b/vendor/github.com/mailru/easyjson/.travis.yml new file mode 100644 index 000000000..884f8bbdf --- /dev/null +++ b/vendor/github.com/mailru/easyjson/.travis.yml @@ -0,0 +1,9 @@ +language: go + +go: + - tip +install: + - go get github.com/ugorji/go/codec + - go get github.com/pquerna/ffjson/fflib/v1 + - go get github.com/json-iterator/go + - go get github.com/golang/lint/golint diff --git a/vendor/github.com/mailru/easyjson/LICENSE b/vendor/github.com/mailru/easyjson/LICENSE new file mode 100644 index 000000000..fbff658f7 --- /dev/null +++ b/vendor/github.com/mailru/easyjson/LICENSE @@ -0,0 +1,7 @@ +Copyright (c) 2016 Mail.Ru Group + +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/mailru/easyjson/Makefile b/vendor/github.com/mailru/easyjson/Makefile new file mode 100644 index 000000000..f877ab269 --- /dev/null +++ b/vendor/github.com/mailru/easyjson/Makefile @@ -0,0 +1,56 @@ +PKG=github.com/mailru/easyjson +GOPATH:=$(PWD)/.root:$(GOPATH) +export GOPATH + +all: test + +.root/src/$(PKG): + mkdir -p $@ + for i in $$PWD/* ; do ln -s $$i $@/`basename $$i` ; done + +root: .root/src/$(PKG) + +clean: + rm -rf .root + rm -rf tests/*_easyjson.go + +build: + go build -i -o .root/bin/easyjson $(PKG)/easyjson + +generate: root build + .root/bin/easyjson -stubs \ + .root/src/$(PKG)/tests/snake.go \ + .root/src/$(PKG)/tests/data.go \ + .root/src/$(PKG)/tests/omitempty.go \ + .root/src/$(PKG)/tests/nothing.go \ + .root/src/$(PKG)/tests/named_type.go + + .root/bin/easyjson -all .root/src/$(PKG)/tests/data.go + .root/bin/easyjson -all .root/src/$(PKG)/tests/nothing.go + .root/bin/easyjson -all .root/src/$(PKG)/tests/errors.go + .root/bin/easyjson -snake_case .root/src/$(PKG)/tests/snake.go + .root/bin/easyjson -omit_empty .root/src/$(PKG)/tests/omitempty.go + .root/bin/easyjson -build_tags=use_easyjson .root/src/$(PKG)/benchmark/data.go + .root/bin/easyjson .root/src/$(PKG)/tests/nested_easy.go + .root/bin/easyjson .root/src/$(PKG)/tests/named_type.go + +test: generate root + go test \ + $(PKG)/tests \ + $(PKG)/jlexer \ + $(PKG)/gen \ + $(PKG)/buffer + go test -benchmem -tags use_easyjson -bench . $(PKG)/benchmark + golint -set_exit_status .root/src/$(PKG)/tests/*_easyjson.go + +bench-other: generate root + @go test -benchmem -bench . $(PKG)/benchmark + @go test -benchmem -tags use_ffjson -bench . $(PKG)/benchmark + @go test -benchmem -tags use_jsoniter -bench . $(PKG)/benchmark + @go test -benchmem -tags use_codec -bench . $(PKG)/benchmark + +bench-python: + benchmark/ujson.sh + + +.PHONY: root clean generate test build diff --git a/vendor/github.com/mailru/easyjson/README.md b/vendor/github.com/mailru/easyjson/README.md new file mode 100644 index 000000000..9366e3f71 --- /dev/null +++ b/vendor/github.com/mailru/easyjson/README.md @@ -0,0 +1,331 @@ +# easyjson [](https://travis-ci.org/mailru/easyjson) [](https://goreportcard.com/report/github.com/mailru/easyjson) + +Package easyjson provides a fast and easy way to marshal/unmarshal Go structs +to/from JSON without the use of reflection. In performance tests, easyjson +outperforms the standard `encoding/json` package by a factor of 4-5x, and other +JSON encoding packages by a factor of 2-3x. + +easyjson aims to keep generated Go code simple enough so that it can be easily +optimized or fixed. Another goal is to provide users with the ability to +customize the generated code by providing options not available with the +standard `encoding/json` package, such as generating "snake_case" names or +enabling `omitempty` behavior by default. + +## Usage +```sh +# install +go get -u github.com/mailru/easyjson/... + +# run +easyjson -all <file>.go +``` + +The above will generate `<file>_easyjson.go` containing the appropriate marshaler and +unmarshaler funcs for all structs contained in `<file>.go`. + +Please note that easyjson requires a full Go build environment and the `GOPATH` +environment variable to be set. This is because easyjson code generation +invokes `go run` on a temporary file (an approach to code generation borrowed +from [ffjson](https://github.com/pquerna/ffjson)). + +## Options +```txt +Usage of easyjson: + -all + generate marshaler/unmarshalers for all structs in a file + -build_tags string + build tags to add to generated file + -leave_temps + do not delete temporary files + -no_std_marshalers + don't generate MarshalJSON/UnmarshalJSON funcs + -noformat + do not run 'gofmt -w' on output file + -omit_empty + omit empty fields by default + -output_filename string + specify the filename of the output + -pkg + process the whole package instead of just the given file + -snake_case + use snake_case names instead of CamelCase by default + -lower_camel_case + use lowerCamelCase instead of CamelCase by default + -stubs + only generate stubs for marshaler/unmarshaler funcs +``` + +Using `-all` will generate marshalers/unmarshalers for all Go structs in the +file. If `-all` is not provided, then only those structs whose preceding +comment starts with `easyjson:json` will have marshalers/unmarshalers +generated. For example: + +```go +//easyjson:json +type A struct {} +``` + +Additional option notes: + +* `-snake_case` tells easyjson to generate snake\_case field names by default + (unless overridden by a field tag). The CamelCase to snake\_case conversion + algorithm should work in most cases (ie, HTTPVersion will be converted to + "http_version"). + +* `-build_tags` will add the specified build tags to generated Go sources. + +## Generated Marshaler/Unmarshaler Funcs + +For Go struct types, easyjson generates the funcs `MarshalEasyJSON` / +`UnmarshalEasyJSON` for marshaling/unmarshaling JSON. In turn, these satisify +the `easyjson.Marshaler` and `easyjson.Unmarshaler` interfaces and when used in +conjunction with `easyjson.Marshal` / `easyjson.Unmarshal` avoid unnecessary +reflection / type assertions during marshaling/unmarshaling to/from JSON for Go +structs. + +easyjson also generates `MarshalJSON` and `UnmarshalJSON` funcs for Go struct +types compatible with the standard `json.Marshaler` and `json.Unmarshaler` +interfaces. Please be aware that using the standard `json.Marshal` / +`json.Unmarshal` for marshaling/unmarshaling will incur a significant +performance penalty when compared to using `easyjson.Marshal` / +`easyjson.Unmarshal`. + +Additionally, easyjson exposes utility funcs that use the `MarshalEasyJSON` and +`UnmarshalEasyJSON` for marshaling/unmarshaling to and from standard readers +and writers. For example, easyjson provides `easyjson.MarshalToHTTPResponseWriter` +which marshals to the standard `http.ResponseWriter`. Please see the [GoDoc +listing](https://godoc.org/github.com/mailru/easyjson) for the full listing of +utility funcs that are available. + +## Controlling easyjson Marshaling and Unmarshaling Behavior + +Go types can provide their own `MarshalEasyJSON` and `UnmarshalEasyJSON` funcs +that satisify the `easyjson.Marshaler` / `easyjson.Unmarshaler` interfaces. +These will be used by `easyjson.Marshal` and `easyjson.Unmarshal` when defined +for a Go type. + +Go types can also satisify the `easyjson.Optional` interface, which allows the +type to define its own `omitempty` logic. + +## Type Wrappers + +easyjson provides additional type wrappers defined in the `easyjson/opt` +package. These wrap the standard Go primitives and in turn satisify the +easyjson interfaces. + +The `easyjson/opt` type wrappers are useful when needing to distinguish between +a missing value and/or when needing to specifying a default value. Type +wrappers allow easyjson to avoid additional pointers and heap allocations and +can significantly increase performance when used properly. + +## Memory Pooling + +easyjson uses a buffer pool that allocates data in increasing chunks from 128 +to 32768 bytes. Chunks of 512 bytes and larger will be reused with the help of +`sync.Pool`. The maximum size of a chunk is bounded to reduce redundant memory +allocation and to allow larger reusable buffers. + +easyjson's custom allocation buffer pool is defined in the `easyjson/buffer` +package, and the default behavior pool behavior can be modified (if necessary) +through a call to `buffer.Init()` prior to any marshaling or unmarshaling. +Please see the [GoDoc listing](https://godoc.org/github.com/mailru/easyjson/buffer) +for more information. + +## Issues, Notes, and Limitations + +* easyjson is still early in its development. As such, there are likely to be + bugs and missing features when compared to `encoding/json`. In the case of a + missing feature or bug, please create a GitHub issue. Pull requests are + welcome! + +* Unlike `encoding/json`, object keys are case-sensitive. Case-insensitive + matching is not currently provided due to the significant performance hit + when doing case-insensitive key matching. In the future, case-insensitive + object key matching may be provided via an option to the generator. + +* easyjson makes use of `unsafe`, which simplifies the code and + provides significant performance benefits by allowing no-copy + conversion from `[]byte` to `string`. That said, `unsafe` is used + only when unmarshaling and parsing JSON, and any `unsafe` operations + / memory allocations done will be safely deallocated by + easyjson. Set the build tag `easyjson_nounsafe` to compile it + without `unsafe`. + +* easyjson is compatible with Google App Engine. The `appengine` build + tag (set by App Engine's environment) will automatically disable the + use of `unsafe`, which is not allowed in App Engine's Standard + Environment. Note that the use with App Engine is still experimental. + +* Floats are formatted using the default precision from Go's `strconv` package. + As such, easyjson will not correctly handle high precision floats when + marshaling/unmarshaling JSON. Note, however, that there are very few/limited + uses where this behavior is not sufficient for general use. That said, a + different package may be needed if precise marshaling/unmarshaling of high + precision floats to/from JSON is required. + +* While unmarshaling, the JSON parser does the minimal amount of work needed to + skip over unmatching parens, and as such full validation is not done for the + entire JSON value being unmarshaled/parsed. + +* Currently there is no true streaming support for encoding/decoding as + typically for many uses/protocols the final, marshaled length of the JSON + needs to be known prior to sending the data. Currently this is not possible + with easyjson's architecture. + +## Benchmarks + +Most benchmarks were done using the example +[13kB example JSON](https://dev.twitter.com/rest/reference/get/search/tweets) +(9k after eliminating whitespace). This example is similar to real-world data, +is well-structured, and contains a healthy variety of different types, making +it ideal for JSON serialization benchmarks. + +Note: + +* For small request benchmarks, an 80 byte portion of the above example was + used. + +* For large request marshaling benchmarks, a struct containing 50 regular + samples was used, making a ~500kB output JSON. + +* Benchmarks are showing the results of easyjson's default behaviour, + which makes use of `unsafe`. + +Benchmarks are available in the repository and can be run by invoking `make`. + +### easyjson vs. encoding/json + +easyjson is roughly 5-6 times faster than the standard `encoding/json` for +unmarshaling, and 3-4 times faster for non-concurrent marshaling. Concurrent +marshaling is 6-7x faster if marshaling to a writer. + +### easyjson vs. ffjson + +easyjson uses the same approach for JSON marshaling as +[ffjson](https://github.com/pquerna/ffjson), but takes a significantly +different approach to lexing and parsing JSON during unmarshaling. This means +easyjson is roughly 2-3x faster for unmarshaling and 1.5-2x faster for +non-concurrent unmarshaling. + +As of this writing, `ffjson` seems to have issues when used concurrently: +specifically, large request pooling hurts `ffjson`'s performance and causes +scalability issues. These issues with `ffjson` can likely be fixed, but as of +writing remain outstanding/known issues with `ffjson`. + +easyjson and `ffjson` have similar performance for small requests, however +easyjson outperforms `ffjson` by roughly 2-5x times for large requests when +used with a writer. + +### easyjson vs. go/codec + +[go/codec](https://github.com/ugorji/go) provides +compile-time helpers for JSON generation. In this case, helpers do not work +like marshalers as they are encoding-independent. + +easyjson is generally 2x faster than `go/codec` for non-concurrent benchmarks +and about 3x faster for concurrent encoding (without marshaling to a writer). + +In an attempt to measure marshaling performance of `go/codec` (as opposed to +allocations/memcpy/writer interface invocations), a benchmark was done with +resetting length of a byte slice rather than resetting the whole slice to nil. +However, the optimization in this exact form may not be applicable in practice, +since the memory is not freed between marshaling operations. + +### easyjson vs 'ujson' python module + +[ujson](https://github.com/esnme/ultrajson) is using C code for parsing, so it +is interesting to see how plain golang compares to that. It is imporant to note +that the resulting object for python is slower to access, since the library +parses JSON object into dictionaries. + +easyjson is slightly faster for unmarshaling and 2-3x faster than `ujson` for +marshaling. + +### Benchmark Results + +`ffjson` results are from February 4th, 2016, using the latest `ffjson` and go1.6. +`go/codec` results are from March 4th, 2016, using the latest `go/codec` and go1.6. + +#### Unmarshaling + +| lib | json size | MB/s | allocs/op | B/op | +|:---------|:----------|-----:|----------:|------:| +| standard | regular | 22 | 218 | 10229 | +| standard | small | 9.7 | 14 | 720 | +| | | | | | +| easyjson | regular | 125 | 128 | 9794 | +| easyjson | small | 67 | 3 | 128 | +| | | | | | +| ffjson | regular | 66 | 141 | 9985 | +| ffjson | small | 17.6 | 10 | 488 | +| | | | | | +| codec | regular | 55 | 434 | 19299 | +| codec | small | 29 | 7 | 336 | +| | | | | | +| ujson | regular | 103 | N/A | N/A | + +#### Marshaling, one goroutine. + +| lib | json size | MB/s | allocs/op | B/op | +|:----------|:----------|-----:|----------:|------:| +| standard | regular | 75 | 9 | 23256 | +| standard | small | 32 | 3 | 328 | +| standard | large | 80 | 17 | 1.2M | +| | | | | | +| easyjson | regular | 213 | 9 | 10260 | +| easyjson* | regular | 263 | 8 | 742 | +| easyjson | small | 125 | 1 | 128 | +| easyjson | large | 212 | 33 | 490k | +| easyjson* | large | 262 | 25 | 2879 | +| | | | | | +| ffjson | regular | 122 | 153 | 21340 | +| ffjson** | regular | 146 | 152 | 4897 | +| ffjson | small | 36 | 5 | 384 | +| ffjson** | small | 64 | 4 | 128 | +| ffjson | large | 134 | 7317 | 818k | +| ffjson** | large | 125 | 7320 | 827k | +| | | | | | +| codec | regular | 80 | 17 | 33601 | +| codec*** | regular | 108 | 9 | 1153 | +| codec | small | 42 | 3 | 304 | +| codec*** | small | 56 | 1 | 48 | +| codec | large | 73 | 483 | 2.5M | +| codec*** | large | 103 | 451 | 66007 | +| | | | | | +| ujson | regular | 92 | N/A | N/A | + +\* marshaling to a writer, +\*\* using `ffjson.Pool()`, +\*\*\* reusing output slice instead of resetting it to nil + +#### Marshaling, concurrent. + +| lib | json size | MB/s | allocs/op | B/op | +|:----------|:----------|-----:|----------:|------:| +| standard | regular | 252 | 9 | 23257 | +| standard | small | 124 | 3 | 328 | +| standard | large | 289 | 17 | 1.2M | +| | | | | | +| easyjson | regular | 792 | 9 | 10597 | +| easyjson* | regular | 1748 | 8 | 779 | +| easyjson | small | 333 | 1 | 128 | +| easyjson | large | 718 | 36 | 548k | +| easyjson* | large | 2134 | 25 | 4957 | +| | | | | | +| ffjson | regular | 301 | 153 | 21629 | +| ffjson** | regular | 707 | 152 | 5148 | +| ffjson | small | 62 | 5 | 384 | +| ffjson** | small | 282 | 4 | 128 | +| ffjson | large | 438 | 7330 | 1.0M | +| ffjson** | large | 131 | 7319 | 820k | +| | | | | | +| codec | regular | 183 | 17 | 33603 | +| codec*** | regular | 671 | 9 | 1157 | +| codec | small | 147 | 3 | 304 | +| codec*** | small | 299 | 1 | 48 | +| codec | large | 190 | 483 | 2.5M | +| codec*** | large | 752 | 451 | 77574 | + +\* marshaling to a writer, +\*\* using `ffjson.Pool()`, +\*\*\* reusing output slice instead of resetting it to nil diff --git a/vendor/github.com/mailru/easyjson/benchmark/codec_test.go b/vendor/github.com/mailru/easyjson/benchmark/codec_test.go new file mode 100644 index 000000000..5c77072ee --- /dev/null +++ b/vendor/github.com/mailru/easyjson/benchmark/codec_test.go @@ -0,0 +1,279 @@ +// +build use_codec + +package benchmark + +import ( + "testing" + + "github.com/ugorji/go/codec" +) + +func BenchmarkCodec_Unmarshal_M(b *testing.B) { + var h codec.Handle = new(codec.JsonHandle) + dec := codec.NewDecoderBytes(nil, h) + + b.SetBytes(int64(len(largeStructText))) + for i := 0; i < b.N; i++ { + var s LargeStruct + dec.ResetBytes(largeStructText) + if err := dec.Decode(&s); err != nil { + b.Error(err) + } + } +} + +func BenchmarkCodec_Unmarshal_S(b *testing.B) { + var h codec.Handle = new(codec.JsonHandle) + dec := codec.NewDecoderBytes(nil, h) + + b.SetBytes(int64(len(smallStructText))) + for i := 0; i < b.N; i++ { + var s LargeStruct + dec.ResetBytes(smallStructText) + if err := dec.Decode(&s); err != nil { + b.Error(err) + } + } +} + +func BenchmarkCodec_Marshal_S(b *testing.B) { + var h codec.Handle = new(codec.JsonHandle) + + var out []byte + enc := codec.NewEncoderBytes(&out, h) + + var l int64 + for i := 0; i < b.N; i++ { + enc.ResetBytes(&out) + if err := enc.Encode(&smallStructData); err != nil { + b.Error(err) + } + l = int64(len(out)) + out = nil + } + + b.SetBytes(l) +} + +func BenchmarkCodec_Marshal_M(b *testing.B) { + var h codec.Handle = new(codec.JsonHandle) + + var out []byte + enc := codec.NewEncoderBytes(&out, h) + + var l int64 + for i := 0; i < b.N; i++ { + enc.ResetBytes(&out) + if err := enc.Encode(&largeStructData); err != nil { + b.Error(err) + } + l = int64(len(out)) + out = nil + } + + b.SetBytes(l) +} + +func BenchmarkCodec_Marshal_L(b *testing.B) { + var h codec.Handle = new(codec.JsonHandle) + + var out []byte + enc := codec.NewEncoderBytes(&out, h) + + var l int64 + for i := 0; i < b.N; i++ { + enc.ResetBytes(&out) + if err := enc.Encode(&xlStructData); err != nil { + b.Error(err) + } + l = int64(len(out)) + out = nil + } + + b.SetBytes(l) +} + +func BenchmarkCodec_Marshal_S_Reuse(b *testing.B) { + var h codec.Handle = new(codec.JsonHandle) + + var out []byte + enc := codec.NewEncoderBytes(&out, h) + + var l int64 + for i := 0; i < b.N; i++ { + enc.ResetBytes(&out) + if err := enc.Encode(&smallStructData); err != nil { + b.Error(err) + } + l = int64(len(out)) + out = out[:0] + } + + b.SetBytes(l) +} + +func BenchmarkCodec_Marshal_M_Reuse(b *testing.B) { + var h codec.Handle = new(codec.JsonHandle) + + var out []byte + enc := codec.NewEncoderBytes(&out, h) + + var l int64 + for i := 0; i < b.N; i++ { + enc.ResetBytes(&out) + if err := enc.Encode(&largeStructData); err != nil { + b.Error(err) + } + l = int64(len(out)) + out = out[:0] + } + + b.SetBytes(l) +} + +func BenchmarkCodec_Marshal_L_Reuse(b *testing.B) { + var h codec.Handle = new(codec.JsonHandle) + + var out []byte + enc := codec.NewEncoderBytes(&out, h) + + var l int64 + for i := 0; i < b.N; i++ { + enc.ResetBytes(&out) + if err := enc.Encode(&xlStructData); err != nil { + b.Error(err) + } + l = int64(len(out)) + out = out[:0] + } + + b.SetBytes(l) +} + +func BenchmarkCodec_Marshal_S_Parallel(b *testing.B) { + var l int64 + + b.RunParallel(func(pb *testing.PB) { + var out []byte + + var h codec.Handle = new(codec.JsonHandle) + enc := codec.NewEncoderBytes(&out, h) + + for pb.Next() { + enc.ResetBytes(&out) + if err := enc.Encode(&smallStructData); err != nil { + b.Error(err) + } + l = int64(len(out)) + out = nil + } + }) + + b.SetBytes(l) +} + +func BenchmarkCodec_Marshal_M_Parallel(b *testing.B) { + var l int64 + + b.RunParallel(func(pb *testing.PB) { + var h codec.Handle = new(codec.JsonHandle) + + var out []byte + enc := codec.NewEncoderBytes(&out, h) + + for pb.Next() { + enc.ResetBytes(&out) + if err := enc.Encode(&largeStructData); err != nil { + b.Error(err) + } + l = int64(len(out)) + out = nil + } + }) + b.SetBytes(l) +} + +func BenchmarkCodec_Marshal_L_Parallel(b *testing.B) { + var l int64 + + b.RunParallel(func(pb *testing.PB) { + var h codec.Handle = new(codec.JsonHandle) + + var out []byte + enc := codec.NewEncoderBytes(&out, h) + + for pb.Next() { + enc.ResetBytes(&out) + if err := enc.Encode(&xlStructData); err != nil { + b.Error(err) + } + l = int64(len(out)) + out = nil + } + }) + b.SetBytes(l) +} + +func BenchmarkCodec_Marshal_S_Parallel_Reuse(b *testing.B) { + var l int64 + + b.RunParallel(func(pb *testing.PB) { + var out []byte + + var h codec.Handle = new(codec.JsonHandle) + enc := codec.NewEncoderBytes(&out, h) + + for pb.Next() { + enc.ResetBytes(&out) + if err := enc.Encode(&smallStructData); err != nil { + b.Error(err) + } + l = int64(len(out)) + out = out[:0] + } + }) + + b.SetBytes(l) +} + +func BenchmarkCodec_Marshal_M_Parallel_Reuse(b *testing.B) { + var l int64 + + b.RunParallel(func(pb *testing.PB) { + var h codec.Handle = new(codec.JsonHandle) + + var out []byte + enc := codec.NewEncoderBytes(&out, h) + + for pb.Next() { + enc.ResetBytes(&out) + if err := enc.Encode(&largeStructData); err != nil { + b.Error(err) + } + l = int64(len(out)) + out = out[:0] + } + }) + b.SetBytes(l) +} + +func BenchmarkCodec_Marshal_L_Parallel_Reuse(b *testing.B) { + var l int64 + + b.RunParallel(func(pb *testing.PB) { + var h codec.Handle = new(codec.JsonHandle) + + var out []byte + enc := codec.NewEncoderBytes(&out, h) + + for pb.Next() { + enc.ResetBytes(&out) + if err := enc.Encode(&xlStructData); err != nil { + b.Error(err) + } + l = int64(len(out)) + out = out[:0] + } + }) + b.SetBytes(l) +} diff --git a/vendor/github.com/mailru/easyjson/benchmark/data.go b/vendor/github.com/mailru/easyjson/benchmark/data.go new file mode 100644 index 000000000..71eb91a94 --- /dev/null +++ b/vendor/github.com/mailru/easyjson/benchmark/data.go @@ -0,0 +1,148 @@ +// Package benchmark provides a simple benchmark for easyjson against default serialization and ffjson. +// The data example is taken from https://dev.twitter.com/rest/reference/get/search/tweets +package benchmark + +import ( + "io/ioutil" +) + +var largeStructText, _ = ioutil.ReadFile("example.json") +var xlStructData XLStruct + +func init() { + for i := 0; i < 50; i++ { + xlStructData.Data = append(xlStructData.Data, largeStructData) + } +} + +var smallStructText = []byte(`{"hashtags":[{"indices":[5, 10],"text":"some-text"}],"urls":[],"user_mentions":[]}`) +var smallStructData = Entities{ + Hashtags: []Hashtag{{Indices: []int{5, 10}, Text: "some-text"}}, + Urls: []*string{}, + UserMentions: []*string{}, +} + +type SearchMetadata struct { + CompletedIn float64 `json:"completed_in"` + Count int `json:"count"` + MaxID int64 `json:"max_id"` + MaxIDStr string `json:"max_id_str"` + NextResults string `json:"next_results"` + Query string `json:"query"` + RefreshURL string `json:"refresh_url"` + SinceID int64 `json:"since_id"` + SinceIDStr string `json:"since_id_str"` +} + +type Hashtag struct { + Indices []int `json:"indices"` + Text string `json:"text"` +} + +//easyjson:json +type Entities struct { + Hashtags []Hashtag `json:"hashtags"` + Urls []*string `json:"urls"` + UserMentions []*string `json:"user_mentions"` +} + +type UserEntityDescription struct { + Urls []*string `json:"urls"` +} + +type URL struct { + ExpandedURL *string `json:"expanded_url"` + Indices []int `json:"indices"` + URL string `json:"url"` +} + +type UserEntityURL struct { + Urls []URL `json:"urls"` +} + +type UserEntities struct { + Description UserEntityDescription `json:"description"` + URL UserEntityURL `json:"url"` +} + +type User struct { + ContributorsEnabled bool `json:"contributors_enabled"` + CreatedAt string `json:"created_at"` + DefaultProfile bool `json:"default_profile"` + DefaultProfileImage bool `json:"default_profile_image"` + Description string `json:"description"` + Entities UserEntities `json:"entities"` + FavouritesCount int `json:"favourites_count"` + FollowRequestSent *string `json:"follow_request_sent"` + FollowersCount int `json:"followers_count"` + Following *string `json:"following"` + FriendsCount int `json:"friends_count"` + GeoEnabled bool `json:"geo_enabled"` + ID int `json:"id"` + IDStr string `json:"id_str"` + IsTranslator bool `json:"is_translator"` + Lang string `json:"lang"` + ListedCount int `json:"listed_count"` + Location string `json:"location"` + Name string `json:"name"` + Notifications *string `json:"notifications"` + ProfileBackgroundColor string `json:"profile_background_color"` + ProfileBackgroundImageURL string `json:"profile_background_image_url"` + ProfileBackgroundImageURLHTTPS string `json:"profile_background_image_url_https"` + ProfileBackgroundTile bool `json:"profile_background_tile"` + ProfileImageURL string `json:"profile_image_url"` + ProfileImageURLHTTPS string `json:"profile_image_url_https"` + ProfileLinkColor string `json:"profile_link_color"` + ProfileSidebarBorderColor string `json:"profile_sidebar_border_color"` + ProfileSidebarFillColor string `json:"profile_sidebar_fill_color"` + ProfileTextColor string `json:"profile_text_color"` + ProfileUseBackgroundImage bool `json:"profile_use_background_image"` + Protected bool `json:"protected"` + ScreenName string `json:"screen_name"` + ShowAllInlineMedia bool `json:"show_all_inline_media"` + StatusesCount int `json:"statuses_count"` + TimeZone string `json:"time_zone"` + URL *string `json:"url"` + UtcOffset int `json:"utc_offset"` + Verified bool `json:"verified"` +} + +type StatusMetadata struct { + IsoLanguageCode string `json:"iso_language_code"` + ResultType string `json:"result_type"` +} + +type Status struct { + Contributors *string `json:"contributors"` + Coordinates *string `json:"coordinates"` + CreatedAt string `json:"created_at"` + Entities Entities `json:"entities"` + Favorited bool `json:"favorited"` + Geo *string `json:"geo"` + ID int64 `json:"id"` + IDStr string `json:"id_str"` + InReplyToScreenName *string `json:"in_reply_to_screen_name"` + InReplyToStatusID *string `json:"in_reply_to_status_id"` + InReplyToStatusIDStr *string `json:"in_reply_to_status_id_str"` + InReplyToUserID *string `json:"in_reply_to_user_id"` + InReplyToUserIDStr *string `json:"in_reply_to_user_id_str"` + Metadata StatusMetadata `json:"metadata"` + Place *string `json:"place"` + RetweetCount int `json:"retweet_count"` + Retweeted bool `json:"retweeted"` + Source string `json:"source"` + Text string `json:"text"` + Truncated bool `json:"truncated"` + User User `json:"user"` +} + +//easyjson:json +type LargeStruct struct { + SearchMetadata SearchMetadata `json:"search_metadata"` + Statuses []Status `json:"statuses"` +} + +//easyjson:json +type XLStruct struct { + Data []LargeStruct +} diff --git a/vendor/github.com/mailru/easyjson/benchmark/data_codec.go b/vendor/github.com/mailru/easyjson/benchmark/data_codec.go new file mode 100644 index 000000000..d2d83fac6 --- /dev/null +++ b/vendor/github.com/mailru/easyjson/benchmark/data_codec.go @@ -0,0 +1,6914 @@ +//+build use_codec +//+build !easyjson_nounsafe +//+build !appengine + +// ************************************************************ +// DO NOT EDIT. +// THIS FILE IS AUTO-GENERATED BY codecgen. +// ************************************************************ + +package benchmark + +import ( + "errors" + "fmt" + "reflect" + "runtime" + "unsafe" + + codec1978 "github.com/ugorji/go/codec" +) + +const ( + // ----- content types ---- + codecSelferC_UTF89225 = 1 + codecSelferC_RAW9225 = 0 + // ----- value types used ---- + codecSelferValueTypeArray9225 = 10 + codecSelferValueTypeMap9225 = 9 + // ----- containerStateValues ---- + codecSelfer_containerMapKey9225 = 2 + codecSelfer_containerMapValue9225 = 3 + codecSelfer_containerMapEnd9225 = 4 + codecSelfer_containerArrayElem9225 = 6 + codecSelfer_containerArrayEnd9225 = 7 +) + +var ( + codecSelferBitsize9225 = uint8(reflect.TypeOf(uint(0)).Bits()) + codecSelferOnlyMapOrArrayEncodeToStructErr9225 = errors.New(`only encoded map or array can be decoded into a struct`) +) + +type codecSelferUnsafeString9225 struct { + Data uintptr + Len int +} + +type codecSelfer9225 struct{} + +func init() { + if codec1978.GenVersion != 5 { + _, file, _, _ := runtime.Caller(0) + err := fmt.Errorf("codecgen version mismatch: current: %v, need %v. Re-generate file: %v", + 5, codec1978.GenVersion, file) + panic(err) + } + if false { // reference the types, but skip this branch at build/run time + var v0 unsafe.Pointer + _ = v0 + } +} + +func (x *SearchMetadata) CodecEncodeSelf(e *codec1978.Encoder) { + var h codecSelfer9225 + z, r := codec1978.GenHelperEncoder(e) + _, _, _ = h, z, r + if x == nil { + r.EncodeNil() + } else { + yym1 := z.EncBinary() + _ = yym1 + if false { + } else if z.HasExtensions() && z.EncExt(x) { + } else { + yysep2 := !z.EncBinary() + yy2arr2 := z.EncBasicHandle().StructToArray + var yyq2 [9]bool + _, _, _ = yysep2, yyq2, yy2arr2 + const yyr2 bool = false + var yynn2 int + if yyr2 || yy2arr2 { + r.EncodeArrayStart(9) + } else { + yynn2 = 9 + for _, b := range yyq2 { + if b { + yynn2++ + } + } + r.EncodeMapStart(yynn2) + yynn2 = 0 + } + if yyr2 || yy2arr2 { + z.EncSendContainerState(codecSelfer_containerArrayElem9225) + yym4 := z.EncBinary() + _ = yym4 + if false { + } else { + r.EncodeFloat64(float64(x.CompletedIn)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey9225) + r.EncodeString(codecSelferC_UTF89225, string("completed_in")) + z.EncSendContainerState(codecSelfer_containerMapValue9225) + yym5 := z.EncBinary() + _ = yym5 + if false { + } else { + r.EncodeFloat64(float64(x.CompletedIn)) + } + } + if yyr2 || yy2arr2 { + z.EncSendContainerState(codecSelfer_containerArrayElem9225) + yym7 := z.EncBinary() + _ = yym7 + if false { + } else { + r.EncodeInt(int64(x.Count)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey9225) + r.EncodeString(codecSelferC_UTF89225, string("count")) + z.EncSendContainerState(codecSelfer_containerMapValue9225) + yym8 := z.EncBinary() + _ = yym8 + if false { + } else { + r.EncodeInt(int64(x.Count)) + } + } + if yyr2 || yy2arr2 { + z.EncSendContainerState(codecSelfer_containerArrayElem9225) + yym10 := z.EncBinary() + _ = yym10 + if false { + } else { + r.EncodeInt(int64(x.MaxID)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey9225) + r.EncodeString(codecSelferC_UTF89225, string("max_id")) + z.EncSendContainerState(codecSelfer_containerMapValue9225) + yym11 := z.EncBinary() + _ = yym11 + if false { + } else { + r.EncodeInt(int64(x.MaxID)) + } + } + if yyr2 || yy2arr2 { + z.EncSendContainerState(codecSelfer_containerArrayElem9225) + yym13 := z.EncBinary() + _ = yym13 + if false { + } else { + r.EncodeString(codecSelferC_UTF89225, string(x.MaxIDStr)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey9225) + r.EncodeString(codecSelferC_UTF89225, string("max_id_str")) + z.EncSendContainerState(codecSelfer_containerMapValue9225) + yym14 := z.EncBinary() + _ = yym14 + if false { + } else { + r.EncodeString(codecSelferC_UTF89225, string(x.MaxIDStr)) + } + } + if yyr2 || yy2arr2 { + z.EncSendContainerState(codecSelfer_containerArrayElem9225) + yym16 := z.EncBinary() + _ = yym16 + if false { + } else { + r.EncodeString(codecSelferC_UTF89225, string(x.NextResults)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey9225) + r.EncodeString(codecSelferC_UTF89225, string("next_results")) + z.EncSendContainerState(codecSelfer_containerMapValue9225) + yym17 := z.EncBinary() + _ = yym17 + if false { + } else { + r.EncodeString(codecSelferC_UTF89225, string(x.NextResults)) + } + } + if yyr2 || yy2arr2 { + z.EncSendContainerState(codecSelfer_containerArrayElem9225) + yym19 := z.EncBinary() + _ = yym19 + if false { + } else { + r.EncodeString(codecSelferC_UTF89225, string(x.Query)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey9225) + r.EncodeString(codecSelferC_UTF89225, string("query")) + z.EncSendContainerState(codecSelfer_containerMapValue9225) + yym20 := z.EncBinary() + _ = yym20 + if false { + } else { + r.EncodeString(codecSelferC_UTF89225, string(x.Query)) + } + } + if yyr2 || yy2arr2 { + z.EncSendContainerState(codecSelfer_containerArrayElem9225) + yym22 := z.EncBinary() + _ = yym22 + if false { + } else { + r.EncodeString(codecSelferC_UTF89225, string(x.RefreshURL)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey9225) + r.EncodeString(codecSelferC_UTF89225, string("refresh_url")) + z.EncSendContainerState(codecSelfer_containerMapValue9225) + yym23 := z.EncBinary() + _ = yym23 + if false { + } else { + r.EncodeString(codecSelferC_UTF89225, string(x.RefreshURL)) + } + } + if yyr2 || yy2arr2 { + z.EncSendContainerState(codecSelfer_containerArrayElem9225) + yym25 := z.EncBinary() + _ = yym25 + if false { + } else { + r.EncodeInt(int64(x.SinceID)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey9225) + r.EncodeString(codecSelferC_UTF89225, string("since_id")) + z.EncSendContainerState(codecSelfer_containerMapValue9225) + yym26 := z.EncBinary() + _ = yym26 + if false { + } else { + r.EncodeInt(int64(x.SinceID)) + } + } + if yyr2 || yy2arr2 { + z.EncSendContainerState(codecSelfer_containerArrayElem9225) + yym28 := z.EncBinary() + _ = yym28 + if false { + } else { + r.EncodeString(codecSelferC_UTF89225, string(x.SinceIDStr)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey9225) + r.EncodeString(codecSelferC_UTF89225, string("since_id_str")) + z.EncSendContainerState(codecSelfer_containerMapValue9225) + yym29 := z.EncBinary() + _ = yym29 + if false { + } else { + r.EncodeString(codecSelferC_UTF89225, string(x.SinceIDStr)) + } + } + if yyr2 || yy2arr2 { + z.EncSendContainerState(codecSelfer_containerArrayEnd9225) + } else { + z.EncSendContainerState(codecSelfer_containerMapEnd9225) + } + } + } +} + +func (x *SearchMetadata) CodecDecodeSelf(d *codec1978.Decoder) { + var h codecSelfer9225 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + yym1 := z.DecBinary() + _ = yym1 + if false { + } else if z.HasExtensions() && z.DecExt(x) { + } else { + yyct2 := r.ContainerType() + if yyct2 == codecSelferValueTypeMap9225 { + yyl2 := r.ReadMapStart() + if yyl2 == 0 { + z.DecSendContainerState(codecSelfer_containerMapEnd9225) + } else { + x.codecDecodeSelfFromMap(yyl2, d) + } + } else if yyct2 == codecSelferValueTypeArray9225 { + yyl2 := r.ReadArrayStart() + if yyl2 == 0 { + z.DecSendContainerState(codecSelfer_containerArrayEnd9225) + } else { + x.codecDecodeSelfFromArray(yyl2, d) + } + } else { + panic(codecSelferOnlyMapOrArrayEncodeToStructErr9225) + } + } +} + +func (x *SearchMetadata) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { + var h codecSelfer9225 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + var yys3Slc = z.DecScratchBuffer() // default slice to decode into + _ = yys3Slc + var yyhl3 bool = l >= 0 + for yyj3 := 0; ; yyj3++ { + if yyhl3 { + if yyj3 >= l { + break + } + } else { + if r.CheckBreak() { + break + } + } + z.DecSendContainerState(codecSelfer_containerMapKey9225) + yys3Slc = r.DecodeBytes(yys3Slc, true, true) + yys3SlcHdr := codecSelferUnsafeString9225{uintptr(unsafe.Pointer(&yys3Slc[0])), len(yys3Slc)} + yys3 := *(*string)(unsafe.Pointer(&yys3SlcHdr)) + z.DecSendContainerState(codecSelfer_containerMapValue9225) + switch yys3 { + case "completed_in": + if r.TryDecodeAsNil() { + x.CompletedIn = 0 + } else { + yyv4 := &x.CompletedIn + yym5 := z.DecBinary() + _ = yym5 + if false { + } else { + *((*float64)(yyv4)) = float64(r.DecodeFloat(false)) + } + } + case "count": + if r.TryDecodeAsNil() { + x.Count = 0 + } else { + yyv6 := &x.Count + yym7 := z.DecBinary() + _ = yym7 + if false { + } else { + *((*int)(yyv6)) = int(r.DecodeInt(codecSelferBitsize9225)) + } + } + case "max_id": + if r.TryDecodeAsNil() { + x.MaxID = 0 + } else { + yyv8 := &x.MaxID + yym9 := z.DecBinary() + _ = yym9 + if false { + } else { + *((*int)(yyv8)) = int(r.DecodeInt(codecSelferBitsize9225)) + } + } + case "max_id_str": + if r.TryDecodeAsNil() { + x.MaxIDStr = "" + } else { + yyv10 := &x.MaxIDStr + yym11 := z.DecBinary() + _ = yym11 + if false { + } else { + *((*string)(yyv10)) = r.DecodeString() + } + } + case "next_results": + if r.TryDecodeAsNil() { + x.NextResults = "" + } else { + yyv12 := &x.NextResults + yym13 := z.DecBinary() + _ = yym13 + if false { + } else { + *((*string)(yyv12)) = r.DecodeString() + } + } + case "query": + if r.TryDecodeAsNil() { + x.Query = "" + } else { + yyv14 := &x.Query + yym15 := z.DecBinary() + _ = yym15 + if false { + } else { + *((*string)(yyv14)) = r.DecodeString() + } + } + case "refresh_url": + if r.TryDecodeAsNil() { + x.RefreshURL = "" + } else { + yyv16 := &x.RefreshURL + yym17 := z.DecBinary() + _ = yym17 + if false { + } else { + *((*string)(yyv16)) = r.DecodeString() + } + } + case "since_id": + if r.TryDecodeAsNil() { + x.SinceID = 0 + } else { + yyv18 := &x.SinceID + yym19 := z.DecBinary() + _ = yym19 + if false { + } else { + *((*int)(yyv18)) = int(r.DecodeInt(codecSelferBitsize9225)) + } + } + case "since_id_str": + if r.TryDecodeAsNil() { + x.SinceIDStr = "" + } else { + yyv20 := &x.SinceIDStr + yym21 := z.DecBinary() + _ = yym21 + if false { + } else { + *((*string)(yyv20)) = r.DecodeString() + } + } + default: + z.DecStructFieldNotFound(-1, yys3) + } // end switch yys3 + } // end for yyj3 + z.DecSendContainerState(codecSelfer_containerMapEnd9225) +} + +func (x *SearchMetadata) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { + var h codecSelfer9225 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + var yyj22 int + var yyb22 bool + var yyhl22 bool = l >= 0 + yyj22++ + if yyhl22 { + yyb22 = yyj22 > l + } else { + yyb22 = r.CheckBreak() + } + if yyb22 { + z.DecSendContainerState(codecSelfer_containerArrayEnd9225) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem9225) + if r.TryDecodeAsNil() { + x.CompletedIn = 0 + } else { + yyv23 := &x.CompletedIn + yym24 := z.DecBinary() + _ = yym24 + if false { + } else { + *((*float64)(yyv23)) = float64(r.DecodeFloat(false)) + } + } + yyj22++ + if yyhl22 { + yyb22 = yyj22 > l + } else { + yyb22 = r.CheckBreak() + } + if yyb22 { + z.DecSendContainerState(codecSelfer_containerArrayEnd9225) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem9225) + if r.TryDecodeAsNil() { + x.Count = 0 + } else { + yyv25 := &x.Count + yym26 := z.DecBinary() + _ = yym26 + if false { + } else { + *((*int)(yyv25)) = int(r.DecodeInt(codecSelferBitsize9225)) + } + } + yyj22++ + if yyhl22 { + yyb22 = yyj22 > l + } else { + yyb22 = r.CheckBreak() + } + if yyb22 { + z.DecSendContainerState(codecSelfer_containerArrayEnd9225) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem9225) + if r.TryDecodeAsNil() { + x.MaxID = 0 + } else { + yyv27 := &x.MaxID + yym28 := z.DecBinary() + _ = yym28 + if false { + } else { + *((*int)(yyv27)) = int(r.DecodeInt(codecSelferBitsize9225)) + } + } + yyj22++ + if yyhl22 { + yyb22 = yyj22 > l + } else { + yyb22 = r.CheckBreak() + } + if yyb22 { + z.DecSendContainerState(codecSelfer_containerArrayEnd9225) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem9225) + if r.TryDecodeAsNil() { + x.MaxIDStr = "" + } else { + yyv29 := &x.MaxIDStr + yym30 := z.DecBinary() + _ = yym30 + if false { + } else { + *((*string)(yyv29)) = r.DecodeString() + } + } + yyj22++ + if yyhl22 { + yyb22 = yyj22 > l + } else { + yyb22 = r.CheckBreak() + } + if yyb22 { + z.DecSendContainerState(codecSelfer_containerArrayEnd9225) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem9225) + if r.TryDecodeAsNil() { + x.NextResults = "" + } else { + yyv31 := &x.NextResults + yym32 := z.DecBinary() + _ = yym32 + if false { + } else { + *((*string)(yyv31)) = r.DecodeString() + } + } + yyj22++ + if yyhl22 { + yyb22 = yyj22 > l + } else { + yyb22 = r.CheckBreak() + } + if yyb22 { + z.DecSendContainerState(codecSelfer_containerArrayEnd9225) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem9225) + if r.TryDecodeAsNil() { + x.Query = "" + } else { + yyv33 := &x.Query + yym34 := z.DecBinary() + _ = yym34 + if false { + } else { + *((*string)(yyv33)) = r.DecodeString() + } + } + yyj22++ + if yyhl22 { + yyb22 = yyj22 > l + } else { + yyb22 = r.CheckBreak() + } + if yyb22 { + z.DecSendContainerState(codecSelfer_containerArrayEnd9225) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem9225) + if r.TryDecodeAsNil() { + x.RefreshURL = "" + } else { + yyv35 := &x.RefreshURL + yym36 := z.DecBinary() + _ = yym36 + if false { + } else { + *((*string)(yyv35)) = r.DecodeString() + } + } + yyj22++ + if yyhl22 { + yyb22 = yyj22 > l + } else { + yyb22 = r.CheckBreak() + } + if yyb22 { + z.DecSendContainerState(codecSelfer_containerArrayEnd9225) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem9225) + if r.TryDecodeAsNil() { + x.SinceID = 0 + } else { + yyv37 := &x.SinceID + yym38 := z.DecBinary() + _ = yym38 + if false { + } else { + *((*int)(yyv37)) = int(r.DecodeInt(codecSelferBitsize9225)) + } + } + yyj22++ + if yyhl22 { + yyb22 = yyj22 > l + } else { + yyb22 = r.CheckBreak() + } + if yyb22 { + z.DecSendContainerState(codecSelfer_containerArrayEnd9225) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem9225) + if r.TryDecodeAsNil() { + x.SinceIDStr = "" + } else { + yyv39 := &x.SinceIDStr + yym40 := z.DecBinary() + _ = yym40 + if false { + } else { + *((*string)(yyv39)) = r.DecodeString() + } + } + for { + yyj22++ + if yyhl22 { + yyb22 = yyj22 > l + } else { + yyb22 = r.CheckBreak() + } + if yyb22 { + break + } + z.DecSendContainerState(codecSelfer_containerArrayElem9225) + z.DecStructFieldNotFound(yyj22-1, "") + } + z.DecSendContainerState(codecSelfer_containerArrayEnd9225) +} + +func (x *Hashtag) CodecEncodeSelf(e *codec1978.Encoder) { + var h codecSelfer9225 + z, r := codec1978.GenHelperEncoder(e) + _, _, _ = h, z, r + if x == nil { + r.EncodeNil() + } else { + yym1 := z.EncBinary() + _ = yym1 + if false { + } else if z.HasExtensions() && z.EncExt(x) { + } else { + yysep2 := !z.EncBinary() + yy2arr2 := z.EncBasicHandle().StructToArray + var yyq2 [2]bool + _, _, _ = yysep2, yyq2, yy2arr2 + const yyr2 bool = false + var yynn2 int + if yyr2 || yy2arr2 { + r.EncodeArrayStart(2) + } else { + yynn2 = 2 + for _, b := range yyq2 { + if b { + yynn2++ + } + } + r.EncodeMapStart(yynn2) + yynn2 = 0 + } + if yyr2 || yy2arr2 { + z.EncSendContainerState(codecSelfer_containerArrayElem9225) + if x.Indices == nil { + r.EncodeNil() + } else { + yym4 := z.EncBinary() + _ = yym4 + if false { + } else { + z.F.EncSliceIntV(x.Indices, false, e) + } + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey9225) + r.EncodeString(codecSelferC_UTF89225, string("indices")) + z.EncSendContainerState(codecSelfer_containerMapValue9225) + if x.Indices == nil { + r.EncodeNil() + } else { + yym5 := z.EncBinary() + _ = yym5 + if false { + } else { + z.F.EncSliceIntV(x.Indices, false, e) + } + } + } + if yyr2 || yy2arr2 { + z.EncSendContainerState(codecSelfer_containerArrayElem9225) + yym7 := z.EncBinary() + _ = yym7 + if false { + } else { + r.EncodeString(codecSelferC_UTF89225, string(x.Text)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey9225) + r.EncodeString(codecSelferC_UTF89225, string("text")) + z.EncSendContainerState(codecSelfer_containerMapValue9225) + yym8 := z.EncBinary() + _ = yym8 + if false { + } else { + r.EncodeString(codecSelferC_UTF89225, string(x.Text)) + } + } + if yyr2 || yy2arr2 { + z.EncSendContainerState(codecSelfer_containerArrayEnd9225) + } else { + z.EncSendContainerState(codecSelfer_containerMapEnd9225) + } + } + } +} + +func (x *Hashtag) CodecDecodeSelf(d *codec1978.Decoder) { + var h codecSelfer9225 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + yym1 := z.DecBinary() + _ = yym1 + if false { + } else if z.HasExtensions() && z.DecExt(x) { + } else { + yyct2 := r.ContainerType() + if yyct2 == codecSelferValueTypeMap9225 { + yyl2 := r.ReadMapStart() + if yyl2 == 0 { + z.DecSendContainerState(codecSelfer_containerMapEnd9225) + } else { + x.codecDecodeSelfFromMap(yyl2, d) + } + } else if yyct2 == codecSelferValueTypeArray9225 { + yyl2 := r.ReadArrayStart() + if yyl2 == 0 { + z.DecSendContainerState(codecSelfer_containerArrayEnd9225) + } else { + x.codecDecodeSelfFromArray(yyl2, d) + } + } else { + panic(codecSelferOnlyMapOrArrayEncodeToStructErr9225) + } + } +} + +func (x *Hashtag) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { + var h codecSelfer9225 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + var yys3Slc = z.DecScratchBuffer() // default slice to decode into + _ = yys3Slc + var yyhl3 bool = l >= 0 + for yyj3 := 0; ; yyj3++ { + if yyhl3 { + if yyj3 >= l { + break + } + } else { + if r.CheckBreak() { + break + } + } + z.DecSendContainerState(codecSelfer_containerMapKey9225) + yys3Slc = r.DecodeBytes(yys3Slc, true, true) + yys3SlcHdr := codecSelferUnsafeString9225{uintptr(unsafe.Pointer(&yys3Slc[0])), len(yys3Slc)} + yys3 := *(*string)(unsafe.Pointer(&yys3SlcHdr)) + z.DecSendContainerState(codecSelfer_containerMapValue9225) + switch yys3 { + case "indices": + if r.TryDecodeAsNil() { + x.Indices = nil + } else { + yyv4 := &x.Indices + yym5 := z.DecBinary() + _ = yym5 + if false { + } else { + z.F.DecSliceIntX(yyv4, false, d) + } + } + case "text": + if r.TryDecodeAsNil() { + x.Text = "" + } else { + yyv6 := &x.Text + yym7 := z.DecBinary() + _ = yym7 + if false { + } else { + *((*string)(yyv6)) = r.DecodeString() + } + } + default: + z.DecStructFieldNotFound(-1, yys3) + } // end switch yys3 + } // end for yyj3 + z.DecSendContainerState(codecSelfer_containerMapEnd9225) +} + +func (x *Hashtag) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { + var h codecSelfer9225 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + var yyj8 int + var yyb8 bool + var yyhl8 bool = l >= 0 + yyj8++ + if yyhl8 { + yyb8 = yyj8 > l + } else { + yyb8 = r.CheckBreak() + } + if yyb8 { + z.DecSendContainerState(codecSelfer_containerArrayEnd9225) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem9225) + if r.TryDecodeAsNil() { + x.Indices = nil + } else { + yyv9 := &x.Indices + yym10 := z.DecBinary() + _ = yym10 + if false { + } else { + z.F.DecSliceIntX(yyv9, false, d) + } + } + yyj8++ + if yyhl8 { + yyb8 = yyj8 > l + } else { + yyb8 = r.CheckBreak() + } + if yyb8 { + z.DecSendContainerState(codecSelfer_containerArrayEnd9225) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem9225) + if r.TryDecodeAsNil() { + x.Text = "" + } else { + yyv11 := &x.Text + yym12 := z.DecBinary() + _ = yym12 + if false { + } else { + *((*string)(yyv11)) = r.DecodeString() + } + } + for { + yyj8++ + if yyhl8 { + yyb8 = yyj8 > l + } else { + yyb8 = r.CheckBreak() + } + if yyb8 { + break + } + z.DecSendContainerState(codecSelfer_containerArrayElem9225) + z.DecStructFieldNotFound(yyj8-1, "") + } + z.DecSendContainerState(codecSelfer_containerArrayEnd9225) +} + +func (x *Entities) CodecEncodeSelf(e *codec1978.Encoder) { + var h codecSelfer9225 + z, r := codec1978.GenHelperEncoder(e) + _, _, _ = h, z, r + if x == nil { + r.EncodeNil() + } else { + yym1 := z.EncBinary() + _ = yym1 + if false { + } else if z.HasExtensions() && z.EncExt(x) { + } else { + yysep2 := !z.EncBinary() + yy2arr2 := z.EncBasicHandle().StructToArray + var yyq2 [3]bool + _, _, _ = yysep2, yyq2, yy2arr2 + const yyr2 bool = false + var yynn2 int + if yyr2 || yy2arr2 { + r.EncodeArrayStart(3) + } else { + yynn2 = 3 + for _, b := range yyq2 { + if b { + yynn2++ + } + } + r.EncodeMapStart(yynn2) + yynn2 = 0 + } + if yyr2 || yy2arr2 { + z.EncSendContainerState(codecSelfer_containerArrayElem9225) + if x.Hashtags == nil { + r.EncodeNil() + } else { + yym4 := z.EncBinary() + _ = yym4 + if false { + } else { + h.encSliceHashtag(([]Hashtag)(x.Hashtags), e) + } + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey9225) + r.EncodeString(codecSelferC_UTF89225, string("hashtags")) + z.EncSendContainerState(codecSelfer_containerMapValue9225) + if x.Hashtags == nil { + r.EncodeNil() + } else { + yym5 := z.EncBinary() + _ = yym5 + if false { + } else { + h.encSliceHashtag(([]Hashtag)(x.Hashtags), e) + } + } + } + if yyr2 || yy2arr2 { + z.EncSendContainerState(codecSelfer_containerArrayElem9225) + if x.Urls == nil { + r.EncodeNil() + } else { + yym7 := z.EncBinary() + _ = yym7 + if false { + } else { + h.encSlicePtrtostring(([]*string)(x.Urls), e) + } + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey9225) + r.EncodeString(codecSelferC_UTF89225, string("urls")) + z.EncSendContainerState(codecSelfer_containerMapValue9225) + if x.Urls == nil { + r.EncodeNil() + } else { + yym8 := z.EncBinary() + _ = yym8 + if false { + } else { + h.encSlicePtrtostring(([]*string)(x.Urls), e) + } + } + } + if yyr2 || yy2arr2 { + z.EncSendContainerState(codecSelfer_containerArrayElem9225) + if x.UserMentions == nil { + r.EncodeNil() + } else { + yym10 := z.EncBinary() + _ = yym10 + if false { + } else { + h.encSlicePtrtostring(([]*string)(x.UserMentions), e) + } + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey9225) + r.EncodeString(codecSelferC_UTF89225, string("user_mentions")) + z.EncSendContainerState(codecSelfer_containerMapValue9225) + if x.UserMentions == nil { + r.EncodeNil() + } else { + yym11 := z.EncBinary() + _ = yym11 + if false { + } else { + h.encSlicePtrtostring(([]*string)(x.UserMentions), e) + } + } + } + if yyr2 || yy2arr2 { + z.EncSendContainerState(codecSelfer_containerArrayEnd9225) + } else { + z.EncSendContainerState(codecSelfer_containerMapEnd9225) + } + } + } +} + +func (x *Entities) CodecDecodeSelf(d *codec1978.Decoder) { + var h codecSelfer9225 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + yym1 := z.DecBinary() + _ = yym1 + if false { + } else if z.HasExtensions() && z.DecExt(x) { + } else { + yyct2 := r.ContainerType() + if yyct2 == codecSelferValueTypeMap9225 { + yyl2 := r.ReadMapStart() + if yyl2 == 0 { + z.DecSendContainerState(codecSelfer_containerMapEnd9225) + } else { + x.codecDecodeSelfFromMap(yyl2, d) + } + } else if yyct2 == codecSelferValueTypeArray9225 { + yyl2 := r.ReadArrayStart() + if yyl2 == 0 { + z.DecSendContainerState(codecSelfer_containerArrayEnd9225) + } else { + x.codecDecodeSelfFromArray(yyl2, d) + } + } else { + panic(codecSelferOnlyMapOrArrayEncodeToStructErr9225) + } + } +} + +func (x *Entities) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { + var h codecSelfer9225 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + var yys3Slc = z.DecScratchBuffer() // default slice to decode into + _ = yys3Slc + var yyhl3 bool = l >= 0 + for yyj3 := 0; ; yyj3++ { + if yyhl3 { + if yyj3 >= l { + break + } + } else { + if r.CheckBreak() { + break + } + } + z.DecSendContainerState(codecSelfer_containerMapKey9225) + yys3Slc = r.DecodeBytes(yys3Slc, true, true) + yys3SlcHdr := codecSelferUnsafeString9225{uintptr(unsafe.Pointer(&yys3Slc[0])), len(yys3Slc)} + yys3 := *(*string)(unsafe.Pointer(&yys3SlcHdr)) + z.DecSendContainerState(codecSelfer_containerMapValue9225) + switch yys3 { + case "hashtags": + if r.TryDecodeAsNil() { + x.Hashtags = nil + } else { + yyv4 := &x.Hashtags + yym5 := z.DecBinary() + _ = yym5 + if false { + } else { + h.decSliceHashtag((*[]Hashtag)(yyv4), d) + } + } + case "urls": + if r.TryDecodeAsNil() { + x.Urls = nil + } else { + yyv6 := &x.Urls + yym7 := z.DecBinary() + _ = yym7 + if false { + } else { + h.decSlicePtrtostring((*[]*string)(yyv6), d) + } + } + case "user_mentions": + if r.TryDecodeAsNil() { + x.UserMentions = nil + } else { + yyv8 := &x.UserMentions + yym9 := z.DecBinary() + _ = yym9 + if false { + } else { + h.decSlicePtrtostring((*[]*string)(yyv8), d) + } + } + default: + z.DecStructFieldNotFound(-1, yys3) + } // end switch yys3 + } // end for yyj3 + z.DecSendContainerState(codecSelfer_containerMapEnd9225) +} + +func (x *Entities) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { + var h codecSelfer9225 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + var yyj10 int + var yyb10 bool + var yyhl10 bool = l >= 0 + yyj10++ + if yyhl10 { + yyb10 = yyj10 > l + } else { + yyb10 = r.CheckBreak() + } + if yyb10 { + z.DecSendContainerState(codecSelfer_containerArrayEnd9225) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem9225) + if r.TryDecodeAsNil() { + x.Hashtags = nil + } else { + yyv11 := &x.Hashtags + yym12 := z.DecBinary() + _ = yym12 + if false { + } else { + h.decSliceHashtag((*[]Hashtag)(yyv11), d) + } + } + yyj10++ + if yyhl10 { + yyb10 = yyj10 > l + } else { + yyb10 = r.CheckBreak() + } + if yyb10 { + z.DecSendContainerState(codecSelfer_containerArrayEnd9225) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem9225) + if r.TryDecodeAsNil() { + x.Urls = nil + } else { + yyv13 := &x.Urls + yym14 := z.DecBinary() + _ = yym14 + if false { + } else { + h.decSlicePtrtostring((*[]*string)(yyv13), d) + } + } + yyj10++ + if yyhl10 { + yyb10 = yyj10 > l + } else { + yyb10 = r.CheckBreak() + } + if yyb10 { + z.DecSendContainerState(codecSelfer_containerArrayEnd9225) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem9225) + if r.TryDecodeAsNil() { + x.UserMentions = nil + } else { + yyv15 := &x.UserMentions + yym16 := z.DecBinary() + _ = yym16 + if false { + } else { + h.decSlicePtrtostring((*[]*string)(yyv15), d) + } + } + for { + yyj10++ + if yyhl10 { + yyb10 = yyj10 > l + } else { + yyb10 = r.CheckBreak() + } + if yyb10 { + break + } + z.DecSendContainerState(codecSelfer_containerArrayElem9225) + z.DecStructFieldNotFound(yyj10-1, "") + } + z.DecSendContainerState(codecSelfer_containerArrayEnd9225) +} + +func (x *UserEntityDescription) CodecEncodeSelf(e *codec1978.Encoder) { + var h codecSelfer9225 + z, r := codec1978.GenHelperEncoder(e) + _, _, _ = h, z, r + if x == nil { + r.EncodeNil() + } else { + yym1 := z.EncBinary() + _ = yym1 + if false { + } else if z.HasExtensions() && z.EncExt(x) { + } else { + yysep2 := !z.EncBinary() + yy2arr2 := z.EncBasicHandle().StructToArray + var yyq2 [1]bool + _, _, _ = yysep2, yyq2, yy2arr2 + const yyr2 bool = false + var yynn2 int + if yyr2 || yy2arr2 { + r.EncodeArrayStart(1) + } else { + yynn2 = 1 + for _, b := range yyq2 { + if b { + yynn2++ + } + } + r.EncodeMapStart(yynn2) + yynn2 = 0 + } + if yyr2 || yy2arr2 { + z.EncSendContainerState(codecSelfer_containerArrayElem9225) + if x.Urls == nil { + r.EncodeNil() + } else { + yym4 := z.EncBinary() + _ = yym4 + if false { + } else { + h.encSlicePtrtostring(([]*string)(x.Urls), e) + } + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey9225) + r.EncodeString(codecSelferC_UTF89225, string("urls")) + z.EncSendContainerState(codecSelfer_containerMapValue9225) + if x.Urls == nil { + r.EncodeNil() + } else { + yym5 := z.EncBinary() + _ = yym5 + if false { + } else { + h.encSlicePtrtostring(([]*string)(x.Urls), e) + } + } + } + if yyr2 || yy2arr2 { + z.EncSendContainerState(codecSelfer_containerArrayEnd9225) + } else { + z.EncSendContainerState(codecSelfer_containerMapEnd9225) + } + } + } +} + +func (x *UserEntityDescription) CodecDecodeSelf(d *codec1978.Decoder) { + var h codecSelfer9225 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + yym1 := z.DecBinary() + _ = yym1 + if false { + } else if z.HasExtensions() && z.DecExt(x) { + } else { + yyct2 := r.ContainerType() + if yyct2 == codecSelferValueTypeMap9225 { + yyl2 := r.ReadMapStart() + if yyl2 == 0 { + z.DecSendContainerState(codecSelfer_containerMapEnd9225) + } else { + x.codecDecodeSelfFromMap(yyl2, d) + } + } else if yyct2 == codecSelferValueTypeArray9225 { + yyl2 := r.ReadArrayStart() + if yyl2 == 0 { + z.DecSendContainerState(codecSelfer_containerArrayEnd9225) + } else { + x.codecDecodeSelfFromArray(yyl2, d) + } + } else { + panic(codecSelferOnlyMapOrArrayEncodeToStructErr9225) + } + } +} + +func (x *UserEntityDescription) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { + var h codecSelfer9225 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + var yys3Slc = z.DecScratchBuffer() // default slice to decode into + _ = yys3Slc + var yyhl3 bool = l >= 0 + for yyj3 := 0; ; yyj3++ { + if yyhl3 { + if yyj3 >= l { + break + } + } else { + if r.CheckBreak() { + break + } + } + z.DecSendContainerState(codecSelfer_containerMapKey9225) + yys3Slc = r.DecodeBytes(yys3Slc, true, true) + yys3SlcHdr := codecSelferUnsafeString9225{uintptr(unsafe.Pointer(&yys3Slc[0])), len(yys3Slc)} + yys3 := *(*string)(unsafe.Pointer(&yys3SlcHdr)) + z.DecSendContainerState(codecSelfer_containerMapValue9225) + switch yys3 { + case "urls": + if r.TryDecodeAsNil() { + x.Urls = nil + } else { + yyv4 := &x.Urls + yym5 := z.DecBinary() + _ = yym5 + if false { + } else { + h.decSlicePtrtostring((*[]*string)(yyv4), d) + } + } + default: + z.DecStructFieldNotFound(-1, yys3) + } // end switch yys3 + } // end for yyj3 + z.DecSendContainerState(codecSelfer_containerMapEnd9225) +} + +func (x *UserEntityDescription) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { + var h codecSelfer9225 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + var yyj6 int + var yyb6 bool + var yyhl6 bool = l >= 0 + yyj6++ + if yyhl6 { + yyb6 = yyj6 > l + } else { + yyb6 = r.CheckBreak() + } + if yyb6 { + z.DecSendContainerState(codecSelfer_containerArrayEnd9225) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem9225) + if r.TryDecodeAsNil() { + x.Urls = nil + } else { + yyv7 := &x.Urls + yym8 := z.DecBinary() + _ = yym8 + if false { + } else { + h.decSlicePtrtostring((*[]*string)(yyv7), d) + } + } + for { + yyj6++ + if yyhl6 { + yyb6 = yyj6 > l + } else { + yyb6 = r.CheckBreak() + } + if yyb6 { + break + } + z.DecSendContainerState(codecSelfer_containerArrayElem9225) + z.DecStructFieldNotFound(yyj6-1, "") + } + z.DecSendContainerState(codecSelfer_containerArrayEnd9225) +} + +func (x *URL) CodecEncodeSelf(e *codec1978.Encoder) { + var h codecSelfer9225 + z, r := codec1978.GenHelperEncoder(e) + _, _, _ = h, z, r + if x == nil { + r.EncodeNil() + } else { + yym1 := z.EncBinary() + _ = yym1 + if false { + } else if z.HasExtensions() && z.EncExt(x) { + } else { + yysep2 := !z.EncBinary() + yy2arr2 := z.EncBasicHandle().StructToArray + var yyq2 [3]bool + _, _, _ = yysep2, yyq2, yy2arr2 + const yyr2 bool = false + var yynn2 int + if yyr2 || yy2arr2 { + r.EncodeArrayStart(3) + } else { + yynn2 = 3 + for _, b := range yyq2 { + if b { + yynn2++ + } + } + r.EncodeMapStart(yynn2) + yynn2 = 0 + } + if yyr2 || yy2arr2 { + z.EncSendContainerState(codecSelfer_containerArrayElem9225) + if x.ExpandedURL == nil { + r.EncodeNil() + } else { + yy4 := *x.ExpandedURL + yym5 := z.EncBinary() + _ = yym5 + if false { + } else { + r.EncodeString(codecSelferC_UTF89225, string(yy4)) + } + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey9225) + r.EncodeString(codecSelferC_UTF89225, string("expanded_url")) + z.EncSendContainerState(codecSelfer_containerMapValue9225) + if x.ExpandedURL == nil { + r.EncodeNil() + } else { + yy6 := *x.ExpandedURL + yym7 := z.EncBinary() + _ = yym7 + if false { + } else { + r.EncodeString(codecSelferC_UTF89225, string(yy6)) + } + } + } + if yyr2 || yy2arr2 { + z.EncSendContainerState(codecSelfer_containerArrayElem9225) + if x.Indices == nil { + r.EncodeNil() + } else { + yym9 := z.EncBinary() + _ = yym9 + if false { + } else { + z.F.EncSliceIntV(x.Indices, false, e) + } + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey9225) + r.EncodeString(codecSelferC_UTF89225, string("indices")) + z.EncSendContainerState(codecSelfer_containerMapValue9225) + if x.Indices == nil { + r.EncodeNil() + } else { + yym10 := z.EncBinary() + _ = yym10 + if false { + } else { + z.F.EncSliceIntV(x.Indices, false, e) + } + } + } + if yyr2 || yy2arr2 { + z.EncSendContainerState(codecSelfer_containerArrayElem9225) + yym12 := z.EncBinary() + _ = yym12 + if false { + } else { + r.EncodeString(codecSelferC_UTF89225, string(x.URL)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey9225) + r.EncodeString(codecSelferC_UTF89225, string("url")) + z.EncSendContainerState(codecSelfer_containerMapValue9225) + yym13 := z.EncBinary() + _ = yym13 + if false { + } else { + r.EncodeString(codecSelferC_UTF89225, string(x.URL)) + } + } + if yyr2 || yy2arr2 { + z.EncSendContainerState(codecSelfer_containerArrayEnd9225) + } else { + z.EncSendContainerState(codecSelfer_containerMapEnd9225) + } + } + } +} + +func (x *URL) CodecDecodeSelf(d *codec1978.Decoder) { + var h codecSelfer9225 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + yym1 := z.DecBinary() + _ = yym1 + if false { + } else if z.HasExtensions() && z.DecExt(x) { + } else { + yyct2 := r.ContainerType() + if yyct2 == codecSelferValueTypeMap9225 { + yyl2 := r.ReadMapStart() + if yyl2 == 0 { + z.DecSendContainerState(codecSelfer_containerMapEnd9225) + } else { + x.codecDecodeSelfFromMap(yyl2, d) + } + } else if yyct2 == codecSelferValueTypeArray9225 { + yyl2 := r.ReadArrayStart() + if yyl2 == 0 { + z.DecSendContainerState(codecSelfer_containerArrayEnd9225) + } else { + x.codecDecodeSelfFromArray(yyl2, d) + } + } else { + panic(codecSelferOnlyMapOrArrayEncodeToStructErr9225) + } + } +} + +func (x *URL) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { + var h codecSelfer9225 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + var yys3Slc = z.DecScratchBuffer() // default slice to decode into + _ = yys3Slc + var yyhl3 bool = l >= 0 + for yyj3 := 0; ; yyj3++ { + if yyhl3 { + if yyj3 >= l { + break + } + } else { + if r.CheckBreak() { + break + } + } + z.DecSendContainerState(codecSelfer_containerMapKey9225) + yys3Slc = r.DecodeBytes(yys3Slc, true, true) + yys3SlcHdr := codecSelferUnsafeString9225{uintptr(unsafe.Pointer(&yys3Slc[0])), len(yys3Slc)} + yys3 := *(*string)(unsafe.Pointer(&yys3SlcHdr)) + z.DecSendContainerState(codecSelfer_containerMapValue9225) + switch yys3 { + case "expanded_url": + if r.TryDecodeAsNil() { + if x.ExpandedURL != nil { + x.ExpandedURL = nil + } + } else { + if x.ExpandedURL == nil { + x.ExpandedURL = new(string) + } + yym5 := z.DecBinary() + _ = yym5 + if false { + } else { + *((*string)(x.ExpandedURL)) = r.DecodeString() + } + } + case "indices": + if r.TryDecodeAsNil() { + x.Indices = nil + } else { + yyv6 := &x.Indices + yym7 := z.DecBinary() + _ = yym7 + if false { + } else { + z.F.DecSliceIntX(yyv6, false, d) + } + } + case "url": + if r.TryDecodeAsNil() { + x.URL = "" + } else { + yyv8 := &x.URL + yym9 := z.DecBinary() + _ = yym9 + if false { + } else { + *((*string)(yyv8)) = r.DecodeString() + } + } + default: + z.DecStructFieldNotFound(-1, yys3) + } // end switch yys3 + } // end for yyj3 + z.DecSendContainerState(codecSelfer_containerMapEnd9225) +} + +func (x *URL) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { + var h codecSelfer9225 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + var yyj10 int + var yyb10 bool + var yyhl10 bool = l >= 0 + yyj10++ + if yyhl10 { + yyb10 = yyj10 > l + } else { + yyb10 = r.CheckBreak() + } + if yyb10 { + z.DecSendContainerState(codecSelfer_containerArrayEnd9225) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem9225) + if r.TryDecodeAsNil() { + if x.ExpandedURL != nil { + x.ExpandedURL = nil + } + } else { + if x.ExpandedURL == nil { + x.ExpandedURL = new(string) + } + yym12 := z.DecBinary() + _ = yym12 + if false { + } else { + *((*string)(x.ExpandedURL)) = r.DecodeString() + } + } + yyj10++ + if yyhl10 { + yyb10 = yyj10 > l + } else { + yyb10 = r.CheckBreak() + } + if yyb10 { + z.DecSendContainerState(codecSelfer_containerArrayEnd9225) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem9225) + if r.TryDecodeAsNil() { + x.Indices = nil + } else { + yyv13 := &x.Indices + yym14 := z.DecBinary() + _ = yym14 + if false { + } else { + z.F.DecSliceIntX(yyv13, false, d) + } + } + yyj10++ + if yyhl10 { + yyb10 = yyj10 > l + } else { + yyb10 = r.CheckBreak() + } + if yyb10 { + z.DecSendContainerState(codecSelfer_containerArrayEnd9225) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem9225) + if r.TryDecodeAsNil() { + x.URL = "" + } else { + yyv15 := &x.URL + yym16 := z.DecBinary() + _ = yym16 + if false { + } else { + *((*string)(yyv15)) = r.DecodeString() + } + } + for { + yyj10++ + if yyhl10 { + yyb10 = yyj10 > l + } else { + yyb10 = r.CheckBreak() + } + if yyb10 { + break + } + z.DecSendContainerState(codecSelfer_containerArrayElem9225) + z.DecStructFieldNotFound(yyj10-1, "") + } + z.DecSendContainerState(codecSelfer_containerArrayEnd9225) +} + +func (x *UserEntityURL) CodecEncodeSelf(e *codec1978.Encoder) { + var h codecSelfer9225 + z, r := codec1978.GenHelperEncoder(e) + _, _, _ = h, z, r + if x == nil { + r.EncodeNil() + } else { + yym1 := z.EncBinary() + _ = yym1 + if false { + } else if z.HasExtensions() && z.EncExt(x) { + } else { + yysep2 := !z.EncBinary() + yy2arr2 := z.EncBasicHandle().StructToArray + var yyq2 [1]bool + _, _, _ = yysep2, yyq2, yy2arr2 + const yyr2 bool = false + var yynn2 int + if yyr2 || yy2arr2 { + r.EncodeArrayStart(1) + } else { + yynn2 = 1 + for _, b := range yyq2 { + if b { + yynn2++ + } + } + r.EncodeMapStart(yynn2) + yynn2 = 0 + } + if yyr2 || yy2arr2 { + z.EncSendContainerState(codecSelfer_containerArrayElem9225) + if x.Urls == nil { + r.EncodeNil() + } else { + yym4 := z.EncBinary() + _ = yym4 + if false { + } else { + h.encSliceURL(([]URL)(x.Urls), e) + } + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey9225) + r.EncodeString(codecSelferC_UTF89225, string("urls")) + z.EncSendContainerState(codecSelfer_containerMapValue9225) + if x.Urls == nil { + r.EncodeNil() + } else { + yym5 := z.EncBinary() + _ = yym5 + if false { + } else { + h.encSliceURL(([]URL)(x.Urls), e) + } + } + } + if yyr2 || yy2arr2 { + z.EncSendContainerState(codecSelfer_containerArrayEnd9225) + } else { + z.EncSendContainerState(codecSelfer_containerMapEnd9225) + } + } + } +} + +func (x *UserEntityURL) CodecDecodeSelf(d *codec1978.Decoder) { + var h codecSelfer9225 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + yym1 := z.DecBinary() + _ = yym1 + if false { + } else if z.HasExtensions() && z.DecExt(x) { + } else { + yyct2 := r.ContainerType() + if yyct2 == codecSelferValueTypeMap9225 { + yyl2 := r.ReadMapStart() + if yyl2 == 0 { + z.DecSendContainerState(codecSelfer_containerMapEnd9225) + } else { + x.codecDecodeSelfFromMap(yyl2, d) + } + } else if yyct2 == codecSelferValueTypeArray9225 { + yyl2 := r.ReadArrayStart() + if yyl2 == 0 { + z.DecSendContainerState(codecSelfer_containerArrayEnd9225) + } else { + x.codecDecodeSelfFromArray(yyl2, d) + } + } else { + panic(codecSelferOnlyMapOrArrayEncodeToStructErr9225) + } + } +} + +func (x *UserEntityURL) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { + var h codecSelfer9225 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + var yys3Slc = z.DecScratchBuffer() // default slice to decode into + _ = yys3Slc + var yyhl3 bool = l >= 0 + for yyj3 := 0; ; yyj3++ { + if yyhl3 { + if yyj3 >= l { + break + } + } else { + if r.CheckBreak() { + break + } + } + z.DecSendContainerState(codecSelfer_containerMapKey9225) + yys3Slc = r.DecodeBytes(yys3Slc, true, true) + yys3SlcHdr := codecSelferUnsafeString9225{uintptr(unsafe.Pointer(&yys3Slc[0])), len(yys3Slc)} + yys3 := *(*string)(unsafe.Pointer(&yys3SlcHdr)) + z.DecSendContainerState(codecSelfer_containerMapValue9225) + switch yys3 { + case "urls": + if r.TryDecodeAsNil() { + x.Urls = nil + } else { + yyv4 := &x.Urls + yym5 := z.DecBinary() + _ = yym5 + if false { + } else { + h.decSliceURL((*[]URL)(yyv4), d) + } + } + default: + z.DecStructFieldNotFound(-1, yys3) + } // end switch yys3 + } // end for yyj3 + z.DecSendContainerState(codecSelfer_containerMapEnd9225) +} + +func (x *UserEntityURL) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { + var h codecSelfer9225 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + var yyj6 int + var yyb6 bool + var yyhl6 bool = l >= 0 + yyj6++ + if yyhl6 { + yyb6 = yyj6 > l + } else { + yyb6 = r.CheckBreak() + } + if yyb6 { + z.DecSendContainerState(codecSelfer_containerArrayEnd9225) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem9225) + if r.TryDecodeAsNil() { + x.Urls = nil + } else { + yyv7 := &x.Urls + yym8 := z.DecBinary() + _ = yym8 + if false { + } else { + h.decSliceURL((*[]URL)(yyv7), d) + } + } + for { + yyj6++ + if yyhl6 { + yyb6 = yyj6 > l + } else { + yyb6 = r.CheckBreak() + } + if yyb6 { + break + } + z.DecSendContainerState(codecSelfer_containerArrayElem9225) + z.DecStructFieldNotFound(yyj6-1, "") + } + z.DecSendContainerState(codecSelfer_containerArrayEnd9225) +} + +func (x *UserEntities) CodecEncodeSelf(e *codec1978.Encoder) { + var h codecSelfer9225 + z, r := codec1978.GenHelperEncoder(e) + _, _, _ = h, z, r + if x == nil { + r.EncodeNil() + } else { + yym1 := z.EncBinary() + _ = yym1 + if false { + } else if z.HasExtensions() && z.EncExt(x) { + } else { + yysep2 := !z.EncBinary() + yy2arr2 := z.EncBasicHandle().StructToArray + var yyq2 [2]bool + _, _, _ = yysep2, yyq2, yy2arr2 + const yyr2 bool = false + var yynn2 int + if yyr2 || yy2arr2 { + r.EncodeArrayStart(2) + } else { + yynn2 = 2 + for _, b := range yyq2 { + if b { + yynn2++ + } + } + r.EncodeMapStart(yynn2) + yynn2 = 0 + } + if yyr2 || yy2arr2 { + z.EncSendContainerState(codecSelfer_containerArrayElem9225) + yy4 := &x.Description + yy4.CodecEncodeSelf(e) + } else { + z.EncSendContainerState(codecSelfer_containerMapKey9225) + r.EncodeString(codecSelferC_UTF89225, string("description")) + z.EncSendContainerState(codecSelfer_containerMapValue9225) + yy6 := &x.Description + yy6.CodecEncodeSelf(e) + } + if yyr2 || yy2arr2 { + z.EncSendContainerState(codecSelfer_containerArrayElem9225) + yy9 := &x.URL + yy9.CodecEncodeSelf(e) + } else { + z.EncSendContainerState(codecSelfer_containerMapKey9225) + r.EncodeString(codecSelferC_UTF89225, string("url")) + z.EncSendContainerState(codecSelfer_containerMapValue9225) + yy11 := &x.URL + yy11.CodecEncodeSelf(e) + } + if yyr2 || yy2arr2 { + z.EncSendContainerState(codecSelfer_containerArrayEnd9225) + } else { + z.EncSendContainerState(codecSelfer_containerMapEnd9225) + } + } + } +} + +func (x *UserEntities) CodecDecodeSelf(d *codec1978.Decoder) { + var h codecSelfer9225 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + yym1 := z.DecBinary() + _ = yym1 + if false { + } else if z.HasExtensions() && z.DecExt(x) { + } else { + yyct2 := r.ContainerType() + if yyct2 == codecSelferValueTypeMap9225 { + yyl2 := r.ReadMapStart() + if yyl2 == 0 { + z.DecSendContainerState(codecSelfer_containerMapEnd9225) + } else { + x.codecDecodeSelfFromMap(yyl2, d) + } + } else if yyct2 == codecSelferValueTypeArray9225 { + yyl2 := r.ReadArrayStart() + if yyl2 == 0 { + z.DecSendContainerState(codecSelfer_containerArrayEnd9225) + } else { + x.codecDecodeSelfFromArray(yyl2, d) + } + } else { + panic(codecSelferOnlyMapOrArrayEncodeToStructErr9225) + } + } +} + +func (x *UserEntities) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { + var h codecSelfer9225 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + var yys3Slc = z.DecScratchBuffer() // default slice to decode into + _ = yys3Slc + var yyhl3 bool = l >= 0 + for yyj3 := 0; ; yyj3++ { + if yyhl3 { + if yyj3 >= l { + break + } + } else { + if r.CheckBreak() { + break + } + } + z.DecSendContainerState(codecSelfer_containerMapKey9225) + yys3Slc = r.DecodeBytes(yys3Slc, true, true) + yys3SlcHdr := codecSelferUnsafeString9225{uintptr(unsafe.Pointer(&yys3Slc[0])), len(yys3Slc)} + yys3 := *(*string)(unsafe.Pointer(&yys3SlcHdr)) + z.DecSendContainerState(codecSelfer_containerMapValue9225) + switch yys3 { + case "description": + if r.TryDecodeAsNil() { + x.Description = UserEntityDescription{} + } else { + yyv4 := &x.Description + yyv4.CodecDecodeSelf(d) + } + case "url": + if r.TryDecodeAsNil() { + x.URL = UserEntityURL{} + } else { + yyv5 := &x.URL + yyv5.CodecDecodeSelf(d) + } + default: + z.DecStructFieldNotFound(-1, yys3) + } // end switch yys3 + } // end for yyj3 + z.DecSendContainerState(codecSelfer_containerMapEnd9225) +} + +func (x *UserEntities) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { + var h codecSelfer9225 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + var yyj6 int + var yyb6 bool + var yyhl6 bool = l >= 0 + yyj6++ + if yyhl6 { + yyb6 = yyj6 > l + } else { + yyb6 = r.CheckBreak() + } + if yyb6 { + z.DecSendContainerState(codecSelfer_containerArrayEnd9225) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem9225) + if r.TryDecodeAsNil() { + x.Description = UserEntityDescription{} + } else { + yyv7 := &x.Description + yyv7.CodecDecodeSelf(d) + } + yyj6++ + if yyhl6 { + yyb6 = yyj6 > l + } else { + yyb6 = r.CheckBreak() + } + if yyb6 { + z.DecSendContainerState(codecSelfer_containerArrayEnd9225) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem9225) + if r.TryDecodeAsNil() { + x.URL = UserEntityURL{} + } else { + yyv8 := &x.URL + yyv8.CodecDecodeSelf(d) + } + for { + yyj6++ + if yyhl6 { + yyb6 = yyj6 > l + } else { + yyb6 = r.CheckBreak() + } + if yyb6 { + break + } + z.DecSendContainerState(codecSelfer_containerArrayElem9225) + z.DecStructFieldNotFound(yyj6-1, "") + } + z.DecSendContainerState(codecSelfer_containerArrayEnd9225) +} + +func (x *User) CodecEncodeSelf(e *codec1978.Encoder) { + var h codecSelfer9225 + z, r := codec1978.GenHelperEncoder(e) + _, _, _ = h, z, r + if x == nil { + r.EncodeNil() + } else { + yym1 := z.EncBinary() + _ = yym1 + if false { + } else if z.HasExtensions() && z.EncExt(x) { + } else { + yysep2 := !z.EncBinary() + yy2arr2 := z.EncBasicHandle().StructToArray + var yyq2 [39]bool + _, _, _ = yysep2, yyq2, yy2arr2 + const yyr2 bool = false + var yynn2 int + if yyr2 || yy2arr2 { + r.EncodeArrayStart(39) + } else { + yynn2 = 39 + for _, b := range yyq2 { + if b { + yynn2++ + } + } + r.EncodeMapStart(yynn2) + yynn2 = 0 + } + if yyr2 || yy2arr2 { + z.EncSendContainerState(codecSelfer_containerArrayElem9225) + yym4 := z.EncBinary() + _ = yym4 + if false { + } else { + r.EncodeBool(bool(x.ContributorsEnabled)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey9225) + r.EncodeString(codecSelferC_UTF89225, string("contributors_enabled")) + z.EncSendContainerState(codecSelfer_containerMapValue9225) + yym5 := z.EncBinary() + _ = yym5 + if false { + } else { + r.EncodeBool(bool(x.ContributorsEnabled)) + } + } + if yyr2 || yy2arr2 { + z.EncSendContainerState(codecSelfer_containerArrayElem9225) + yym7 := z.EncBinary() + _ = yym7 + if false { + } else { + r.EncodeString(codecSelferC_UTF89225, string(x.CreatedAt)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey9225) + r.EncodeString(codecSelferC_UTF89225, string("created_at")) + z.EncSendContainerState(codecSelfer_containerMapValue9225) + yym8 := z.EncBinary() + _ = yym8 + if false { + } else { + r.EncodeString(codecSelferC_UTF89225, string(x.CreatedAt)) + } + } + if yyr2 || yy2arr2 { + z.EncSendContainerState(codecSelfer_containerArrayElem9225) + yym10 := z.EncBinary() + _ = yym10 + if false { + } else { + r.EncodeBool(bool(x.DefaultProfile)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey9225) + r.EncodeString(codecSelferC_UTF89225, string("default_profile")) + z.EncSendContainerState(codecSelfer_containerMapValue9225) + yym11 := z.EncBinary() + _ = yym11 + if false { + } else { + r.EncodeBool(bool(x.DefaultProfile)) + } + } + if yyr2 || yy2arr2 { + z.EncSendContainerState(codecSelfer_containerArrayElem9225) + yym13 := z.EncBinary() + _ = yym13 + if false { + } else { + r.EncodeBool(bool(x.DefaultProfileImage)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey9225) + r.EncodeString(codecSelferC_UTF89225, string("default_profile_image")) + z.EncSendContainerState(codecSelfer_containerMapValue9225) + yym14 := z.EncBinary() + _ = yym14 + if false { + } else { + r.EncodeBool(bool(x.DefaultProfileImage)) + } + } + if yyr2 || yy2arr2 { + z.EncSendContainerState(codecSelfer_containerArrayElem9225) + yym16 := z.EncBinary() + _ = yym16 + if false { + } else { + r.EncodeString(codecSelferC_UTF89225, string(x.Description)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey9225) + r.EncodeString(codecSelferC_UTF89225, string("description")) + z.EncSendContainerState(codecSelfer_containerMapValue9225) + yym17 := z.EncBinary() + _ = yym17 + if false { + } else { + r.EncodeString(codecSelferC_UTF89225, string(x.Description)) + } + } + if yyr2 || yy2arr2 { + z.EncSendContainerState(codecSelfer_containerArrayElem9225) + yy19 := &x.Entities + yy19.CodecEncodeSelf(e) + } else { + z.EncSendContainerState(codecSelfer_containerMapKey9225) + r.EncodeString(codecSelferC_UTF89225, string("entities")) + z.EncSendContainerState(codecSelfer_containerMapValue9225) + yy21 := &x.Entities + yy21.CodecEncodeSelf(e) + } + if yyr2 || yy2arr2 { + z.EncSendContainerState(codecSelfer_containerArrayElem9225) + yym24 := z.EncBinary() + _ = yym24 + if false { + } else { + r.EncodeInt(int64(x.FavouritesCount)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey9225) + r.EncodeString(codecSelferC_UTF89225, string("favourites_count")) + z.EncSendContainerState(codecSelfer_containerMapValue9225) + yym25 := z.EncBinary() + _ = yym25 + if false { + } else { + r.EncodeInt(int64(x.FavouritesCount)) + } + } + if yyr2 || yy2arr2 { + z.EncSendContainerState(codecSelfer_containerArrayElem9225) + if x.FollowRequestSent == nil { + r.EncodeNil() + } else { + yy27 := *x.FollowRequestSent + yym28 := z.EncBinary() + _ = yym28 + if false { + } else { + r.EncodeString(codecSelferC_UTF89225, string(yy27)) + } + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey9225) + r.EncodeString(codecSelferC_UTF89225, string("follow_request_sent")) + z.EncSendContainerState(codecSelfer_containerMapValue9225) + if x.FollowRequestSent == nil { + r.EncodeNil() + } else { + yy29 := *x.FollowRequestSent + yym30 := z.EncBinary() + _ = yym30 + if false { + } else { + r.EncodeString(codecSelferC_UTF89225, string(yy29)) + } + } + } + if yyr2 || yy2arr2 { + z.EncSendContainerState(codecSelfer_containerArrayElem9225) + yym32 := z.EncBinary() + _ = yym32 + if false { + } else { + r.EncodeInt(int64(x.FollowersCount)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey9225) + r.EncodeString(codecSelferC_UTF89225, string("followers_count")) + z.EncSendContainerState(codecSelfer_containerMapValue9225) + yym33 := z.EncBinary() + _ = yym33 + if false { + } else { + r.EncodeInt(int64(x.FollowersCount)) + } + } + if yyr2 || yy2arr2 { + z.EncSendContainerState(codecSelfer_containerArrayElem9225) + if x.Following == nil { + r.EncodeNil() + } else { + yy35 := *x.Following + yym36 := z.EncBinary() + _ = yym36 + if false { + } else { + r.EncodeString(codecSelferC_UTF89225, string(yy35)) + } + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey9225) + r.EncodeString(codecSelferC_UTF89225, string("following")) + z.EncSendContainerState(codecSelfer_containerMapValue9225) + if x.Following == nil { + r.EncodeNil() + } else { + yy37 := *x.Following + yym38 := z.EncBinary() + _ = yym38 + if false { + } else { + r.EncodeString(codecSelferC_UTF89225, string(yy37)) + } + } + } + if yyr2 || yy2arr2 { + z.EncSendContainerState(codecSelfer_containerArrayElem9225) + yym40 := z.EncBinary() + _ = yym40 + if false { + } else { + r.EncodeInt(int64(x.FriendsCount)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey9225) + r.EncodeString(codecSelferC_UTF89225, string("friends_count")) + z.EncSendContainerState(codecSelfer_containerMapValue9225) + yym41 := z.EncBinary() + _ = yym41 + if false { + } else { + r.EncodeInt(int64(x.FriendsCount)) + } + } + if yyr2 || yy2arr2 { + z.EncSendContainerState(codecSelfer_containerArrayElem9225) + yym43 := z.EncBinary() + _ = yym43 + if false { + } else { + r.EncodeBool(bool(x.GeoEnabled)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey9225) + r.EncodeString(codecSelferC_UTF89225, string("geo_enabled")) + z.EncSendContainerState(codecSelfer_containerMapValue9225) + yym44 := z.EncBinary() + _ = yym44 + if false { + } else { + r.EncodeBool(bool(x.GeoEnabled)) + } + } + if yyr2 || yy2arr2 { + z.EncSendContainerState(codecSelfer_containerArrayElem9225) + yym46 := z.EncBinary() + _ = yym46 + if false { + } else { + r.EncodeInt(int64(x.ID)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey9225) + r.EncodeString(codecSelferC_UTF89225, string("id")) + z.EncSendContainerState(codecSelfer_containerMapValue9225) + yym47 := z.EncBinary() + _ = yym47 + if false { + } else { + r.EncodeInt(int64(x.ID)) + } + } + if yyr2 || yy2arr2 { + z.EncSendContainerState(codecSelfer_containerArrayElem9225) + yym49 := z.EncBinary() + _ = yym49 + if false { + } else { + r.EncodeString(codecSelferC_UTF89225, string(x.IDStr)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey9225) + r.EncodeString(codecSelferC_UTF89225, string("id_str")) + z.EncSendContainerState(codecSelfer_containerMapValue9225) + yym50 := z.EncBinary() + _ = yym50 + if false { + } else { + r.EncodeString(codecSelferC_UTF89225, string(x.IDStr)) + } + } + if yyr2 || yy2arr2 { + z.EncSendContainerState(codecSelfer_containerArrayElem9225) + yym52 := z.EncBinary() + _ = yym52 + if false { + } else { + r.EncodeBool(bool(x.IsTranslator)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey9225) + r.EncodeString(codecSelferC_UTF89225, string("is_translator")) + z.EncSendContainerState(codecSelfer_containerMapValue9225) + yym53 := z.EncBinary() + _ = yym53 + if false { + } else { + r.EncodeBool(bool(x.IsTranslator)) + } + } + if yyr2 || yy2arr2 { + z.EncSendContainerState(codecSelfer_containerArrayElem9225) + yym55 := z.EncBinary() + _ = yym55 + if false { + } else { + r.EncodeString(codecSelferC_UTF89225, string(x.Lang)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey9225) + r.EncodeString(codecSelferC_UTF89225, string("lang")) + z.EncSendContainerState(codecSelfer_containerMapValue9225) + yym56 := z.EncBinary() + _ = yym56 + if false { + } else { + r.EncodeString(codecSelferC_UTF89225, string(x.Lang)) + } + } + if yyr2 || yy2arr2 { + z.EncSendContainerState(codecSelfer_containerArrayElem9225) + yym58 := z.EncBinary() + _ = yym58 + if false { + } else { + r.EncodeInt(int64(x.ListedCount)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey9225) + r.EncodeString(codecSelferC_UTF89225, string("listed_count")) + z.EncSendContainerState(codecSelfer_containerMapValue9225) + yym59 := z.EncBinary() + _ = yym59 + if false { + } else { + r.EncodeInt(int64(x.ListedCount)) + } + } + if yyr2 || yy2arr2 { + z.EncSendContainerState(codecSelfer_containerArrayElem9225) + yym61 := z.EncBinary() + _ = yym61 + if false { + } else { + r.EncodeString(codecSelferC_UTF89225, string(x.Location)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey9225) + r.EncodeString(codecSelferC_UTF89225, string("location")) + z.EncSendContainerState(codecSelfer_containerMapValue9225) + yym62 := z.EncBinary() + _ = yym62 + if false { + } else { + r.EncodeString(codecSelferC_UTF89225, string(x.Location)) + } + } + if yyr2 || yy2arr2 { + z.EncSendContainerState(codecSelfer_containerArrayElem9225) + yym64 := z.EncBinary() + _ = yym64 + if false { + } else { + r.EncodeString(codecSelferC_UTF89225, string(x.Name)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey9225) + r.EncodeString(codecSelferC_UTF89225, string("name")) + z.EncSendContainerState(codecSelfer_containerMapValue9225) + yym65 := z.EncBinary() + _ = yym65 + if false { + } else { + r.EncodeString(codecSelferC_UTF89225, string(x.Name)) + } + } + if yyr2 || yy2arr2 { + z.EncSendContainerState(codecSelfer_containerArrayElem9225) + if x.Notifications == nil { + r.EncodeNil() + } else { + yy67 := *x.Notifications + yym68 := z.EncBinary() + _ = yym68 + if false { + } else { + r.EncodeString(codecSelferC_UTF89225, string(yy67)) + } + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey9225) + r.EncodeString(codecSelferC_UTF89225, string("notifications")) + z.EncSendContainerState(codecSelfer_containerMapValue9225) + if x.Notifications == nil { + r.EncodeNil() + } else { + yy69 := *x.Notifications + yym70 := z.EncBinary() + _ = yym70 + if false { + } else { + r.EncodeString(codecSelferC_UTF89225, string(yy69)) + } + } + } + if yyr2 || yy2arr2 { + z.EncSendContainerState(codecSelfer_containerArrayElem9225) + yym72 := z.EncBinary() + _ = yym72 + if false { + } else { + r.EncodeString(codecSelferC_UTF89225, string(x.ProfileBackgroundColor)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey9225) + r.EncodeString(codecSelferC_UTF89225, string("profile_background_color")) + z.EncSendContainerState(codecSelfer_containerMapValue9225) + yym73 := z.EncBinary() + _ = yym73 + if false { + } else { + r.EncodeString(codecSelferC_UTF89225, string(x.ProfileBackgroundColor)) + } + } + if yyr2 || yy2arr2 { + z.EncSendContainerState(codecSelfer_containerArrayElem9225) + yym75 := z.EncBinary() + _ = yym75 + if false { + } else { + r.EncodeString(codecSelferC_UTF89225, string(x.ProfileBackgroundImageURL)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey9225) + r.EncodeString(codecSelferC_UTF89225, string("profile_background_image_url")) + z.EncSendContainerState(codecSelfer_containerMapValue9225) + yym76 := z.EncBinary() + _ = yym76 + if false { + } else { + r.EncodeString(codecSelferC_UTF89225, string(x.ProfileBackgroundImageURL)) + } + } + if yyr2 || yy2arr2 { + z.EncSendContainerState(codecSelfer_containerArrayElem9225) + yym78 := z.EncBinary() + _ = yym78 + if false { + } else { + r.EncodeString(codecSelferC_UTF89225, string(x.ProfileBackgroundImageURLHTTPS)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey9225) + r.EncodeString(codecSelferC_UTF89225, string("profile_background_image_url_https")) + z.EncSendContainerState(codecSelfer_containerMapValue9225) + yym79 := z.EncBinary() + _ = yym79 + if false { + } else { + r.EncodeString(codecSelferC_UTF89225, string(x.ProfileBackgroundImageURLHTTPS)) + } + } + if yyr2 || yy2arr2 { + z.EncSendContainerState(codecSelfer_containerArrayElem9225) + yym81 := z.EncBinary() + _ = yym81 + if false { + } else { + r.EncodeBool(bool(x.ProfileBackgroundTile)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey9225) + r.EncodeString(codecSelferC_UTF89225, string("profile_background_tile")) + z.EncSendContainerState(codecSelfer_containerMapValue9225) + yym82 := z.EncBinary() + _ = yym82 + if false { + } else { + r.EncodeBool(bool(x.ProfileBackgroundTile)) + } + } + if yyr2 || yy2arr2 { + z.EncSendContainerState(codecSelfer_containerArrayElem9225) + yym84 := z.EncBinary() + _ = yym84 + if false { + } else { + r.EncodeString(codecSelferC_UTF89225, string(x.ProfileImageURL)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey9225) + r.EncodeString(codecSelferC_UTF89225, string("profile_image_url")) + z.EncSendContainerState(codecSelfer_containerMapValue9225) + yym85 := z.EncBinary() + _ = yym85 + if false { + } else { + r.EncodeString(codecSelferC_UTF89225, string(x.ProfileImageURL)) + } + } + if yyr2 || yy2arr2 { + z.EncSendContainerState(codecSelfer_containerArrayElem9225) + yym87 := z.EncBinary() + _ = yym87 + if false { + } else { + r.EncodeString(codecSelferC_UTF89225, string(x.ProfileImageURLHTTPS)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey9225) + r.EncodeString(codecSelferC_UTF89225, string("profile_image_url_https")) + z.EncSendContainerState(codecSelfer_containerMapValue9225) + yym88 := z.EncBinary() + _ = yym88 + if false { + } else { + r.EncodeString(codecSelferC_UTF89225, string(x.ProfileImageURLHTTPS)) + } + } + if yyr2 || yy2arr2 { + z.EncSendContainerState(codecSelfer_containerArrayElem9225) + yym90 := z.EncBinary() + _ = yym90 + if false { + } else { + r.EncodeString(codecSelferC_UTF89225, string(x.ProfileLinkColor)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey9225) + r.EncodeString(codecSelferC_UTF89225, string("profile_link_color")) + z.EncSendContainerState(codecSelfer_containerMapValue9225) + yym91 := z.EncBinary() + _ = yym91 + if false { + } else { + r.EncodeString(codecSelferC_UTF89225, string(x.ProfileLinkColor)) + } + } + if yyr2 || yy2arr2 { + z.EncSendContainerState(codecSelfer_containerArrayElem9225) + yym93 := z.EncBinary() + _ = yym93 + if false { + } else { + r.EncodeString(codecSelferC_UTF89225, string(x.ProfileSidebarBorderColor)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey9225) + r.EncodeString(codecSelferC_UTF89225, string("profile_sidebar_border_color")) + z.EncSendContainerState(codecSelfer_containerMapValue9225) + yym94 := z.EncBinary() + _ = yym94 + if false { + } else { + r.EncodeString(codecSelferC_UTF89225, string(x.ProfileSidebarBorderColor)) + } + } + if yyr2 || yy2arr2 { + z.EncSendContainerState(codecSelfer_containerArrayElem9225) + yym96 := z.EncBinary() + _ = yym96 + if false { + } else { + r.EncodeString(codecSelferC_UTF89225, string(x.ProfileSidebarFillColor)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey9225) + r.EncodeString(codecSelferC_UTF89225, string("profile_sidebar_fill_color")) + z.EncSendContainerState(codecSelfer_containerMapValue9225) + yym97 := z.EncBinary() + _ = yym97 + if false { + } else { + r.EncodeString(codecSelferC_UTF89225, string(x.ProfileSidebarFillColor)) + } + } + if yyr2 || yy2arr2 { + z.EncSendContainerState(codecSelfer_containerArrayElem9225) + yym99 := z.EncBinary() + _ = yym99 + if false { + } else { + r.EncodeString(codecSelferC_UTF89225, string(x.ProfileTextColor)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey9225) + r.EncodeString(codecSelferC_UTF89225, string("profile_text_color")) + z.EncSendContainerState(codecSelfer_containerMapValue9225) + yym100 := z.EncBinary() + _ = yym100 + if false { + } else { + r.EncodeString(codecSelferC_UTF89225, string(x.ProfileTextColor)) + } + } + if yyr2 || yy2arr2 { + z.EncSendContainerState(codecSelfer_containerArrayElem9225) + yym102 := z.EncBinary() + _ = yym102 + if false { + } else { + r.EncodeBool(bool(x.ProfileUseBackgroundImage)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey9225) + r.EncodeString(codecSelferC_UTF89225, string("profile_use_background_image")) + z.EncSendContainerState(codecSelfer_containerMapValue9225) + yym103 := z.EncBinary() + _ = yym103 + if false { + } else { + r.EncodeBool(bool(x.ProfileUseBackgroundImage)) + } + } + if yyr2 || yy2arr2 { + z.EncSendContainerState(codecSelfer_containerArrayElem9225) + yym105 := z.EncBinary() + _ = yym105 + if false { + } else { + r.EncodeBool(bool(x.Protected)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey9225) + r.EncodeString(codecSelferC_UTF89225, string("protected")) + z.EncSendContainerState(codecSelfer_containerMapValue9225) + yym106 := z.EncBinary() + _ = yym106 + if false { + } else { + r.EncodeBool(bool(x.Protected)) + } + } + if yyr2 || yy2arr2 { + z.EncSendContainerState(codecSelfer_containerArrayElem9225) + yym108 := z.EncBinary() + _ = yym108 + if false { + } else { + r.EncodeString(codecSelferC_UTF89225, string(x.ScreenName)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey9225) + r.EncodeString(codecSelferC_UTF89225, string("screen_name")) + z.EncSendContainerState(codecSelfer_containerMapValue9225) + yym109 := z.EncBinary() + _ = yym109 + if false { + } else { + r.EncodeString(codecSelferC_UTF89225, string(x.ScreenName)) + } + } + if yyr2 || yy2arr2 { + z.EncSendContainerState(codecSelfer_containerArrayElem9225) + yym111 := z.EncBinary() + _ = yym111 + if false { + } else { + r.EncodeBool(bool(x.ShowAllInlineMedia)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey9225) + r.EncodeString(codecSelferC_UTF89225, string("show_all_inline_media")) + z.EncSendContainerState(codecSelfer_containerMapValue9225) + yym112 := z.EncBinary() + _ = yym112 + if false { + } else { + r.EncodeBool(bool(x.ShowAllInlineMedia)) + } + } + if yyr2 || yy2arr2 { + z.EncSendContainerState(codecSelfer_containerArrayElem9225) + yym114 := z.EncBinary() + _ = yym114 + if false { + } else { + r.EncodeInt(int64(x.StatusesCount)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey9225) + r.EncodeString(codecSelferC_UTF89225, string("statuses_count")) + z.EncSendContainerState(codecSelfer_containerMapValue9225) + yym115 := z.EncBinary() + _ = yym115 + if false { + } else { + r.EncodeInt(int64(x.StatusesCount)) + } + } + if yyr2 || yy2arr2 { + z.EncSendContainerState(codecSelfer_containerArrayElem9225) + yym117 := z.EncBinary() + _ = yym117 + if false { + } else { + r.EncodeString(codecSelferC_UTF89225, string(x.TimeZone)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey9225) + r.EncodeString(codecSelferC_UTF89225, string("time_zone")) + z.EncSendContainerState(codecSelfer_containerMapValue9225) + yym118 := z.EncBinary() + _ = yym118 + if false { + } else { + r.EncodeString(codecSelferC_UTF89225, string(x.TimeZone)) + } + } + if yyr2 || yy2arr2 { + z.EncSendContainerState(codecSelfer_containerArrayElem9225) + if x.URL == nil { + r.EncodeNil() + } else { + yy120 := *x.URL + yym121 := z.EncBinary() + _ = yym121 + if false { + } else { + r.EncodeString(codecSelferC_UTF89225, string(yy120)) + } + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey9225) + r.EncodeString(codecSelferC_UTF89225, string("url")) + z.EncSendContainerState(codecSelfer_containerMapValue9225) + if x.URL == nil { + r.EncodeNil() + } else { + yy122 := *x.URL + yym123 := z.EncBinary() + _ = yym123 + if false { + } else { + r.EncodeString(codecSelferC_UTF89225, string(yy122)) + } + } + } + if yyr2 || yy2arr2 { + z.EncSendContainerState(codecSelfer_containerArrayElem9225) + yym125 := z.EncBinary() + _ = yym125 + if false { + } else { + r.EncodeInt(int64(x.UtcOffset)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey9225) + r.EncodeString(codecSelferC_UTF89225, string("utc_offset")) + z.EncSendContainerState(codecSelfer_containerMapValue9225) + yym126 := z.EncBinary() + _ = yym126 + if false { + } else { + r.EncodeInt(int64(x.UtcOffset)) + } + } + if yyr2 || yy2arr2 { + z.EncSendContainerState(codecSelfer_containerArrayElem9225) + yym128 := z.EncBinary() + _ = yym128 + if false { + } else { + r.EncodeBool(bool(x.Verified)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey9225) + r.EncodeString(codecSelferC_UTF89225, string("verified")) + z.EncSendContainerState(codecSelfer_containerMapValue9225) + yym129 := z.EncBinary() + _ = yym129 + if false { + } else { + r.EncodeBool(bool(x.Verified)) + } + } + if yyr2 || yy2arr2 { + z.EncSendContainerState(codecSelfer_containerArrayEnd9225) + } else { + z.EncSendContainerState(codecSelfer_containerMapEnd9225) + } + } + } +} + +func (x *User) CodecDecodeSelf(d *codec1978.Decoder) { + var h codecSelfer9225 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + yym1 := z.DecBinary() + _ = yym1 + if false { + } else if z.HasExtensions() && z.DecExt(x) { + } else { + yyct2 := r.ContainerType() + if yyct2 == codecSelferValueTypeMap9225 { + yyl2 := r.ReadMapStart() + if yyl2 == 0 { + z.DecSendContainerState(codecSelfer_containerMapEnd9225) + } else { + x.codecDecodeSelfFromMap(yyl2, d) + } + } else if yyct2 == codecSelferValueTypeArray9225 { + yyl2 := r.ReadArrayStart() + if yyl2 == 0 { + z.DecSendContainerState(codecSelfer_containerArrayEnd9225) + } else { + x.codecDecodeSelfFromArray(yyl2, d) + } + } else { + panic(codecSelferOnlyMapOrArrayEncodeToStructErr9225) + } + } +} + +func (x *User) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { + var h codecSelfer9225 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + var yys3Slc = z.DecScratchBuffer() // default slice to decode into + _ = yys3Slc + var yyhl3 bool = l >= 0 + for yyj3 := 0; ; yyj3++ { + if yyhl3 { + if yyj3 >= l { + break + } + } else { + if r.CheckBreak() { + break + } + } + z.DecSendContainerState(codecSelfer_containerMapKey9225) + yys3Slc = r.DecodeBytes(yys3Slc, true, true) + yys3SlcHdr := codecSelferUnsafeString9225{uintptr(unsafe.Pointer(&yys3Slc[0])), len(yys3Slc)} + yys3 := *(*string)(unsafe.Pointer(&yys3SlcHdr)) + z.DecSendContainerState(codecSelfer_containerMapValue9225) + switch yys3 { + case "contributors_enabled": + if r.TryDecodeAsNil() { + x.ContributorsEnabled = false + } else { + yyv4 := &x.ContributorsEnabled + yym5 := z.DecBinary() + _ = yym5 + if false { + } else { + *((*bool)(yyv4)) = r.DecodeBool() + } + } + case "created_at": + if r.TryDecodeAsNil() { + x.CreatedAt = "" + } else { + yyv6 := &x.CreatedAt + yym7 := z.DecBinary() + _ = yym7 + if false { + } else { + *((*string)(yyv6)) = r.DecodeString() + } + } + case "default_profile": + if r.TryDecodeAsNil() { + x.DefaultProfile = false + } else { + yyv8 := &x.DefaultProfile + yym9 := z.DecBinary() + _ = yym9 + if false { + } else { + *((*bool)(yyv8)) = r.DecodeBool() + } + } + case "default_profile_image": + if r.TryDecodeAsNil() { + x.DefaultProfileImage = false + } else { + yyv10 := &x.DefaultProfileImage + yym11 := z.DecBinary() + _ = yym11 + if false { + } else { + *((*bool)(yyv10)) = r.DecodeBool() + } + } + case "description": + if r.TryDecodeAsNil() { + x.Description = "" + } else { + yyv12 := &x.Description + yym13 := z.DecBinary() + _ = yym13 + if false { + } else { + *((*string)(yyv12)) = r.DecodeString() + } + } + case "entities": + if r.TryDecodeAsNil() { + x.Entities = UserEntities{} + } else { + yyv14 := &x.Entities + yyv14.CodecDecodeSelf(d) + } + case "favourites_count": + if r.TryDecodeAsNil() { + x.FavouritesCount = 0 + } else { + yyv15 := &x.FavouritesCount + yym16 := z.DecBinary() + _ = yym16 + if false { + } else { + *((*int)(yyv15)) = int(r.DecodeInt(codecSelferBitsize9225)) + } + } + case "follow_request_sent": + if r.TryDecodeAsNil() { + if x.FollowRequestSent != nil { + x.FollowRequestSent = nil + } + } else { + if x.FollowRequestSent == nil { + x.FollowRequestSent = new(string) + } + yym18 := z.DecBinary() + _ = yym18 + if false { + } else { + *((*string)(x.FollowRequestSent)) = r.DecodeString() + } + } + case "followers_count": + if r.TryDecodeAsNil() { + x.FollowersCount = 0 + } else { + yyv19 := &x.FollowersCount + yym20 := z.DecBinary() + _ = yym20 + if false { + } else { + *((*int)(yyv19)) = int(r.DecodeInt(codecSelferBitsize9225)) + } + } + case "following": + if r.TryDecodeAsNil() { + if x.Following != nil { + x.Following = nil + } + } else { + if x.Following == nil { + x.Following = new(string) + } + yym22 := z.DecBinary() + _ = yym22 + if false { + } else { + *((*string)(x.Following)) = r.DecodeString() + } + } + case "friends_count": + if r.TryDecodeAsNil() { + x.FriendsCount = 0 + } else { + yyv23 := &x.FriendsCount + yym24 := z.DecBinary() + _ = yym24 + if false { + } else { + *((*int)(yyv23)) = int(r.DecodeInt(codecSelferBitsize9225)) + } + } + case "geo_enabled": + if r.TryDecodeAsNil() { + x.GeoEnabled = false + } else { + yyv25 := &x.GeoEnabled + yym26 := z.DecBinary() + _ = yym26 + if false { + } else { + *((*bool)(yyv25)) = r.DecodeBool() + } + } + case "id": + if r.TryDecodeAsNil() { + x.ID = 0 + } else { + yyv27 := &x.ID + yym28 := z.DecBinary() + _ = yym28 + if false { + } else { + *((*int)(yyv27)) = int(r.DecodeInt(codecSelferBitsize9225)) + } + } + case "id_str": + if r.TryDecodeAsNil() { + x.IDStr = "" + } else { + yyv29 := &x.IDStr + yym30 := z.DecBinary() + _ = yym30 + if false { + } else { + *((*string)(yyv29)) = r.DecodeString() + } + } + case "is_translator": + if r.TryDecodeAsNil() { + x.IsTranslator = false + } else { + yyv31 := &x.IsTranslator + yym32 := z.DecBinary() + _ = yym32 + if false { + } else { + *((*bool)(yyv31)) = r.DecodeBool() + } + } + case "lang": + if r.TryDecodeAsNil() { + x.Lang = "" + } else { + yyv33 := &x.Lang + yym34 := z.DecBinary() + _ = yym34 + if false { + } else { + *((*string)(yyv33)) = r.DecodeString() + } + } + case "listed_count": + if r.TryDecodeAsNil() { + x.ListedCount = 0 + } else { + yyv35 := &x.ListedCount + yym36 := z.DecBinary() + _ = yym36 + if false { + } else { + *((*int)(yyv35)) = int(r.DecodeInt(codecSelferBitsize9225)) + } + } + case "location": + if r.TryDecodeAsNil() { + x.Location = "" + } else { + yyv37 := &x.Location + yym38 := z.DecBinary() + _ = yym38 + if false { + } else { + *((*string)(yyv37)) = r.DecodeString() + } + } + case "name": + if r.TryDecodeAsNil() { + x.Name = "" + } else { + yyv39 := &x.Name + yym40 := z.DecBinary() + _ = yym40 + if false { + } else { + *((*string)(yyv39)) = r.DecodeString() + } + } + case "notifications": + if r.TryDecodeAsNil() { + if x.Notifications != nil { + x.Notifications = nil + } + } else { + if x.Notifications == nil { + x.Notifications = new(string) + } + yym42 := z.DecBinary() + _ = yym42 + if false { + } else { + *((*string)(x.Notifications)) = r.DecodeString() + } + } + case "profile_background_color": + if r.TryDecodeAsNil() { + x.ProfileBackgroundColor = "" + } else { + yyv43 := &x.ProfileBackgroundColor + yym44 := z.DecBinary() + _ = yym44 + if false { + } else { + *((*string)(yyv43)) = r.DecodeString() + } + } + case "profile_background_image_url": + if r.TryDecodeAsNil() { + x.ProfileBackgroundImageURL = "" + } else { + yyv45 := &x.ProfileBackgroundImageURL + yym46 := z.DecBinary() + _ = yym46 + if false { + } else { + *((*string)(yyv45)) = r.DecodeString() + } + } + case "profile_background_image_url_https": + if r.TryDecodeAsNil() { + x.ProfileBackgroundImageURLHTTPS = "" + } else { + yyv47 := &x.ProfileBackgroundImageURLHTTPS + yym48 := z.DecBinary() + _ = yym48 + if false { + } else { + *((*string)(yyv47)) = r.DecodeString() + } + } + case "profile_background_tile": + if r.TryDecodeAsNil() { + x.ProfileBackgroundTile = false + } else { + yyv49 := &x.ProfileBackgroundTile + yym50 := z.DecBinary() + _ = yym50 + if false { + } else { + *((*bool)(yyv49)) = r.DecodeBool() + } + } + case "profile_image_url": + if r.TryDecodeAsNil() { + x.ProfileImageURL = "" + } else { + yyv51 := &x.ProfileImageURL + yym52 := z.DecBinary() + _ = yym52 + if false { + } else { + *((*string)(yyv51)) = r.DecodeString() + } + } + case "profile_image_url_https": + if r.TryDecodeAsNil() { + x.ProfileImageURLHTTPS = "" + } else { + yyv53 := &x.ProfileImageURLHTTPS + yym54 := z.DecBinary() + _ = yym54 + if false { + } else { + *((*string)(yyv53)) = r.DecodeString() + } + } + case "profile_link_color": + if r.TryDecodeAsNil() { + x.ProfileLinkColor = "" + } else { + yyv55 := &x.ProfileLinkColor + yym56 := z.DecBinary() + _ = yym56 + if false { + } else { + *((*string)(yyv55)) = r.DecodeString() + } + } + case "profile_sidebar_border_color": + if r.TryDecodeAsNil() { + x.ProfileSidebarBorderColor = "" + } else { + yyv57 := &x.ProfileSidebarBorderColor + yym58 := z.DecBinary() + _ = yym58 + if false { + } else { + *((*string)(yyv57)) = r.DecodeString() + } + } + case "profile_sidebar_fill_color": + if r.TryDecodeAsNil() { + x.ProfileSidebarFillColor = "" + } else { + yyv59 := &x.ProfileSidebarFillColor + yym60 := z.DecBinary() + _ = yym60 + if false { + } else { + *((*string)(yyv59)) = r.DecodeString() + } + } + case "profile_text_color": + if r.TryDecodeAsNil() { + x.ProfileTextColor = "" + } else { + yyv61 := &x.ProfileTextColor + yym62 := z.DecBinary() + _ = yym62 + if false { + } else { + *((*string)(yyv61)) = r.DecodeString() + } + } + case "profile_use_background_image": + if r.TryDecodeAsNil() { + x.ProfileUseBackgroundImage = false + } else { + yyv63 := &x.ProfileUseBackgroundImage + yym64 := z.DecBinary() + _ = yym64 + if false { + } else { + *((*bool)(yyv63)) = r.DecodeBool() + } + } + case "protected": + if r.TryDecodeAsNil() { + x.Protected = false + } else { + yyv65 := &x.Protected + yym66 := z.DecBinary() + _ = yym66 + if false { + } else { + *((*bool)(yyv65)) = r.DecodeBool() + } + } + case "screen_name": + if r.TryDecodeAsNil() { + x.ScreenName = "" + } else { + yyv67 := &x.ScreenName + yym68 := z.DecBinary() + _ = yym68 + if false { + } else { + *((*string)(yyv67)) = r.DecodeString() + } + } + case "show_all_inline_media": + if r.TryDecodeAsNil() { + x.ShowAllInlineMedia = false + } else { + yyv69 := &x.ShowAllInlineMedia + yym70 := z.DecBinary() + _ = yym70 + if false { + } else { + *((*bool)(yyv69)) = r.DecodeBool() + } + } + case "statuses_count": + if r.TryDecodeAsNil() { + x.StatusesCount = 0 + } else { + yyv71 := &x.StatusesCount + yym72 := z.DecBinary() + _ = yym72 + if false { + } else { + *((*int)(yyv71)) = int(r.DecodeInt(codecSelferBitsize9225)) + } + } + case "time_zone": + if r.TryDecodeAsNil() { + x.TimeZone = "" + } else { + yyv73 := &x.TimeZone + yym74 := z.DecBinary() + _ = yym74 + if false { + } else { + *((*string)(yyv73)) = r.DecodeString() + } + } + case "url": + if r.TryDecodeAsNil() { + if x.URL != nil { + x.URL = nil + } + } else { + if x.URL == nil { + x.URL = new(string) + } + yym76 := z.DecBinary() + _ = yym76 + if false { + } else { + *((*string)(x.URL)) = r.DecodeString() + } + } + case "utc_offset": + if r.TryDecodeAsNil() { + x.UtcOffset = 0 + } else { + yyv77 := &x.UtcOffset + yym78 := z.DecBinary() + _ = yym78 + if false { + } else { + *((*int)(yyv77)) = int(r.DecodeInt(codecSelferBitsize9225)) + } + } + case "verified": + if r.TryDecodeAsNil() { + x.Verified = false + } else { + yyv79 := &x.Verified + yym80 := z.DecBinary() + _ = yym80 + if false { + } else { + *((*bool)(yyv79)) = r.DecodeBool() + } + } + default: + z.DecStructFieldNotFound(-1, yys3) + } // end switch yys3 + } // end for yyj3 + z.DecSendContainerState(codecSelfer_containerMapEnd9225) +} + +func (x *User) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { + var h codecSelfer9225 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + var yyj81 int + var yyb81 bool + var yyhl81 bool = l >= 0 + yyj81++ + if yyhl81 { + yyb81 = yyj81 > l + } else { + yyb81 = r.CheckBreak() + } + if yyb81 { + z.DecSendContainerState(codecSelfer_containerArrayEnd9225) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem9225) + if r.TryDecodeAsNil() { + x.ContributorsEnabled = false + } else { + yyv82 := &x.ContributorsEnabled + yym83 := z.DecBinary() + _ = yym83 + if false { + } else { + *((*bool)(yyv82)) = r.DecodeBool() + } + } + yyj81++ + if yyhl81 { + yyb81 = yyj81 > l + } else { + yyb81 = r.CheckBreak() + } + if yyb81 { + z.DecSendContainerState(codecSelfer_containerArrayEnd9225) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem9225) + if r.TryDecodeAsNil() { + x.CreatedAt = "" + } else { + yyv84 := &x.CreatedAt + yym85 := z.DecBinary() + _ = yym85 + if false { + } else { + *((*string)(yyv84)) = r.DecodeString() + } + } + yyj81++ + if yyhl81 { + yyb81 = yyj81 > l + } else { + yyb81 = r.CheckBreak() + } + if yyb81 { + z.DecSendContainerState(codecSelfer_containerArrayEnd9225) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem9225) + if r.TryDecodeAsNil() { + x.DefaultProfile = false + } else { + yyv86 := &x.DefaultProfile + yym87 := z.DecBinary() + _ = yym87 + if false { + } else { + *((*bool)(yyv86)) = r.DecodeBool() + } + } + yyj81++ + if yyhl81 { + yyb81 = yyj81 > l + } else { + yyb81 = r.CheckBreak() + } + if yyb81 { + z.DecSendContainerState(codecSelfer_containerArrayEnd9225) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem9225) + if r.TryDecodeAsNil() { + x.DefaultProfileImage = false + } else { + yyv88 := &x.DefaultProfileImage + yym89 := z.DecBinary() + _ = yym89 + if false { + } else { + *((*bool)(yyv88)) = r.DecodeBool() + } + } + yyj81++ + if yyhl81 { + yyb81 = yyj81 > l + } else { + yyb81 = r.CheckBreak() + } + if yyb81 { + z.DecSendContainerState(codecSelfer_containerArrayEnd9225) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem9225) + if r.TryDecodeAsNil() { + x.Description = "" + } else { + yyv90 := &x.Description + yym91 := z.DecBinary() + _ = yym91 + if false { + } else { + *((*string)(yyv90)) = r.DecodeString() + } + } + yyj81++ + if yyhl81 { + yyb81 = yyj81 > l + } else { + yyb81 = r.CheckBreak() + } + if yyb81 { + z.DecSendContainerState(codecSelfer_containerArrayEnd9225) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem9225) + if r.TryDecodeAsNil() { + x.Entities = UserEntities{} + } else { + yyv92 := &x.Entities + yyv92.CodecDecodeSelf(d) + } + yyj81++ + if yyhl81 { + yyb81 = yyj81 > l + } else { + yyb81 = r.CheckBreak() + } + if yyb81 { + z.DecSendContainerState(codecSelfer_containerArrayEnd9225) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem9225) + if r.TryDecodeAsNil() { + x.FavouritesCount = 0 + } else { + yyv93 := &x.FavouritesCount + yym94 := z.DecBinary() + _ = yym94 + if false { + } else { + *((*int)(yyv93)) = int(r.DecodeInt(codecSelferBitsize9225)) + } + } + yyj81++ + if yyhl81 { + yyb81 = yyj81 > l + } else { + yyb81 = r.CheckBreak() + } + if yyb81 { + z.DecSendContainerState(codecSelfer_containerArrayEnd9225) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem9225) + if r.TryDecodeAsNil() { + if x.FollowRequestSent != nil { + x.FollowRequestSent = nil + } + } else { + if x.FollowRequestSent == nil { + x.FollowRequestSent = new(string) + } + yym96 := z.DecBinary() + _ = yym96 + if false { + } else { + *((*string)(x.FollowRequestSent)) = r.DecodeString() + } + } + yyj81++ + if yyhl81 { + yyb81 = yyj81 > l + } else { + yyb81 = r.CheckBreak() + } + if yyb81 { + z.DecSendContainerState(codecSelfer_containerArrayEnd9225) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem9225) + if r.TryDecodeAsNil() { + x.FollowersCount = 0 + } else { + yyv97 := &x.FollowersCount + yym98 := z.DecBinary() + _ = yym98 + if false { + } else { + *((*int)(yyv97)) = int(r.DecodeInt(codecSelferBitsize9225)) + } + } + yyj81++ + if yyhl81 { + yyb81 = yyj81 > l + } else { + yyb81 = r.CheckBreak() + } + if yyb81 { + z.DecSendContainerState(codecSelfer_containerArrayEnd9225) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem9225) + if r.TryDecodeAsNil() { + if x.Following != nil { + x.Following = nil + } + } else { + if x.Following == nil { + x.Following = new(string) + } + yym100 := z.DecBinary() + _ = yym100 + if false { + } else { + *((*string)(x.Following)) = r.DecodeString() + } + } + yyj81++ + if yyhl81 { + yyb81 = yyj81 > l + } else { + yyb81 = r.CheckBreak() + } + if yyb81 { + z.DecSendContainerState(codecSelfer_containerArrayEnd9225) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem9225) + if r.TryDecodeAsNil() { + x.FriendsCount = 0 + } else { + yyv101 := &x.FriendsCount + yym102 := z.DecBinary() + _ = yym102 + if false { + } else { + *((*int)(yyv101)) = int(r.DecodeInt(codecSelferBitsize9225)) + } + } + yyj81++ + if yyhl81 { + yyb81 = yyj81 > l + } else { + yyb81 = r.CheckBreak() + } + if yyb81 { + z.DecSendContainerState(codecSelfer_containerArrayEnd9225) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem9225) + if r.TryDecodeAsNil() { + x.GeoEnabled = false + } else { + yyv103 := &x.GeoEnabled + yym104 := z.DecBinary() + _ = yym104 + if false { + } else { + *((*bool)(yyv103)) = r.DecodeBool() + } + } + yyj81++ + if yyhl81 { + yyb81 = yyj81 > l + } else { + yyb81 = r.CheckBreak() + } + if yyb81 { + z.DecSendContainerState(codecSelfer_containerArrayEnd9225) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem9225) + if r.TryDecodeAsNil() { + x.ID = 0 + } else { + yyv105 := &x.ID + yym106 := z.DecBinary() + _ = yym106 + if false { + } else { + *((*int)(yyv105)) = int(r.DecodeInt(codecSelferBitsize9225)) + } + } + yyj81++ + if yyhl81 { + yyb81 = yyj81 > l + } else { + yyb81 = r.CheckBreak() + } + if yyb81 { + z.DecSendContainerState(codecSelfer_containerArrayEnd9225) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem9225) + if r.TryDecodeAsNil() { + x.IDStr = "" + } else { + yyv107 := &x.IDStr + yym108 := z.DecBinary() + _ = yym108 + if false { + } else { + *((*string)(yyv107)) = r.DecodeString() + } + } + yyj81++ + if yyhl81 { + yyb81 = yyj81 > l + } else { + yyb81 = r.CheckBreak() + } + if yyb81 { + z.DecSendContainerState(codecSelfer_containerArrayEnd9225) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem9225) + if r.TryDecodeAsNil() { + x.IsTranslator = false + } else { + yyv109 := &x.IsTranslator + yym110 := z.DecBinary() + _ = yym110 + if false { + } else { + *((*bool)(yyv109)) = r.DecodeBool() + } + } + yyj81++ + if yyhl81 { + yyb81 = yyj81 > l + } else { + yyb81 = r.CheckBreak() + } + if yyb81 { + z.DecSendContainerState(codecSelfer_containerArrayEnd9225) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem9225) + if r.TryDecodeAsNil() { + x.Lang = "" + } else { + yyv111 := &x.Lang + yym112 := z.DecBinary() + _ = yym112 + if false { + } else { + *((*string)(yyv111)) = r.DecodeString() + } + } + yyj81++ + if yyhl81 { + yyb81 = yyj81 > l + } else { + yyb81 = r.CheckBreak() + } + if yyb81 { + z.DecSendContainerState(codecSelfer_containerArrayEnd9225) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem9225) + if r.TryDecodeAsNil() { + x.ListedCount = 0 + } else { + yyv113 := &x.ListedCount + yym114 := z.DecBinary() + _ = yym114 + if false { + } else { + *((*int)(yyv113)) = int(r.DecodeInt(codecSelferBitsize9225)) + } + } + yyj81++ + if yyhl81 { + yyb81 = yyj81 > l + } else { + yyb81 = r.CheckBreak() + } + if yyb81 { + z.DecSendContainerState(codecSelfer_containerArrayEnd9225) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem9225) + if r.TryDecodeAsNil() { + x.Location = "" + } else { + yyv115 := &x.Location + yym116 := z.DecBinary() + _ = yym116 + if false { + } else { + *((*string)(yyv115)) = r.DecodeString() + } + } + yyj81++ + if yyhl81 { + yyb81 = yyj81 > l + } else { + yyb81 = r.CheckBreak() + } + if yyb81 { + z.DecSendContainerState(codecSelfer_containerArrayEnd9225) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem9225) + if r.TryDecodeAsNil() { + x.Name = "" + } else { + yyv117 := &x.Name + yym118 := z.DecBinary() + _ = yym118 + if false { + } else { + *((*string)(yyv117)) = r.DecodeString() + } + } + yyj81++ + if yyhl81 { + yyb81 = yyj81 > l + } else { + yyb81 = r.CheckBreak() + } + if yyb81 { + z.DecSendContainerState(codecSelfer_containerArrayEnd9225) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem9225) + if r.TryDecodeAsNil() { + if x.Notifications != nil { + x.Notifications = nil + } + } else { + if x.Notifications == nil { + x.Notifications = new(string) + } + yym120 := z.DecBinary() + _ = yym120 + if false { + } else { + *((*string)(x.Notifications)) = r.DecodeString() + } + } + yyj81++ + if yyhl81 { + yyb81 = yyj81 > l + } else { + yyb81 = r.CheckBreak() + } + if yyb81 { + z.DecSendContainerState(codecSelfer_containerArrayEnd9225) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem9225) + if r.TryDecodeAsNil() { + x.ProfileBackgroundColor = "" + } else { + yyv121 := &x.ProfileBackgroundColor + yym122 := z.DecBinary() + _ = yym122 + if false { + } else { + *((*string)(yyv121)) = r.DecodeString() + } + } + yyj81++ + if yyhl81 { + yyb81 = yyj81 > l + } else { + yyb81 = r.CheckBreak() + } + if yyb81 { + z.DecSendContainerState(codecSelfer_containerArrayEnd9225) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem9225) + if r.TryDecodeAsNil() { + x.ProfileBackgroundImageURL = "" + } else { + yyv123 := &x.ProfileBackgroundImageURL + yym124 := z.DecBinary() + _ = yym124 + if false { + } else { + *((*string)(yyv123)) = r.DecodeString() + } + } + yyj81++ + if yyhl81 { + yyb81 = yyj81 > l + } else { + yyb81 = r.CheckBreak() + } + if yyb81 { + z.DecSendContainerState(codecSelfer_containerArrayEnd9225) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem9225) + if r.TryDecodeAsNil() { + x.ProfileBackgroundImageURLHTTPS = "" + } else { + yyv125 := &x.ProfileBackgroundImageURLHTTPS + yym126 := z.DecBinary() + _ = yym126 + if false { + } else { + *((*string)(yyv125)) = r.DecodeString() + } + } + yyj81++ + if yyhl81 { + yyb81 = yyj81 > l + } else { + yyb81 = r.CheckBreak() + } + if yyb81 { + z.DecSendContainerState(codecSelfer_containerArrayEnd9225) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem9225) + if r.TryDecodeAsNil() { + x.ProfileBackgroundTile = false + } else { + yyv127 := &x.ProfileBackgroundTile + yym128 := z.DecBinary() + _ = yym128 + if false { + } else { + *((*bool)(yyv127)) = r.DecodeBool() + } + } + yyj81++ + if yyhl81 { + yyb81 = yyj81 > l + } else { + yyb81 = r.CheckBreak() + } + if yyb81 { + z.DecSendContainerState(codecSelfer_containerArrayEnd9225) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem9225) + if r.TryDecodeAsNil() { + x.ProfileImageURL = "" + } else { + yyv129 := &x.ProfileImageURL + yym130 := z.DecBinary() + _ = yym130 + if false { + } else { + *((*string)(yyv129)) = r.DecodeString() + } + } + yyj81++ + if yyhl81 { + yyb81 = yyj81 > l + } else { + yyb81 = r.CheckBreak() + } + if yyb81 { + z.DecSendContainerState(codecSelfer_containerArrayEnd9225) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem9225) + if r.TryDecodeAsNil() { + x.ProfileImageURLHTTPS = "" + } else { + yyv131 := &x.ProfileImageURLHTTPS + yym132 := z.DecBinary() + _ = yym132 + if false { + } else { + *((*string)(yyv131)) = r.DecodeString() + } + } + yyj81++ + if yyhl81 { + yyb81 = yyj81 > l + } else { + yyb81 = r.CheckBreak() + } + if yyb81 { + z.DecSendContainerState(codecSelfer_containerArrayEnd9225) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem9225) + if r.TryDecodeAsNil() { + x.ProfileLinkColor = "" + } else { + yyv133 := &x.ProfileLinkColor + yym134 := z.DecBinary() + _ = yym134 + if false { + } else { + *((*string)(yyv133)) = r.DecodeString() + } + } + yyj81++ + if yyhl81 { + yyb81 = yyj81 > l + } else { + yyb81 = r.CheckBreak() + } + if yyb81 { + z.DecSendContainerState(codecSelfer_containerArrayEnd9225) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem9225) + if r.TryDecodeAsNil() { + x.ProfileSidebarBorderColor = "" + } else { + yyv135 := &x.ProfileSidebarBorderColor + yym136 := z.DecBinary() + _ = yym136 + if false { + } else { + *((*string)(yyv135)) = r.DecodeString() + } + } + yyj81++ + if yyhl81 { + yyb81 = yyj81 > l + } else { + yyb81 = r.CheckBreak() + } + if yyb81 { + z.DecSendContainerState(codecSelfer_containerArrayEnd9225) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem9225) + if r.TryDecodeAsNil() { + x.ProfileSidebarFillColor = "" + } else { + yyv137 := &x.ProfileSidebarFillColor + yym138 := z.DecBinary() + _ = yym138 + if false { + } else { + *((*string)(yyv137)) = r.DecodeString() + } + } + yyj81++ + if yyhl81 { + yyb81 = yyj81 > l + } else { + yyb81 = r.CheckBreak() + } + if yyb81 { + z.DecSendContainerState(codecSelfer_containerArrayEnd9225) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem9225) + if r.TryDecodeAsNil() { + x.ProfileTextColor = "" + } else { + yyv139 := &x.ProfileTextColor + yym140 := z.DecBinary() + _ = yym140 + if false { + } else { + *((*string)(yyv139)) = r.DecodeString() + } + } + yyj81++ + if yyhl81 { + yyb81 = yyj81 > l + } else { + yyb81 = r.CheckBreak() + } + if yyb81 { + z.DecSendContainerState(codecSelfer_containerArrayEnd9225) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem9225) + if r.TryDecodeAsNil() { + x.ProfileUseBackgroundImage = false + } else { + yyv141 := &x.ProfileUseBackgroundImage + yym142 := z.DecBinary() + _ = yym142 + if false { + } else { + *((*bool)(yyv141)) = r.DecodeBool() + } + } + yyj81++ + if yyhl81 { + yyb81 = yyj81 > l + } else { + yyb81 = r.CheckBreak() + } + if yyb81 { + z.DecSendContainerState(codecSelfer_containerArrayEnd9225) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem9225) + if r.TryDecodeAsNil() { + x.Protected = false + } else { + yyv143 := &x.Protected + yym144 := z.DecBinary() + _ = yym144 + if false { + } else { + *((*bool)(yyv143)) = r.DecodeBool() + } + } + yyj81++ + if yyhl81 { + yyb81 = yyj81 > l + } else { + yyb81 = r.CheckBreak() + } + if yyb81 { + z.DecSendContainerState(codecSelfer_containerArrayEnd9225) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem9225) + if r.TryDecodeAsNil() { + x.ScreenName = "" + } else { + yyv145 := &x.ScreenName + yym146 := z.DecBinary() + _ = yym146 + if false { + } else { + *((*string)(yyv145)) = r.DecodeString() + } + } + yyj81++ + if yyhl81 { + yyb81 = yyj81 > l + } else { + yyb81 = r.CheckBreak() + } + if yyb81 { + z.DecSendContainerState(codecSelfer_containerArrayEnd9225) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem9225) + if r.TryDecodeAsNil() { + x.ShowAllInlineMedia = false + } else { + yyv147 := &x.ShowAllInlineMedia + yym148 := z.DecBinary() + _ = yym148 + if false { + } else { + *((*bool)(yyv147)) = r.DecodeBool() + } + } + yyj81++ + if yyhl81 { + yyb81 = yyj81 > l + } else { + yyb81 = r.CheckBreak() + } + if yyb81 { + z.DecSendContainerState(codecSelfer_containerArrayEnd9225) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem9225) + if r.TryDecodeAsNil() { + x.StatusesCount = 0 + } else { + yyv149 := &x.StatusesCount + yym150 := z.DecBinary() + _ = yym150 + if false { + } else { + *((*int)(yyv149)) = int(r.DecodeInt(codecSelferBitsize9225)) + } + } + yyj81++ + if yyhl81 { + yyb81 = yyj81 > l + } else { + yyb81 = r.CheckBreak() + } + if yyb81 { + z.DecSendContainerState(codecSelfer_containerArrayEnd9225) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem9225) + if r.TryDecodeAsNil() { + x.TimeZone = "" + } else { + yyv151 := &x.TimeZone + yym152 := z.DecBinary() + _ = yym152 + if false { + } else { + *((*string)(yyv151)) = r.DecodeString() + } + } + yyj81++ + if yyhl81 { + yyb81 = yyj81 > l + } else { + yyb81 = r.CheckBreak() + } + if yyb81 { + z.DecSendContainerState(codecSelfer_containerArrayEnd9225) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem9225) + if r.TryDecodeAsNil() { + if x.URL != nil { + x.URL = nil + } + } else { + if x.URL == nil { + x.URL = new(string) + } + yym154 := z.DecBinary() + _ = yym154 + if false { + } else { + *((*string)(x.URL)) = r.DecodeString() + } + } + yyj81++ + if yyhl81 { + yyb81 = yyj81 > l + } else { + yyb81 = r.CheckBreak() + } + if yyb81 { + z.DecSendContainerState(codecSelfer_containerArrayEnd9225) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem9225) + if r.TryDecodeAsNil() { + x.UtcOffset = 0 + } else { + yyv155 := &x.UtcOffset + yym156 := z.DecBinary() + _ = yym156 + if false { + } else { + *((*int)(yyv155)) = int(r.DecodeInt(codecSelferBitsize9225)) + } + } + yyj81++ + if yyhl81 { + yyb81 = yyj81 > l + } else { + yyb81 = r.CheckBreak() + } + if yyb81 { + z.DecSendContainerState(codecSelfer_containerArrayEnd9225) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem9225) + if r.TryDecodeAsNil() { + x.Verified = false + } else { + yyv157 := &x.Verified + yym158 := z.DecBinary() + _ = yym158 + if false { + } else { + *((*bool)(yyv157)) = r.DecodeBool() + } + } + for { + yyj81++ + if yyhl81 { + yyb81 = yyj81 > l + } else { + yyb81 = r.CheckBreak() + } + if yyb81 { + break + } + z.DecSendContainerState(codecSelfer_containerArrayElem9225) + z.DecStructFieldNotFound(yyj81-1, "") + } + z.DecSendContainerState(codecSelfer_containerArrayEnd9225) +} + +func (x *StatusMetadata) CodecEncodeSelf(e *codec1978.Encoder) { + var h codecSelfer9225 + z, r := codec1978.GenHelperEncoder(e) + _, _, _ = h, z, r + if x == nil { + r.EncodeNil() + } else { + yym1 := z.EncBinary() + _ = yym1 + if false { + } else if z.HasExtensions() && z.EncExt(x) { + } else { + yysep2 := !z.EncBinary() + yy2arr2 := z.EncBasicHandle().StructToArray + var yyq2 [2]bool + _, _, _ = yysep2, yyq2, yy2arr2 + const yyr2 bool = false + var yynn2 int + if yyr2 || yy2arr2 { + r.EncodeArrayStart(2) + } else { + yynn2 = 2 + for _, b := range yyq2 { + if b { + yynn2++ + } + } + r.EncodeMapStart(yynn2) + yynn2 = 0 + } + if yyr2 || yy2arr2 { + z.EncSendContainerState(codecSelfer_containerArrayElem9225) + yym4 := z.EncBinary() + _ = yym4 + if false { + } else { + r.EncodeString(codecSelferC_UTF89225, string(x.IsoLanguageCode)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey9225) + r.EncodeString(codecSelferC_UTF89225, string("iso_language_code")) + z.EncSendContainerState(codecSelfer_containerMapValue9225) + yym5 := z.EncBinary() + _ = yym5 + if false { + } else { + r.EncodeString(codecSelferC_UTF89225, string(x.IsoLanguageCode)) + } + } + if yyr2 || yy2arr2 { + z.EncSendContainerState(codecSelfer_containerArrayElem9225) + yym7 := z.EncBinary() + _ = yym7 + if false { + } else { + r.EncodeString(codecSelferC_UTF89225, string(x.ResultType)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey9225) + r.EncodeString(codecSelferC_UTF89225, string("result_type")) + z.EncSendContainerState(codecSelfer_containerMapValue9225) + yym8 := z.EncBinary() + _ = yym8 + if false { + } else { + r.EncodeString(codecSelferC_UTF89225, string(x.ResultType)) + } + } + if yyr2 || yy2arr2 { + z.EncSendContainerState(codecSelfer_containerArrayEnd9225) + } else { + z.EncSendContainerState(codecSelfer_containerMapEnd9225) + } + } + } +} + +func (x *StatusMetadata) CodecDecodeSelf(d *codec1978.Decoder) { + var h codecSelfer9225 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + yym1 := z.DecBinary() + _ = yym1 + if false { + } else if z.HasExtensions() && z.DecExt(x) { + } else { + yyct2 := r.ContainerType() + if yyct2 == codecSelferValueTypeMap9225 { + yyl2 := r.ReadMapStart() + if yyl2 == 0 { + z.DecSendContainerState(codecSelfer_containerMapEnd9225) + } else { + x.codecDecodeSelfFromMap(yyl2, d) + } + } else if yyct2 == codecSelferValueTypeArray9225 { + yyl2 := r.ReadArrayStart() + if yyl2 == 0 { + z.DecSendContainerState(codecSelfer_containerArrayEnd9225) + } else { + x.codecDecodeSelfFromArray(yyl2, d) + } + } else { + panic(codecSelferOnlyMapOrArrayEncodeToStructErr9225) + } + } +} + +func (x *StatusMetadata) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { + var h codecSelfer9225 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + var yys3Slc = z.DecScratchBuffer() // default slice to decode into + _ = yys3Slc + var yyhl3 bool = l >= 0 + for yyj3 := 0; ; yyj3++ { + if yyhl3 { + if yyj3 >= l { + break + } + } else { + if r.CheckBreak() { + break + } + } + z.DecSendContainerState(codecSelfer_containerMapKey9225) + yys3Slc = r.DecodeBytes(yys3Slc, true, true) + yys3SlcHdr := codecSelferUnsafeString9225{uintptr(unsafe.Pointer(&yys3Slc[0])), len(yys3Slc)} + yys3 := *(*string)(unsafe.Pointer(&yys3SlcHdr)) + z.DecSendContainerState(codecSelfer_containerMapValue9225) + switch yys3 { + case "iso_language_code": + if r.TryDecodeAsNil() { + x.IsoLanguageCode = "" + } else { + yyv4 := &x.IsoLanguageCode + yym5 := z.DecBinary() + _ = yym5 + if false { + } else { + *((*string)(yyv4)) = r.DecodeString() + } + } + case "result_type": + if r.TryDecodeAsNil() { + x.ResultType = "" + } else { + yyv6 := &x.ResultType + yym7 := z.DecBinary() + _ = yym7 + if false { + } else { + *((*string)(yyv6)) = r.DecodeString() + } + } + default: + z.DecStructFieldNotFound(-1, yys3) + } // end switch yys3 + } // end for yyj3 + z.DecSendContainerState(codecSelfer_containerMapEnd9225) +} + +func (x *StatusMetadata) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { + var h codecSelfer9225 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + var yyj8 int + var yyb8 bool + var yyhl8 bool = l >= 0 + yyj8++ + if yyhl8 { + yyb8 = yyj8 > l + } else { + yyb8 = r.CheckBreak() + } + if yyb8 { + z.DecSendContainerState(codecSelfer_containerArrayEnd9225) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem9225) + if r.TryDecodeAsNil() { + x.IsoLanguageCode = "" + } else { + yyv9 := &x.IsoLanguageCode + yym10 := z.DecBinary() + _ = yym10 + if false { + } else { + *((*string)(yyv9)) = r.DecodeString() + } + } + yyj8++ + if yyhl8 { + yyb8 = yyj8 > l + } else { + yyb8 = r.CheckBreak() + } + if yyb8 { + z.DecSendContainerState(codecSelfer_containerArrayEnd9225) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem9225) + if r.TryDecodeAsNil() { + x.ResultType = "" + } else { + yyv11 := &x.ResultType + yym12 := z.DecBinary() + _ = yym12 + if false { + } else { + *((*string)(yyv11)) = r.DecodeString() + } + } + for { + yyj8++ + if yyhl8 { + yyb8 = yyj8 > l + } else { + yyb8 = r.CheckBreak() + } + if yyb8 { + break + } + z.DecSendContainerState(codecSelfer_containerArrayElem9225) + z.DecStructFieldNotFound(yyj8-1, "") + } + z.DecSendContainerState(codecSelfer_containerArrayEnd9225) +} + +func (x *Status) CodecEncodeSelf(e *codec1978.Encoder) { + var h codecSelfer9225 + z, r := codec1978.GenHelperEncoder(e) + _, _, _ = h, z, r + if x == nil { + r.EncodeNil() + } else { + yym1 := z.EncBinary() + _ = yym1 + if false { + } else if z.HasExtensions() && z.EncExt(x) { + } else { + yysep2 := !z.EncBinary() + yy2arr2 := z.EncBasicHandle().StructToArray + var yyq2 [21]bool + _, _, _ = yysep2, yyq2, yy2arr2 + const yyr2 bool = false + var yynn2 int + if yyr2 || yy2arr2 { + r.EncodeArrayStart(21) + } else { + yynn2 = 21 + for _, b := range yyq2 { + if b { + yynn2++ + } + } + r.EncodeMapStart(yynn2) + yynn2 = 0 + } + if yyr2 || yy2arr2 { + z.EncSendContainerState(codecSelfer_containerArrayElem9225) + if x.Contributors == nil { + r.EncodeNil() + } else { + yy4 := *x.Contributors + yym5 := z.EncBinary() + _ = yym5 + if false { + } else { + r.EncodeString(codecSelferC_UTF89225, string(yy4)) + } + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey9225) + r.EncodeString(codecSelferC_UTF89225, string("contributors")) + z.EncSendContainerState(codecSelfer_containerMapValue9225) + if x.Contributors == nil { + r.EncodeNil() + } else { + yy6 := *x.Contributors + yym7 := z.EncBinary() + _ = yym7 + if false { + } else { + r.EncodeString(codecSelferC_UTF89225, string(yy6)) + } + } + } + if yyr2 || yy2arr2 { + z.EncSendContainerState(codecSelfer_containerArrayElem9225) + if x.Coordinates == nil { + r.EncodeNil() + } else { + yy9 := *x.Coordinates + yym10 := z.EncBinary() + _ = yym10 + if false { + } else { + r.EncodeString(codecSelferC_UTF89225, string(yy9)) + } + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey9225) + r.EncodeString(codecSelferC_UTF89225, string("coordinates")) + z.EncSendContainerState(codecSelfer_containerMapValue9225) + if x.Coordinates == nil { + r.EncodeNil() + } else { + yy11 := *x.Coordinates + yym12 := z.EncBinary() + _ = yym12 + if false { + } else { + r.EncodeString(codecSelferC_UTF89225, string(yy11)) + } + } + } + if yyr2 || yy2arr2 { + z.EncSendContainerState(codecSelfer_containerArrayElem9225) + yym14 := z.EncBinary() + _ = yym14 + if false { + } else { + r.EncodeString(codecSelferC_UTF89225, string(x.CreatedAt)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey9225) + r.EncodeString(codecSelferC_UTF89225, string("created_at")) + z.EncSendContainerState(codecSelfer_containerMapValue9225) + yym15 := z.EncBinary() + _ = yym15 + if false { + } else { + r.EncodeString(codecSelferC_UTF89225, string(x.CreatedAt)) + } + } + if yyr2 || yy2arr2 { + z.EncSendContainerState(codecSelfer_containerArrayElem9225) + yy17 := &x.Entities + yy17.CodecEncodeSelf(e) + } else { + z.EncSendContainerState(codecSelfer_containerMapKey9225) + r.EncodeString(codecSelferC_UTF89225, string("entities")) + z.EncSendContainerState(codecSelfer_containerMapValue9225) + yy19 := &x.Entities + yy19.CodecEncodeSelf(e) + } + if yyr2 || yy2arr2 { + z.EncSendContainerState(codecSelfer_containerArrayElem9225) + yym22 := z.EncBinary() + _ = yym22 + if false { + } else { + r.EncodeBool(bool(x.Favorited)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey9225) + r.EncodeString(codecSelferC_UTF89225, string("favorited")) + z.EncSendContainerState(codecSelfer_containerMapValue9225) + yym23 := z.EncBinary() + _ = yym23 + if false { + } else { + r.EncodeBool(bool(x.Favorited)) + } + } + if yyr2 || yy2arr2 { + z.EncSendContainerState(codecSelfer_containerArrayElem9225) + if x.Geo == nil { + r.EncodeNil() + } else { + yy25 := *x.Geo + yym26 := z.EncBinary() + _ = yym26 + if false { + } else { + r.EncodeString(codecSelferC_UTF89225, string(yy25)) + } + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey9225) + r.EncodeString(codecSelferC_UTF89225, string("geo")) + z.EncSendContainerState(codecSelfer_containerMapValue9225) + if x.Geo == nil { + r.EncodeNil() + } else { + yy27 := *x.Geo + yym28 := z.EncBinary() + _ = yym28 + if false { + } else { + r.EncodeString(codecSelferC_UTF89225, string(yy27)) + } + } + } + if yyr2 || yy2arr2 { + z.EncSendContainerState(codecSelfer_containerArrayElem9225) + yym30 := z.EncBinary() + _ = yym30 + if false { + } else { + r.EncodeInt(int64(x.ID)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey9225) + r.EncodeString(codecSelferC_UTF89225, string("id")) + z.EncSendContainerState(codecSelfer_containerMapValue9225) + yym31 := z.EncBinary() + _ = yym31 + if false { + } else { + r.EncodeInt(int64(x.ID)) + } + } + if yyr2 || yy2arr2 { + z.EncSendContainerState(codecSelfer_containerArrayElem9225) + yym33 := z.EncBinary() + _ = yym33 + if false { + } else { + r.EncodeString(codecSelferC_UTF89225, string(x.IDStr)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey9225) + r.EncodeString(codecSelferC_UTF89225, string("id_str")) + z.EncSendContainerState(codecSelfer_containerMapValue9225) + yym34 := z.EncBinary() + _ = yym34 + if false { + } else { + r.EncodeString(codecSelferC_UTF89225, string(x.IDStr)) + } + } + if yyr2 || yy2arr2 { + z.EncSendContainerState(codecSelfer_containerArrayElem9225) + if x.InReplyToScreenName == nil { + r.EncodeNil() + } else { + yy36 := *x.InReplyToScreenName + yym37 := z.EncBinary() + _ = yym37 + if false { + } else { + r.EncodeString(codecSelferC_UTF89225, string(yy36)) + } + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey9225) + r.EncodeString(codecSelferC_UTF89225, string("in_reply_to_screen_name")) + z.EncSendContainerState(codecSelfer_containerMapValue9225) + if x.InReplyToScreenName == nil { + r.EncodeNil() + } else { + yy38 := *x.InReplyToScreenName + yym39 := z.EncBinary() + _ = yym39 + if false { + } else { + r.EncodeString(codecSelferC_UTF89225, string(yy38)) + } + } + } + if yyr2 || yy2arr2 { + z.EncSendContainerState(codecSelfer_containerArrayElem9225) + if x.InReplyToStatusID == nil { + r.EncodeNil() + } else { + yy41 := *x.InReplyToStatusID + yym42 := z.EncBinary() + _ = yym42 + if false { + } else { + r.EncodeString(codecSelferC_UTF89225, string(yy41)) + } + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey9225) + r.EncodeString(codecSelferC_UTF89225, string("in_reply_to_status_id")) + z.EncSendContainerState(codecSelfer_containerMapValue9225) + if x.InReplyToStatusID == nil { + r.EncodeNil() + } else { + yy43 := *x.InReplyToStatusID + yym44 := z.EncBinary() + _ = yym44 + if false { + } else { + r.EncodeString(codecSelferC_UTF89225, string(yy43)) + } + } + } + if yyr2 || yy2arr2 { + z.EncSendContainerState(codecSelfer_containerArrayElem9225) + if x.InReplyToStatusIDStr == nil { + r.EncodeNil() + } else { + yy46 := *x.InReplyToStatusIDStr + yym47 := z.EncBinary() + _ = yym47 + if false { + } else { + r.EncodeString(codecSelferC_UTF89225, string(yy46)) + } + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey9225) + r.EncodeString(codecSelferC_UTF89225, string("in_reply_to_status_id_str")) + z.EncSendContainerState(codecSelfer_containerMapValue9225) + if x.InReplyToStatusIDStr == nil { + r.EncodeNil() + } else { + yy48 := *x.InReplyToStatusIDStr + yym49 := z.EncBinary() + _ = yym49 + if false { + } else { + r.EncodeString(codecSelferC_UTF89225, string(yy48)) + } + } + } + if yyr2 || yy2arr2 { + z.EncSendContainerState(codecSelfer_containerArrayElem9225) + if x.InReplyToUserID == nil { + r.EncodeNil() + } else { + yy51 := *x.InReplyToUserID + yym52 := z.EncBinary() + _ = yym52 + if false { + } else { + r.EncodeString(codecSelferC_UTF89225, string(yy51)) + } + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey9225) + r.EncodeString(codecSelferC_UTF89225, string("in_reply_to_user_id")) + z.EncSendContainerState(codecSelfer_containerMapValue9225) + if x.InReplyToUserID == nil { + r.EncodeNil() + } else { + yy53 := *x.InReplyToUserID + yym54 := z.EncBinary() + _ = yym54 + if false { + } else { + r.EncodeString(codecSelferC_UTF89225, string(yy53)) + } + } + } + if yyr2 || yy2arr2 { + z.EncSendContainerState(codecSelfer_containerArrayElem9225) + if x.InReplyToUserIDStr == nil { + r.EncodeNil() + } else { + yy56 := *x.InReplyToUserIDStr + yym57 := z.EncBinary() + _ = yym57 + if false { + } else { + r.EncodeString(codecSelferC_UTF89225, string(yy56)) + } + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey9225) + r.EncodeString(codecSelferC_UTF89225, string("in_reply_to_user_id_str")) + z.EncSendContainerState(codecSelfer_containerMapValue9225) + if x.InReplyToUserIDStr == nil { + r.EncodeNil() + } else { + yy58 := *x.InReplyToUserIDStr + yym59 := z.EncBinary() + _ = yym59 + if false { + } else { + r.EncodeString(codecSelferC_UTF89225, string(yy58)) + } + } + } + if yyr2 || yy2arr2 { + z.EncSendContainerState(codecSelfer_containerArrayElem9225) + yy61 := &x.Metadata + yy61.CodecEncodeSelf(e) + } else { + z.EncSendContainerState(codecSelfer_containerMapKey9225) + r.EncodeString(codecSelferC_UTF89225, string("metadata")) + z.EncSendContainerState(codecSelfer_containerMapValue9225) + yy63 := &x.Metadata + yy63.CodecEncodeSelf(e) + } + if yyr2 || yy2arr2 { + z.EncSendContainerState(codecSelfer_containerArrayElem9225) + if x.Place == nil { + r.EncodeNil() + } else { + yy66 := *x.Place + yym67 := z.EncBinary() + _ = yym67 + if false { + } else { + r.EncodeString(codecSelferC_UTF89225, string(yy66)) + } + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey9225) + r.EncodeString(codecSelferC_UTF89225, string("place")) + z.EncSendContainerState(codecSelfer_containerMapValue9225) + if x.Place == nil { + r.EncodeNil() + } else { + yy68 := *x.Place + yym69 := z.EncBinary() + _ = yym69 + if false { + } else { + r.EncodeString(codecSelferC_UTF89225, string(yy68)) + } + } + } + if yyr2 || yy2arr2 { + z.EncSendContainerState(codecSelfer_containerArrayElem9225) + yym71 := z.EncBinary() + _ = yym71 + if false { + } else { + r.EncodeInt(int64(x.RetweetCount)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey9225) + r.EncodeString(codecSelferC_UTF89225, string("retweet_count")) + z.EncSendContainerState(codecSelfer_containerMapValue9225) + yym72 := z.EncBinary() + _ = yym72 + if false { + } else { + r.EncodeInt(int64(x.RetweetCount)) + } + } + if yyr2 || yy2arr2 { + z.EncSendContainerState(codecSelfer_containerArrayElem9225) + yym74 := z.EncBinary() + _ = yym74 + if false { + } else { + r.EncodeBool(bool(x.Retweeted)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey9225) + r.EncodeString(codecSelferC_UTF89225, string("retweeted")) + z.EncSendContainerState(codecSelfer_containerMapValue9225) + yym75 := z.EncBinary() + _ = yym75 + if false { + } else { + r.EncodeBool(bool(x.Retweeted)) + } + } + if yyr2 || yy2arr2 { + z.EncSendContainerState(codecSelfer_containerArrayElem9225) + yym77 := z.EncBinary() + _ = yym77 + if false { + } else { + r.EncodeString(codecSelferC_UTF89225, string(x.Source)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey9225) + r.EncodeString(codecSelferC_UTF89225, string("source")) + z.EncSendContainerState(codecSelfer_containerMapValue9225) + yym78 := z.EncBinary() + _ = yym78 + if false { + } else { + r.EncodeString(codecSelferC_UTF89225, string(x.Source)) + } + } + if yyr2 || yy2arr2 { + z.EncSendContainerState(codecSelfer_containerArrayElem9225) + yym80 := z.EncBinary() + _ = yym80 + if false { + } else { + r.EncodeString(codecSelferC_UTF89225, string(x.Text)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey9225) + r.EncodeString(codecSelferC_UTF89225, string("text")) + z.EncSendContainerState(codecSelfer_containerMapValue9225) + yym81 := z.EncBinary() + _ = yym81 + if false { + } else { + r.EncodeString(codecSelferC_UTF89225, string(x.Text)) + } + } + if yyr2 || yy2arr2 { + z.EncSendContainerState(codecSelfer_containerArrayElem9225) + yym83 := z.EncBinary() + _ = yym83 + if false { + } else { + r.EncodeBool(bool(x.Truncated)) + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey9225) + r.EncodeString(codecSelferC_UTF89225, string("truncated")) + z.EncSendContainerState(codecSelfer_containerMapValue9225) + yym84 := z.EncBinary() + _ = yym84 + if false { + } else { + r.EncodeBool(bool(x.Truncated)) + } + } + if yyr2 || yy2arr2 { + z.EncSendContainerState(codecSelfer_containerArrayElem9225) + yy86 := &x.User + yy86.CodecEncodeSelf(e) + } else { + z.EncSendContainerState(codecSelfer_containerMapKey9225) + r.EncodeString(codecSelferC_UTF89225, string("user")) + z.EncSendContainerState(codecSelfer_containerMapValue9225) + yy88 := &x.User + yy88.CodecEncodeSelf(e) + } + if yyr2 || yy2arr2 { + z.EncSendContainerState(codecSelfer_containerArrayEnd9225) + } else { + z.EncSendContainerState(codecSelfer_containerMapEnd9225) + } + } + } +} + +func (x *Status) CodecDecodeSelf(d *codec1978.Decoder) { + var h codecSelfer9225 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + yym1 := z.DecBinary() + _ = yym1 + if false { + } else if z.HasExtensions() && z.DecExt(x) { + } else { + yyct2 := r.ContainerType() + if yyct2 == codecSelferValueTypeMap9225 { + yyl2 := r.ReadMapStart() + if yyl2 == 0 { + z.DecSendContainerState(codecSelfer_containerMapEnd9225) + } else { + x.codecDecodeSelfFromMap(yyl2, d) + } + } else if yyct2 == codecSelferValueTypeArray9225 { + yyl2 := r.ReadArrayStart() + if yyl2 == 0 { + z.DecSendContainerState(codecSelfer_containerArrayEnd9225) + } else { + x.codecDecodeSelfFromArray(yyl2, d) + } + } else { + panic(codecSelferOnlyMapOrArrayEncodeToStructErr9225) + } + } +} + +func (x *Status) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { + var h codecSelfer9225 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + var yys3Slc = z.DecScratchBuffer() // default slice to decode into + _ = yys3Slc + var yyhl3 bool = l >= 0 + for yyj3 := 0; ; yyj3++ { + if yyhl3 { + if yyj3 >= l { + break + } + } else { + if r.CheckBreak() { + break + } + } + z.DecSendContainerState(codecSelfer_containerMapKey9225) + yys3Slc = r.DecodeBytes(yys3Slc, true, true) + yys3SlcHdr := codecSelferUnsafeString9225{uintptr(unsafe.Pointer(&yys3Slc[0])), len(yys3Slc)} + yys3 := *(*string)(unsafe.Pointer(&yys3SlcHdr)) + z.DecSendContainerState(codecSelfer_containerMapValue9225) + switch yys3 { + case "contributors": + if r.TryDecodeAsNil() { + if x.Contributors != nil { + x.Contributors = nil + } + } else { + if x.Contributors == nil { + x.Contributors = new(string) + } + yym5 := z.DecBinary() + _ = yym5 + if false { + } else { + *((*string)(x.Contributors)) = r.DecodeString() + } + } + case "coordinates": + if r.TryDecodeAsNil() { + if x.Coordinates != nil { + x.Coordinates = nil + } + } else { + if x.Coordinates == nil { + x.Coordinates = new(string) + } + yym7 := z.DecBinary() + _ = yym7 + if false { + } else { + *((*string)(x.Coordinates)) = r.DecodeString() + } + } + case "created_at": + if r.TryDecodeAsNil() { + x.CreatedAt = "" + } else { + yyv8 := &x.CreatedAt + yym9 := z.DecBinary() + _ = yym9 + if false { + } else { + *((*string)(yyv8)) = r.DecodeString() + } + } + case "entities": + if r.TryDecodeAsNil() { + x.Entities = Entities{} + } else { + yyv10 := &x.Entities + yyv10.CodecDecodeSelf(d) + } + case "favorited": + if r.TryDecodeAsNil() { + x.Favorited = false + } else { + yyv11 := &x.Favorited + yym12 := z.DecBinary() + _ = yym12 + if false { + } else { + *((*bool)(yyv11)) = r.DecodeBool() + } + } + case "geo": + if r.TryDecodeAsNil() { + if x.Geo != nil { + x.Geo = nil + } + } else { + if x.Geo == nil { + x.Geo = new(string) + } + yym14 := z.DecBinary() + _ = yym14 + if false { + } else { + *((*string)(x.Geo)) = r.DecodeString() + } + } + case "id": + if r.TryDecodeAsNil() { + x.ID = 0 + } else { + yyv15 := &x.ID + yym16 := z.DecBinary() + _ = yym16 + if false { + } else { + *((*int64)(yyv15)) = int64(r.DecodeInt(64)) + } + } + case "id_str": + if r.TryDecodeAsNil() { + x.IDStr = "" + } else { + yyv17 := &x.IDStr + yym18 := z.DecBinary() + _ = yym18 + if false { + } else { + *((*string)(yyv17)) = r.DecodeString() + } + } + case "in_reply_to_screen_name": + if r.TryDecodeAsNil() { + if x.InReplyToScreenName != nil { + x.InReplyToScreenName = nil + } + } else { + if x.InReplyToScreenName == nil { + x.InReplyToScreenName = new(string) + } + yym20 := z.DecBinary() + _ = yym20 + if false { + } else { + *((*string)(x.InReplyToScreenName)) = r.DecodeString() + } + } + case "in_reply_to_status_id": + if r.TryDecodeAsNil() { + if x.InReplyToStatusID != nil { + x.InReplyToStatusID = nil + } + } else { + if x.InReplyToStatusID == nil { + x.InReplyToStatusID = new(string) + } + yym22 := z.DecBinary() + _ = yym22 + if false { + } else { + *((*string)(x.InReplyToStatusID)) = r.DecodeString() + } + } + case "in_reply_to_status_id_str": + if r.TryDecodeAsNil() { + if x.InReplyToStatusIDStr != nil { + x.InReplyToStatusIDStr = nil + } + } else { + if x.InReplyToStatusIDStr == nil { + x.InReplyToStatusIDStr = new(string) + } + yym24 := z.DecBinary() + _ = yym24 + if false { + } else { + *((*string)(x.InReplyToStatusIDStr)) = r.DecodeString() + } + } + case "in_reply_to_user_id": + if r.TryDecodeAsNil() { + if x.InReplyToUserID != nil { + x.InReplyToUserID = nil + } + } else { + if x.InReplyToUserID == nil { + x.InReplyToUserID = new(string) + } + yym26 := z.DecBinary() + _ = yym26 + if false { + } else { + *((*string)(x.InReplyToUserID)) = r.DecodeString() + } + } + case "in_reply_to_user_id_str": + if r.TryDecodeAsNil() { + if x.InReplyToUserIDStr != nil { + x.InReplyToUserIDStr = nil + } + } else { + if x.InReplyToUserIDStr == nil { + x.InReplyToUserIDStr = new(string) + } + yym28 := z.DecBinary() + _ = yym28 + if false { + } else { + *((*string)(x.InReplyToUserIDStr)) = r.DecodeString() + } + } + case "metadata": + if r.TryDecodeAsNil() { + x.Metadata = StatusMetadata{} + } else { + yyv29 := &x.Metadata + yyv29.CodecDecodeSelf(d) + } + case "place": + if r.TryDecodeAsNil() { + if x.Place != nil { + x.Place = nil + } + } else { + if x.Place == nil { + x.Place = new(string) + } + yym31 := z.DecBinary() + _ = yym31 + if false { + } else { + *((*string)(x.Place)) = r.DecodeString() + } + } + case "retweet_count": + if r.TryDecodeAsNil() { + x.RetweetCount = 0 + } else { + yyv32 := &x.RetweetCount + yym33 := z.DecBinary() + _ = yym33 + if false { + } else { + *((*int)(yyv32)) = int(r.DecodeInt(codecSelferBitsize9225)) + } + } + case "retweeted": + if r.TryDecodeAsNil() { + x.Retweeted = false + } else { + yyv34 := &x.Retweeted + yym35 := z.DecBinary() + _ = yym35 + if false { + } else { + *((*bool)(yyv34)) = r.DecodeBool() + } + } + case "source": + if r.TryDecodeAsNil() { + x.Source = "" + } else { + yyv36 := &x.Source + yym37 := z.DecBinary() + _ = yym37 + if false { + } else { + *((*string)(yyv36)) = r.DecodeString() + } + } + case "text": + if r.TryDecodeAsNil() { + x.Text = "" + } else { + yyv38 := &x.Text + yym39 := z.DecBinary() + _ = yym39 + if false { + } else { + *((*string)(yyv38)) = r.DecodeString() + } + } + case "truncated": + if r.TryDecodeAsNil() { + x.Truncated = false + } else { + yyv40 := &x.Truncated + yym41 := z.DecBinary() + _ = yym41 + if false { + } else { + *((*bool)(yyv40)) = r.DecodeBool() + } + } + case "user": + if r.TryDecodeAsNil() { + x.User = User{} + } else { + yyv42 := &x.User + yyv42.CodecDecodeSelf(d) + } + default: + z.DecStructFieldNotFound(-1, yys3) + } // end switch yys3 + } // end for yyj3 + z.DecSendContainerState(codecSelfer_containerMapEnd9225) +} + +func (x *Status) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { + var h codecSelfer9225 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + var yyj43 int + var yyb43 bool + var yyhl43 bool = l >= 0 + yyj43++ + if yyhl43 { + yyb43 = yyj43 > l + } else { + yyb43 = r.CheckBreak() + } + if yyb43 { + z.DecSendContainerState(codecSelfer_containerArrayEnd9225) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem9225) + if r.TryDecodeAsNil() { + if x.Contributors != nil { + x.Contributors = nil + } + } else { + if x.Contributors == nil { + x.Contributors = new(string) + } + yym45 := z.DecBinary() + _ = yym45 + if false { + } else { + *((*string)(x.Contributors)) = r.DecodeString() + } + } + yyj43++ + if yyhl43 { + yyb43 = yyj43 > l + } else { + yyb43 = r.CheckBreak() + } + if yyb43 { + z.DecSendContainerState(codecSelfer_containerArrayEnd9225) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem9225) + if r.TryDecodeAsNil() { + if x.Coordinates != nil { + x.Coordinates = nil + } + } else { + if x.Coordinates == nil { + x.Coordinates = new(string) + } + yym47 := z.DecBinary() + _ = yym47 + if false { + } else { + *((*string)(x.Coordinates)) = r.DecodeString() + } + } + yyj43++ + if yyhl43 { + yyb43 = yyj43 > l + } else { + yyb43 = r.CheckBreak() + } + if yyb43 { + z.DecSendContainerState(codecSelfer_containerArrayEnd9225) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem9225) + if r.TryDecodeAsNil() { + x.CreatedAt = "" + } else { + yyv48 := &x.CreatedAt + yym49 := z.DecBinary() + _ = yym49 + if false { + } else { + *((*string)(yyv48)) = r.DecodeString() + } + } + yyj43++ + if yyhl43 { + yyb43 = yyj43 > l + } else { + yyb43 = r.CheckBreak() + } + if yyb43 { + z.DecSendContainerState(codecSelfer_containerArrayEnd9225) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem9225) + if r.TryDecodeAsNil() { + x.Entities = Entities{} + } else { + yyv50 := &x.Entities + yyv50.CodecDecodeSelf(d) + } + yyj43++ + if yyhl43 { + yyb43 = yyj43 > l + } else { + yyb43 = r.CheckBreak() + } + if yyb43 { + z.DecSendContainerState(codecSelfer_containerArrayEnd9225) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem9225) + if r.TryDecodeAsNil() { + x.Favorited = false + } else { + yyv51 := &x.Favorited + yym52 := z.DecBinary() + _ = yym52 + if false { + } else { + *((*bool)(yyv51)) = r.DecodeBool() + } + } + yyj43++ + if yyhl43 { + yyb43 = yyj43 > l + } else { + yyb43 = r.CheckBreak() + } + if yyb43 { + z.DecSendContainerState(codecSelfer_containerArrayEnd9225) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem9225) + if r.TryDecodeAsNil() { + if x.Geo != nil { + x.Geo = nil + } + } else { + if x.Geo == nil { + x.Geo = new(string) + } + yym54 := z.DecBinary() + _ = yym54 + if false { + } else { + *((*string)(x.Geo)) = r.DecodeString() + } + } + yyj43++ + if yyhl43 { + yyb43 = yyj43 > l + } else { + yyb43 = r.CheckBreak() + } + if yyb43 { + z.DecSendContainerState(codecSelfer_containerArrayEnd9225) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem9225) + if r.TryDecodeAsNil() { + x.ID = 0 + } else { + yyv55 := &x.ID + yym56 := z.DecBinary() + _ = yym56 + if false { + } else { + *((*int64)(yyv55)) = int64(r.DecodeInt(64)) + } + } + yyj43++ + if yyhl43 { + yyb43 = yyj43 > l + } else { + yyb43 = r.CheckBreak() + } + if yyb43 { + z.DecSendContainerState(codecSelfer_containerArrayEnd9225) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem9225) + if r.TryDecodeAsNil() { + x.IDStr = "" + } else { + yyv57 := &x.IDStr + yym58 := z.DecBinary() + _ = yym58 + if false { + } else { + *((*string)(yyv57)) = r.DecodeString() + } + } + yyj43++ + if yyhl43 { + yyb43 = yyj43 > l + } else { + yyb43 = r.CheckBreak() + } + if yyb43 { + z.DecSendContainerState(codecSelfer_containerArrayEnd9225) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem9225) + if r.TryDecodeAsNil() { + if x.InReplyToScreenName != nil { + x.InReplyToScreenName = nil + } + } else { + if x.InReplyToScreenName == nil { + x.InReplyToScreenName = new(string) + } + yym60 := z.DecBinary() + _ = yym60 + if false { + } else { + *((*string)(x.InReplyToScreenName)) = r.DecodeString() + } + } + yyj43++ + if yyhl43 { + yyb43 = yyj43 > l + } else { + yyb43 = r.CheckBreak() + } + if yyb43 { + z.DecSendContainerState(codecSelfer_containerArrayEnd9225) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem9225) + if r.TryDecodeAsNil() { + if x.InReplyToStatusID != nil { + x.InReplyToStatusID = nil + } + } else { + if x.InReplyToStatusID == nil { + x.InReplyToStatusID = new(string) + } + yym62 := z.DecBinary() + _ = yym62 + if false { + } else { + *((*string)(x.InReplyToStatusID)) = r.DecodeString() + } + } + yyj43++ + if yyhl43 { + yyb43 = yyj43 > l + } else { + yyb43 = r.CheckBreak() + } + if yyb43 { + z.DecSendContainerState(codecSelfer_containerArrayEnd9225) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem9225) + if r.TryDecodeAsNil() { + if x.InReplyToStatusIDStr != nil { + x.InReplyToStatusIDStr = nil + } + } else { + if x.InReplyToStatusIDStr == nil { + x.InReplyToStatusIDStr = new(string) + } + yym64 := z.DecBinary() + _ = yym64 + if false { + } else { + *((*string)(x.InReplyToStatusIDStr)) = r.DecodeString() + } + } + yyj43++ + if yyhl43 { + yyb43 = yyj43 > l + } else { + yyb43 = r.CheckBreak() + } + if yyb43 { + z.DecSendContainerState(codecSelfer_containerArrayEnd9225) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem9225) + if r.TryDecodeAsNil() { + if x.InReplyToUserID != nil { + x.InReplyToUserID = nil + } + } else { + if x.InReplyToUserID == nil { + x.InReplyToUserID = new(string) + } + yym66 := z.DecBinary() + _ = yym66 + if false { + } else { + *((*string)(x.InReplyToUserID)) = r.DecodeString() + } + } + yyj43++ + if yyhl43 { + yyb43 = yyj43 > l + } else { + yyb43 = r.CheckBreak() + } + if yyb43 { + z.DecSendContainerState(codecSelfer_containerArrayEnd9225) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem9225) + if r.TryDecodeAsNil() { + if x.InReplyToUserIDStr != nil { + x.InReplyToUserIDStr = nil + } + } else { + if x.InReplyToUserIDStr == nil { + x.InReplyToUserIDStr = new(string) + } + yym68 := z.DecBinary() + _ = yym68 + if false { + } else { + *((*string)(x.InReplyToUserIDStr)) = r.DecodeString() + } + } + yyj43++ + if yyhl43 { + yyb43 = yyj43 > l + } else { + yyb43 = r.CheckBreak() + } + if yyb43 { + z.DecSendContainerState(codecSelfer_containerArrayEnd9225) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem9225) + if r.TryDecodeAsNil() { + x.Metadata = StatusMetadata{} + } else { + yyv69 := &x.Metadata + yyv69.CodecDecodeSelf(d) + } + yyj43++ + if yyhl43 { + yyb43 = yyj43 > l + } else { + yyb43 = r.CheckBreak() + } + if yyb43 { + z.DecSendContainerState(codecSelfer_containerArrayEnd9225) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem9225) + if r.TryDecodeAsNil() { + if x.Place != nil { + x.Place = nil + } + } else { + if x.Place == nil { + x.Place = new(string) + } + yym71 := z.DecBinary() + _ = yym71 + if false { + } else { + *((*string)(x.Place)) = r.DecodeString() + } + } + yyj43++ + if yyhl43 { + yyb43 = yyj43 > l + } else { + yyb43 = r.CheckBreak() + } + if yyb43 { + z.DecSendContainerState(codecSelfer_containerArrayEnd9225) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem9225) + if r.TryDecodeAsNil() { + x.RetweetCount = 0 + } else { + yyv72 := &x.RetweetCount + yym73 := z.DecBinary() + _ = yym73 + if false { + } else { + *((*int)(yyv72)) = int(r.DecodeInt(codecSelferBitsize9225)) + } + } + yyj43++ + if yyhl43 { + yyb43 = yyj43 > l + } else { + yyb43 = r.CheckBreak() + } + if yyb43 { + z.DecSendContainerState(codecSelfer_containerArrayEnd9225) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem9225) + if r.TryDecodeAsNil() { + x.Retweeted = false + } else { + yyv74 := &x.Retweeted + yym75 := z.DecBinary() + _ = yym75 + if false { + } else { + *((*bool)(yyv74)) = r.DecodeBool() + } + } + yyj43++ + if yyhl43 { + yyb43 = yyj43 > l + } else { + yyb43 = r.CheckBreak() + } + if yyb43 { + z.DecSendContainerState(codecSelfer_containerArrayEnd9225) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem9225) + if r.TryDecodeAsNil() { + x.Source = "" + } else { + yyv76 := &x.Source + yym77 := z.DecBinary() + _ = yym77 + if false { + } else { + *((*string)(yyv76)) = r.DecodeString() + } + } + yyj43++ + if yyhl43 { + yyb43 = yyj43 > l + } else { + yyb43 = r.CheckBreak() + } + if yyb43 { + z.DecSendContainerState(codecSelfer_containerArrayEnd9225) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem9225) + if r.TryDecodeAsNil() { + x.Text = "" + } else { + yyv78 := &x.Text + yym79 := z.DecBinary() + _ = yym79 + if false { + } else { + *((*string)(yyv78)) = r.DecodeString() + } + } + yyj43++ + if yyhl43 { + yyb43 = yyj43 > l + } else { + yyb43 = r.CheckBreak() + } + if yyb43 { + z.DecSendContainerState(codecSelfer_containerArrayEnd9225) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem9225) + if r.TryDecodeAsNil() { + x.Truncated = false + } else { + yyv80 := &x.Truncated + yym81 := z.DecBinary() + _ = yym81 + if false { + } else { + *((*bool)(yyv80)) = r.DecodeBool() + } + } + yyj43++ + if yyhl43 { + yyb43 = yyj43 > l + } else { + yyb43 = r.CheckBreak() + } + if yyb43 { + z.DecSendContainerState(codecSelfer_containerArrayEnd9225) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem9225) + if r.TryDecodeAsNil() { + x.User = User{} + } else { + yyv82 := &x.User + yyv82.CodecDecodeSelf(d) + } + for { + yyj43++ + if yyhl43 { + yyb43 = yyj43 > l + } else { + yyb43 = r.CheckBreak() + } + if yyb43 { + break + } + z.DecSendContainerState(codecSelfer_containerArrayElem9225) + z.DecStructFieldNotFound(yyj43-1, "") + } + z.DecSendContainerState(codecSelfer_containerArrayEnd9225) +} + +func (x *LargeStruct) CodecEncodeSelf(e *codec1978.Encoder) { + var h codecSelfer9225 + z, r := codec1978.GenHelperEncoder(e) + _, _, _ = h, z, r + if x == nil { + r.EncodeNil() + } else { + yym1 := z.EncBinary() + _ = yym1 + if false { + } else if z.HasExtensions() && z.EncExt(x) { + } else { + yysep2 := !z.EncBinary() + yy2arr2 := z.EncBasicHandle().StructToArray + var yyq2 [2]bool + _, _, _ = yysep2, yyq2, yy2arr2 + const yyr2 bool = false + var yynn2 int + if yyr2 || yy2arr2 { + r.EncodeArrayStart(2) + } else { + yynn2 = 2 + for _, b := range yyq2 { + if b { + yynn2++ + } + } + r.EncodeMapStart(yynn2) + yynn2 = 0 + } + if yyr2 || yy2arr2 { + z.EncSendContainerState(codecSelfer_containerArrayElem9225) + yy4 := &x.SearchMetadata + yy4.CodecEncodeSelf(e) + } else { + z.EncSendContainerState(codecSelfer_containerMapKey9225) + r.EncodeString(codecSelferC_UTF89225, string("search_metadata")) + z.EncSendContainerState(codecSelfer_containerMapValue9225) + yy6 := &x.SearchMetadata + yy6.CodecEncodeSelf(e) + } + if yyr2 || yy2arr2 { + z.EncSendContainerState(codecSelfer_containerArrayElem9225) + if x.Statuses == nil { + r.EncodeNil() + } else { + yym9 := z.EncBinary() + _ = yym9 + if false { + } else { + h.encSliceStatus(([]Status)(x.Statuses), e) + } + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey9225) + r.EncodeString(codecSelferC_UTF89225, string("statuses")) + z.EncSendContainerState(codecSelfer_containerMapValue9225) + if x.Statuses == nil { + r.EncodeNil() + } else { + yym10 := z.EncBinary() + _ = yym10 + if false { + } else { + h.encSliceStatus(([]Status)(x.Statuses), e) + } + } + } + if yyr2 || yy2arr2 { + z.EncSendContainerState(codecSelfer_containerArrayEnd9225) + } else { + z.EncSendContainerState(codecSelfer_containerMapEnd9225) + } + } + } +} + +func (x *LargeStruct) CodecDecodeSelf(d *codec1978.Decoder) { + var h codecSelfer9225 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + yym1 := z.DecBinary() + _ = yym1 + if false { + } else if z.HasExtensions() && z.DecExt(x) { + } else { + yyct2 := r.ContainerType() + if yyct2 == codecSelferValueTypeMap9225 { + yyl2 := r.ReadMapStart() + if yyl2 == 0 { + z.DecSendContainerState(codecSelfer_containerMapEnd9225) + } else { + x.codecDecodeSelfFromMap(yyl2, d) + } + } else if yyct2 == codecSelferValueTypeArray9225 { + yyl2 := r.ReadArrayStart() + if yyl2 == 0 { + z.DecSendContainerState(codecSelfer_containerArrayEnd9225) + } else { + x.codecDecodeSelfFromArray(yyl2, d) + } + } else { + panic(codecSelferOnlyMapOrArrayEncodeToStructErr9225) + } + } +} + +func (x *LargeStruct) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { + var h codecSelfer9225 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + var yys3Slc = z.DecScratchBuffer() // default slice to decode into + _ = yys3Slc + var yyhl3 bool = l >= 0 + for yyj3 := 0; ; yyj3++ { + if yyhl3 { + if yyj3 >= l { + break + } + } else { + if r.CheckBreak() { + break + } + } + z.DecSendContainerState(codecSelfer_containerMapKey9225) + yys3Slc = r.DecodeBytes(yys3Slc, true, true) + yys3SlcHdr := codecSelferUnsafeString9225{uintptr(unsafe.Pointer(&yys3Slc[0])), len(yys3Slc)} + yys3 := *(*string)(unsafe.Pointer(&yys3SlcHdr)) + z.DecSendContainerState(codecSelfer_containerMapValue9225) + switch yys3 { + case "search_metadata": + if r.TryDecodeAsNil() { + x.SearchMetadata = SearchMetadata{} + } else { + yyv4 := &x.SearchMetadata + yyv4.CodecDecodeSelf(d) + } + case "statuses": + if r.TryDecodeAsNil() { + x.Statuses = nil + } else { + yyv5 := &x.Statuses + yym6 := z.DecBinary() + _ = yym6 + if false { + } else { + h.decSliceStatus((*[]Status)(yyv5), d) + } + } + default: + z.DecStructFieldNotFound(-1, yys3) + } // end switch yys3 + } // end for yyj3 + z.DecSendContainerState(codecSelfer_containerMapEnd9225) +} + +func (x *LargeStruct) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { + var h codecSelfer9225 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + var yyj7 int + var yyb7 bool + var yyhl7 bool = l >= 0 + yyj7++ + if yyhl7 { + yyb7 = yyj7 > l + } else { + yyb7 = r.CheckBreak() + } + if yyb7 { + z.DecSendContainerState(codecSelfer_containerArrayEnd9225) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem9225) + if r.TryDecodeAsNil() { + x.SearchMetadata = SearchMetadata{} + } else { + yyv8 := &x.SearchMetadata + yyv8.CodecDecodeSelf(d) + } + yyj7++ + if yyhl7 { + yyb7 = yyj7 > l + } else { + yyb7 = r.CheckBreak() + } + if yyb7 { + z.DecSendContainerState(codecSelfer_containerArrayEnd9225) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem9225) + if r.TryDecodeAsNil() { + x.Statuses = nil + } else { + yyv9 := &x.Statuses + yym10 := z.DecBinary() + _ = yym10 + if false { + } else { + h.decSliceStatus((*[]Status)(yyv9), d) + } + } + for { + yyj7++ + if yyhl7 { + yyb7 = yyj7 > l + } else { + yyb7 = r.CheckBreak() + } + if yyb7 { + break + } + z.DecSendContainerState(codecSelfer_containerArrayElem9225) + z.DecStructFieldNotFound(yyj7-1, "") + } + z.DecSendContainerState(codecSelfer_containerArrayEnd9225) +} + +func (x *XLStruct) CodecEncodeSelf(e *codec1978.Encoder) { + var h codecSelfer9225 + z, r := codec1978.GenHelperEncoder(e) + _, _, _ = h, z, r + if x == nil { + r.EncodeNil() + } else { + yym1 := z.EncBinary() + _ = yym1 + if false { + } else if z.HasExtensions() && z.EncExt(x) { + } else { + yysep2 := !z.EncBinary() + yy2arr2 := z.EncBasicHandle().StructToArray + var yyq2 [1]bool + _, _, _ = yysep2, yyq2, yy2arr2 + const yyr2 bool = false + var yynn2 int + if yyr2 || yy2arr2 { + r.EncodeArrayStart(1) + } else { + yynn2 = 1 + for _, b := range yyq2 { + if b { + yynn2++ + } + } + r.EncodeMapStart(yynn2) + yynn2 = 0 + } + if yyr2 || yy2arr2 { + z.EncSendContainerState(codecSelfer_containerArrayElem9225) + if x.Data == nil { + r.EncodeNil() + } else { + yym4 := z.EncBinary() + _ = yym4 + if false { + } else { + h.encSliceLargeStruct(([]LargeStruct)(x.Data), e) + } + } + } else { + z.EncSendContainerState(codecSelfer_containerMapKey9225) + r.EncodeString(codecSelferC_UTF89225, string("Data")) + z.EncSendContainerState(codecSelfer_containerMapValue9225) + if x.Data == nil { + r.EncodeNil() + } else { + yym5 := z.EncBinary() + _ = yym5 + if false { + } else { + h.encSliceLargeStruct(([]LargeStruct)(x.Data), e) + } + } + } + if yyr2 || yy2arr2 { + z.EncSendContainerState(codecSelfer_containerArrayEnd9225) + } else { + z.EncSendContainerState(codecSelfer_containerMapEnd9225) + } + } + } +} + +func (x *XLStruct) CodecDecodeSelf(d *codec1978.Decoder) { + var h codecSelfer9225 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + yym1 := z.DecBinary() + _ = yym1 + if false { + } else if z.HasExtensions() && z.DecExt(x) { + } else { + yyct2 := r.ContainerType() + if yyct2 == codecSelferValueTypeMap9225 { + yyl2 := r.ReadMapStart() + if yyl2 == 0 { + z.DecSendContainerState(codecSelfer_containerMapEnd9225) + } else { + x.codecDecodeSelfFromMap(yyl2, d) + } + } else if yyct2 == codecSelferValueTypeArray9225 { + yyl2 := r.ReadArrayStart() + if yyl2 == 0 { + z.DecSendContainerState(codecSelfer_containerArrayEnd9225) + } else { + x.codecDecodeSelfFromArray(yyl2, d) + } + } else { + panic(codecSelferOnlyMapOrArrayEncodeToStructErr9225) + } + } +} + +func (x *XLStruct) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { + var h codecSelfer9225 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + var yys3Slc = z.DecScratchBuffer() // default slice to decode into + _ = yys3Slc + var yyhl3 bool = l >= 0 + for yyj3 := 0; ; yyj3++ { + if yyhl3 { + if yyj3 >= l { + break + } + } else { + if r.CheckBreak() { + break + } + } + z.DecSendContainerState(codecSelfer_containerMapKey9225) + yys3Slc = r.DecodeBytes(yys3Slc, true, true) + yys3SlcHdr := codecSelferUnsafeString9225{uintptr(unsafe.Pointer(&yys3Slc[0])), len(yys3Slc)} + yys3 := *(*string)(unsafe.Pointer(&yys3SlcHdr)) + z.DecSendContainerState(codecSelfer_containerMapValue9225) + switch yys3 { + case "Data": + if r.TryDecodeAsNil() { + x.Data = nil + } else { + yyv4 := &x.Data + yym5 := z.DecBinary() + _ = yym5 + if false { + } else { + h.decSliceLargeStruct((*[]LargeStruct)(yyv4), d) + } + } + default: + z.DecStructFieldNotFound(-1, yys3) + } // end switch yys3 + } // end for yyj3 + z.DecSendContainerState(codecSelfer_containerMapEnd9225) +} + +func (x *XLStruct) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { + var h codecSelfer9225 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + var yyj6 int + var yyb6 bool + var yyhl6 bool = l >= 0 + yyj6++ + if yyhl6 { + yyb6 = yyj6 > l + } else { + yyb6 = r.CheckBreak() + } + if yyb6 { + z.DecSendContainerState(codecSelfer_containerArrayEnd9225) + return + } + z.DecSendContainerState(codecSelfer_containerArrayElem9225) + if r.TryDecodeAsNil() { + x.Data = nil + } else { + yyv7 := &x.Data + yym8 := z.DecBinary() + _ = yym8 + if false { + } else { + h.decSliceLargeStruct((*[]LargeStruct)(yyv7), d) + } + } + for { + yyj6++ + if yyhl6 { + yyb6 = yyj6 > l + } else { + yyb6 = r.CheckBreak() + } + if yyb6 { + break + } + z.DecSendContainerState(codecSelfer_containerArrayElem9225) + z.DecStructFieldNotFound(yyj6-1, "") + } + z.DecSendContainerState(codecSelfer_containerArrayEnd9225) +} + +func (x codecSelfer9225) encSliceHashtag(v []Hashtag, e *codec1978.Encoder) { + var h codecSelfer9225 + z, r := codec1978.GenHelperEncoder(e) + _, _, _ = h, z, r + r.EncodeArrayStart(len(v)) + for _, yyv1 := range v { + z.EncSendContainerState(codecSelfer_containerArrayElem9225) + yy2 := &yyv1 + yy2.CodecEncodeSelf(e) + } + z.EncSendContainerState(codecSelfer_containerArrayEnd9225) +} + +func (x codecSelfer9225) decSliceHashtag(v *[]Hashtag, d *codec1978.Decoder) { + var h codecSelfer9225 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + + yyv1 := *v + yyh1, yyl1 := z.DecSliceHelperStart() + var yyc1 bool + _ = yyc1 + if yyl1 == 0 { + if yyv1 == nil { + yyv1 = []Hashtag{} + yyc1 = true + } else if len(yyv1) != 0 { + yyv1 = yyv1[:0] + yyc1 = true + } + } else if yyl1 > 0 { + var yyrr1, yyrl1 int + var yyrt1 bool + _, _ = yyrl1, yyrt1 + yyrr1 = yyl1 // len(yyv1) + if yyl1 > cap(yyv1) { + + yyrg1 := len(yyv1) > 0 + yyv21 := yyv1 + yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 40) + if yyrt1 { + if yyrl1 <= cap(yyv1) { + yyv1 = yyv1[:yyrl1] + } else { + yyv1 = make([]Hashtag, yyrl1) + } + } else { + yyv1 = make([]Hashtag, yyrl1) + } + yyc1 = true + yyrr1 = len(yyv1) + if yyrg1 { + copy(yyv1, yyv21) + } + } else if yyl1 != len(yyv1) { + yyv1 = yyv1[:yyl1] + yyc1 = true + } + yyj1 := 0 + for ; yyj1 < yyrr1; yyj1++ { + yyh1.ElemContainerState(yyj1) + if r.TryDecodeAsNil() { + yyv1[yyj1] = Hashtag{} + } else { + yyv2 := &yyv1[yyj1] + yyv2.CodecDecodeSelf(d) + } + + } + if yyrt1 { + for ; yyj1 < yyl1; yyj1++ { + yyv1 = append(yyv1, Hashtag{}) + yyh1.ElemContainerState(yyj1) + if r.TryDecodeAsNil() { + yyv1[yyj1] = Hashtag{} + } else { + yyv3 := &yyv1[yyj1] + yyv3.CodecDecodeSelf(d) + } + + } + } + + } else { + yyj1 := 0 + for ; !r.CheckBreak(); yyj1++ { + + if yyj1 >= len(yyv1) { + yyv1 = append(yyv1, Hashtag{}) // var yyz1 Hashtag + yyc1 = true + } + yyh1.ElemContainerState(yyj1) + if yyj1 < len(yyv1) { + if r.TryDecodeAsNil() { + yyv1[yyj1] = Hashtag{} + } else { + yyv4 := &yyv1[yyj1] + yyv4.CodecDecodeSelf(d) + } + + } else { + z.DecSwallow() + } + + } + if yyj1 < len(yyv1) { + yyv1 = yyv1[:yyj1] + yyc1 = true + } else if yyj1 == 0 && yyv1 == nil { + yyv1 = []Hashtag{} + yyc1 = true + } + } + yyh1.End() + if yyc1 { + *v = yyv1 + } +} + +func (x codecSelfer9225) encSlicePtrtostring(v []*string, e *codec1978.Encoder) { + var h codecSelfer9225 + z, r := codec1978.GenHelperEncoder(e) + _, _, _ = h, z, r + r.EncodeArrayStart(len(v)) + for _, yyv1 := range v { + z.EncSendContainerState(codecSelfer_containerArrayElem9225) + if yyv1 == nil { + r.EncodeNil() + } else { + yy2 := *yyv1 + yym3 := z.EncBinary() + _ = yym3 + if false { + } else { + r.EncodeString(codecSelferC_UTF89225, string(yy2)) + } + } + } + z.EncSendContainerState(codecSelfer_containerArrayEnd9225) +} + +func (x codecSelfer9225) decSlicePtrtostring(v *[]*string, d *codec1978.Decoder) { + var h codecSelfer9225 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + + yyv1 := *v + yyh1, yyl1 := z.DecSliceHelperStart() + var yyc1 bool + _ = yyc1 + if yyl1 == 0 { + if yyv1 == nil { + yyv1 = []*string{} + yyc1 = true + } else if len(yyv1) != 0 { + yyv1 = yyv1[:0] + yyc1 = true + } + } else if yyl1 > 0 { + var yyrr1, yyrl1 int + var yyrt1 bool + _, _ = yyrl1, yyrt1 + yyrr1 = yyl1 // len(yyv1) + if yyl1 > cap(yyv1) { + + yyrg1 := len(yyv1) > 0 + yyv21 := yyv1 + yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 8) + if yyrt1 { + if yyrl1 <= cap(yyv1) { + yyv1 = yyv1[:yyrl1] + } else { + yyv1 = make([]*string, yyrl1) + } + } else { + yyv1 = make([]*string, yyrl1) + } + yyc1 = true + yyrr1 = len(yyv1) + if yyrg1 { + copy(yyv1, yyv21) + } + } else if yyl1 != len(yyv1) { + yyv1 = yyv1[:yyl1] + yyc1 = true + } + yyj1 := 0 + for ; yyj1 < yyrr1; yyj1++ { + yyh1.ElemContainerState(yyj1) + if r.TryDecodeAsNil() { + if yyv1[yyj1] != nil { + *yyv1[yyj1] = "" + } + } else { + if yyv1[yyj1] == nil { + yyv1[yyj1] = new(string) + } + yyw2 := yyv1[yyj1] + yym3 := z.DecBinary() + _ = yym3 + if false { + } else { + *((*string)(yyw2)) = r.DecodeString() + } + } + + } + if yyrt1 { + for ; yyj1 < yyl1; yyj1++ { + yyv1 = append(yyv1, nil) + yyh1.ElemContainerState(yyj1) + if r.TryDecodeAsNil() { + if yyv1[yyj1] != nil { + *yyv1[yyj1] = "" + } + } else { + if yyv1[yyj1] == nil { + yyv1[yyj1] = new(string) + } + yyw4 := yyv1[yyj1] + yym5 := z.DecBinary() + _ = yym5 + if false { + } else { + *((*string)(yyw4)) = r.DecodeString() + } + } + + } + } + + } else { + yyj1 := 0 + for ; !r.CheckBreak(); yyj1++ { + + if yyj1 >= len(yyv1) { + yyv1 = append(yyv1, nil) // var yyz1 *string + yyc1 = true + } + yyh1.ElemContainerState(yyj1) + if yyj1 < len(yyv1) { + if r.TryDecodeAsNil() { + if yyv1[yyj1] != nil { + *yyv1[yyj1] = "" + } + } else { + if yyv1[yyj1] == nil { + yyv1[yyj1] = new(string) + } + yyw6 := yyv1[yyj1] + yym7 := z.DecBinary() + _ = yym7 + if false { + } else { + *((*string)(yyw6)) = r.DecodeString() + } + } + + } else { + z.DecSwallow() + } + + } + if yyj1 < len(yyv1) { + yyv1 = yyv1[:yyj1] + yyc1 = true + } else if yyj1 == 0 && yyv1 == nil { + yyv1 = []*string{} + yyc1 = true + } + } + yyh1.End() + if yyc1 { + *v = yyv1 + } +} + +func (x codecSelfer9225) encSliceURL(v []URL, e *codec1978.Encoder) { + var h codecSelfer9225 + z, r := codec1978.GenHelperEncoder(e) + _, _, _ = h, z, r + r.EncodeArrayStart(len(v)) + for _, yyv1 := range v { + z.EncSendContainerState(codecSelfer_containerArrayElem9225) + yy2 := &yyv1 + yy2.CodecEncodeSelf(e) + } + z.EncSendContainerState(codecSelfer_containerArrayEnd9225) +} + +func (x codecSelfer9225) decSliceURL(v *[]URL, d *codec1978.Decoder) { + var h codecSelfer9225 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + + yyv1 := *v + yyh1, yyl1 := z.DecSliceHelperStart() + var yyc1 bool + _ = yyc1 + if yyl1 == 0 { + if yyv1 == nil { + yyv1 = []URL{} + yyc1 = true + } else if len(yyv1) != 0 { + yyv1 = yyv1[:0] + yyc1 = true + } + } else if yyl1 > 0 { + var yyrr1, yyrl1 int + var yyrt1 bool + _, _ = yyrl1, yyrt1 + yyrr1 = yyl1 // len(yyv1) + if yyl1 > cap(yyv1) { + + yyrg1 := len(yyv1) > 0 + yyv21 := yyv1 + yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 48) + if yyrt1 { + if yyrl1 <= cap(yyv1) { + yyv1 = yyv1[:yyrl1] + } else { + yyv1 = make([]URL, yyrl1) + } + } else { + yyv1 = make([]URL, yyrl1) + } + yyc1 = true + yyrr1 = len(yyv1) + if yyrg1 { + copy(yyv1, yyv21) + } + } else if yyl1 != len(yyv1) { + yyv1 = yyv1[:yyl1] + yyc1 = true + } + yyj1 := 0 + for ; yyj1 < yyrr1; yyj1++ { + yyh1.ElemContainerState(yyj1) + if r.TryDecodeAsNil() { + yyv1[yyj1] = URL{} + } else { + yyv2 := &yyv1[yyj1] + yyv2.CodecDecodeSelf(d) + } + + } + if yyrt1 { + for ; yyj1 < yyl1; yyj1++ { + yyv1 = append(yyv1, URL{}) + yyh1.ElemContainerState(yyj1) + if r.TryDecodeAsNil() { + yyv1[yyj1] = URL{} + } else { + yyv3 := &yyv1[yyj1] + yyv3.CodecDecodeSelf(d) + } + + } + } + + } else { + yyj1 := 0 + for ; !r.CheckBreak(); yyj1++ { + + if yyj1 >= len(yyv1) { + yyv1 = append(yyv1, URL{}) // var yyz1 URL + yyc1 = true + } + yyh1.ElemContainerState(yyj1) + if yyj1 < len(yyv1) { + if r.TryDecodeAsNil() { + yyv1[yyj1] = URL{} + } else { + yyv4 := &yyv1[yyj1] + yyv4.CodecDecodeSelf(d) + } + + } else { + z.DecSwallow() + } + + } + if yyj1 < len(yyv1) { + yyv1 = yyv1[:yyj1] + yyc1 = true + } else if yyj1 == 0 && yyv1 == nil { + yyv1 = []URL{} + yyc1 = true + } + } + yyh1.End() + if yyc1 { + *v = yyv1 + } +} + +func (x codecSelfer9225) encSliceStatus(v []Status, e *codec1978.Encoder) { + var h codecSelfer9225 + z, r := codec1978.GenHelperEncoder(e) + _, _, _ = h, z, r + r.EncodeArrayStart(len(v)) + for _, yyv1 := range v { + z.EncSendContainerState(codecSelfer_containerArrayElem9225) + yy2 := &yyv1 + yy2.CodecEncodeSelf(e) + } + z.EncSendContainerState(codecSelfer_containerArrayEnd9225) +} + +func (x codecSelfer9225) decSliceStatus(v *[]Status, d *codec1978.Decoder) { + var h codecSelfer9225 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + + yyv1 := *v + yyh1, yyl1 := z.DecSliceHelperStart() + var yyc1 bool + _ = yyc1 + if yyl1 == 0 { + if yyv1 == nil { + yyv1 = []Status{} + yyc1 = true + } else if len(yyv1) != 0 { + yyv1 = yyv1[:0] + yyc1 = true + } + } else if yyl1 > 0 { + var yyrr1, yyrl1 int + var yyrt1 bool + _, _ = yyrl1, yyrt1 + yyrr1 = yyl1 // len(yyv1) + if yyl1 > cap(yyv1) { + + yyrg1 := len(yyv1) > 0 + yyv21 := yyv1 + yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 752) + if yyrt1 { + if yyrl1 <= cap(yyv1) { + yyv1 = yyv1[:yyrl1] + } else { + yyv1 = make([]Status, yyrl1) + } + } else { + yyv1 = make([]Status, yyrl1) + } + yyc1 = true + yyrr1 = len(yyv1) + if yyrg1 { + copy(yyv1, yyv21) + } + } else if yyl1 != len(yyv1) { + yyv1 = yyv1[:yyl1] + yyc1 = true + } + yyj1 := 0 + for ; yyj1 < yyrr1; yyj1++ { + yyh1.ElemContainerState(yyj1) + if r.TryDecodeAsNil() { + yyv1[yyj1] = Status{} + } else { + yyv2 := &yyv1[yyj1] + yyv2.CodecDecodeSelf(d) + } + + } + if yyrt1 { + for ; yyj1 < yyl1; yyj1++ { + yyv1 = append(yyv1, Status{}) + yyh1.ElemContainerState(yyj1) + if r.TryDecodeAsNil() { + yyv1[yyj1] = Status{} + } else { + yyv3 := &yyv1[yyj1] + yyv3.CodecDecodeSelf(d) + } + + } + } + + } else { + yyj1 := 0 + for ; !r.CheckBreak(); yyj1++ { + + if yyj1 >= len(yyv1) { + yyv1 = append(yyv1, Status{}) // var yyz1 Status + yyc1 = true + } + yyh1.ElemContainerState(yyj1) + if yyj1 < len(yyv1) { + if r.TryDecodeAsNil() { + yyv1[yyj1] = Status{} + } else { + yyv4 := &yyv1[yyj1] + yyv4.CodecDecodeSelf(d) + } + + } else { + z.DecSwallow() + } + + } + if yyj1 < len(yyv1) { + yyv1 = yyv1[:yyj1] + yyc1 = true + } else if yyj1 == 0 && yyv1 == nil { + yyv1 = []Status{} + yyc1 = true + } + } + yyh1.End() + if yyc1 { + *v = yyv1 + } +} + +func (x codecSelfer9225) encSliceLargeStruct(v []LargeStruct, e *codec1978.Encoder) { + var h codecSelfer9225 + z, r := codec1978.GenHelperEncoder(e) + _, _, _ = h, z, r + r.EncodeArrayStart(len(v)) + for _, yyv1 := range v { + z.EncSendContainerState(codecSelfer_containerArrayElem9225) + yy2 := &yyv1 + yy2.CodecEncodeSelf(e) + } + z.EncSendContainerState(codecSelfer_containerArrayEnd9225) +} + +func (x codecSelfer9225) decSliceLargeStruct(v *[]LargeStruct, d *codec1978.Decoder) { + var h codecSelfer9225 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + + yyv1 := *v + yyh1, yyl1 := z.DecSliceHelperStart() + var yyc1 bool + _ = yyc1 + if yyl1 == 0 { + if yyv1 == nil { + yyv1 = []LargeStruct{} + yyc1 = true + } else if len(yyv1) != 0 { + yyv1 = yyv1[:0] + yyc1 = true + } + } else if yyl1 > 0 { + var yyrr1, yyrl1 int + var yyrt1 bool + _, _ = yyrl1, yyrt1 + yyrr1 = yyl1 // len(yyv1) + if yyl1 > cap(yyv1) { + + yyrg1 := len(yyv1) > 0 + yyv21 := yyv1 + yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 136) + if yyrt1 { + if yyrl1 <= cap(yyv1) { + yyv1 = yyv1[:yyrl1] + } else { + yyv1 = make([]LargeStruct, yyrl1) + } + } else { + yyv1 = make([]LargeStruct, yyrl1) + } + yyc1 = true + yyrr1 = len(yyv1) + if yyrg1 { + copy(yyv1, yyv21) + } + } else if yyl1 != len(yyv1) { + yyv1 = yyv1[:yyl1] + yyc1 = true + } + yyj1 := 0 + for ; yyj1 < yyrr1; yyj1++ { + yyh1.ElemContainerState(yyj1) + if r.TryDecodeAsNil() { + yyv1[yyj1] = LargeStruct{} + } else { + yyv2 := &yyv1[yyj1] + yyv2.CodecDecodeSelf(d) + } + + } + if yyrt1 { + for ; yyj1 < yyl1; yyj1++ { + yyv1 = append(yyv1, LargeStruct{}) + yyh1.ElemContainerState(yyj1) + if r.TryDecodeAsNil() { + yyv1[yyj1] = LargeStruct{} + } else { + yyv3 := &yyv1[yyj1] + yyv3.CodecDecodeSelf(d) + } + + } + } + + } else { + yyj1 := 0 + for ; !r.CheckBreak(); yyj1++ { + + if yyj1 >= len(yyv1) { + yyv1 = append(yyv1, LargeStruct{}) // var yyz1 LargeStruct + yyc1 = true + } + yyh1.ElemContainerState(yyj1) + if yyj1 < len(yyv1) { + if r.TryDecodeAsNil() { + yyv1[yyj1] = LargeStruct{} + } else { + yyv4 := &yyv1[yyj1] + yyv4.CodecDecodeSelf(d) + } + + } else { + z.DecSwallow() + } + + } + if yyj1 < len(yyv1) { + yyv1 = yyv1[:yyj1] + yyc1 = true + } else if yyj1 == 0 && yyv1 == nil { + yyv1 = []LargeStruct{} + yyc1 = true + } + } + yyh1.End() + if yyc1 { + *v = yyv1 + } +} diff --git a/vendor/github.com/mailru/easyjson/benchmark/data_ffjson.go b/vendor/github.com/mailru/easyjson/benchmark/data_ffjson.go new file mode 100644 index 000000000..9f000d3ad --- /dev/null +++ b/vendor/github.com/mailru/easyjson/benchmark/data_ffjson.go @@ -0,0 +1,6723 @@ +// +build use_ffjson + +// DO NOT EDIT! +// Code generated by ffjson <https://github.com/pquerna/ffjson> +// source: .root/src/github.com/mailru/easyjson/benchmark/data.go +// DO NOT EDIT! + +package benchmark + +import ( + "bytes" + "errors" + "fmt" + fflib "github.com/pquerna/ffjson/fflib/v1" +) + +func (mj *Entities) MarshalJSON() ([]byte, error) { + var buf fflib.Buffer + if mj == nil { + buf.WriteString("null") + return buf.Bytes(), nil + } + err := mj.MarshalJSONBuf(&buf) + if err != nil { + return nil, err + } + return buf.Bytes(), nil +} +func (mj *Entities) MarshalJSONBuf(buf fflib.EncodingBuffer) error { + if mj == nil { + buf.WriteString("null") + return nil + } + var err error + var obj []byte + _ = obj + _ = err + buf.WriteString(`{"hashtags":`) + if mj.Hashtags != nil { + buf.WriteString(`[`) + for i, v := range mj.Hashtags { + if i != 0 { + buf.WriteString(`,`) + } + + { + + err = v.MarshalJSONBuf(buf) + if err != nil { + return err + } + + } + } + buf.WriteString(`]`) + } else { + buf.WriteString(`null`) + } + buf.WriteString(`,"urls":`) + if mj.Urls != nil { + buf.WriteString(`[`) + for i, v := range mj.Urls { + if i != 0 { + buf.WriteString(`,`) + } + if v != nil { + fflib.WriteJsonString(buf, string(*v)) + } else { + buf.WriteString(`null`) + } + } + buf.WriteString(`]`) + } else { + buf.WriteString(`null`) + } + buf.WriteString(`,"user_mentions":`) + if mj.UserMentions != nil { + buf.WriteString(`[`) + for i, v := range mj.UserMentions { + if i != 0 { + buf.WriteString(`,`) + } + if v != nil { + fflib.WriteJsonString(buf, string(*v)) + } else { + buf.WriteString(`null`) + } + } + buf.WriteString(`]`) + } else { + buf.WriteString(`null`) + } + buf.WriteByte('}') + return nil +} + +const ( + ffj_t_Entitiesbase = iota + ffj_t_Entitiesno_such_key + + ffj_t_Entities_Hashtags + + ffj_t_Entities_Urls + + ffj_t_Entities_UserMentions +) + +var ffj_key_Entities_Hashtags = []byte("hashtags") + +var ffj_key_Entities_Urls = []byte("urls") + +var ffj_key_Entities_UserMentions = []byte("user_mentions") + +func (uj *Entities) UnmarshalJSON(input []byte) error { + fs := fflib.NewFFLexer(input) + return uj.UnmarshalJSONFFLexer(fs, fflib.FFParse_map_start) +} + +func (uj *Entities) UnmarshalJSONFFLexer(fs *fflib.FFLexer, state fflib.FFParseState) error { + var err error = nil + currentKey := ffj_t_Entitiesbase + _ = currentKey + tok := fflib.FFTok_init + wantedTok := fflib.FFTok_init + +mainparse: + for { + tok = fs.Scan() + // println(fmt.Sprintf("debug: tok: %v state: %v", tok, state)) + if tok == fflib.FFTok_error { + goto tokerror + } + + switch state { + + case fflib.FFParse_map_start: + if tok != fflib.FFTok_left_bracket { + wantedTok = fflib.FFTok_left_bracket + goto wrongtokenerror + } + state = fflib.FFParse_want_key + continue + + case fflib.FFParse_after_value: + if tok == fflib.FFTok_comma { + state = fflib.FFParse_want_key + } else if tok == fflib.FFTok_right_bracket { + goto done + } else { + wantedTok = fflib.FFTok_comma + goto wrongtokenerror + } + + case fflib.FFParse_want_key: + // json {} ended. goto exit. woo. + if tok == fflib.FFTok_right_bracket { + goto done + } + if tok != fflib.FFTok_string { + wantedTok = fflib.FFTok_string + goto wrongtokenerror + } + + kn := fs.Output.Bytes() + if len(kn) <= 0 { + // "" case. hrm. + currentKey = ffj_t_Entitiesno_such_key + state = fflib.FFParse_want_colon + goto mainparse + } else { + switch kn[0] { + + case 'h': + + if bytes.Equal(ffj_key_Entities_Hashtags, kn) { + currentKey = ffj_t_Entities_Hashtags + state = fflib.FFParse_want_colon + goto mainparse + } + + case 'u': + + if bytes.Equal(ffj_key_Entities_Urls, kn) { + currentKey = ffj_t_Entities_Urls + state = fflib.FFParse_want_colon + goto mainparse + + } else if bytes.Equal(ffj_key_Entities_UserMentions, kn) { + currentKey = ffj_t_Entities_UserMentions + state = fflib.FFParse_want_colon + goto mainparse + } + + } + + if fflib.EqualFoldRight(ffj_key_Entities_UserMentions, kn) { + currentKey = ffj_t_Entities_UserMentions + state = fflib.FFParse_want_colon + goto mainparse + } + + if fflib.EqualFoldRight(ffj_key_Entities_Urls, kn) { + currentKey = ffj_t_Entities_Urls + state = fflib.FFParse_want_colon + goto mainparse + } + + if fflib.EqualFoldRight(ffj_key_Entities_Hashtags, kn) { + currentKey = ffj_t_Entities_Hashtags + state = fflib.FFParse_want_colon + goto mainparse + } + + currentKey = ffj_t_Entitiesno_such_key + state = fflib.FFParse_want_colon + goto mainparse + } + + case fflib.FFParse_want_colon: + if tok != fflib.FFTok_colon { + wantedTok = fflib.FFTok_colon + goto wrongtokenerror + } + state = fflib.FFParse_want_value + continue + case fflib.FFParse_want_value: + + if tok == fflib.FFTok_left_brace || tok == fflib.FFTok_left_bracket || tok == fflib.FFTok_integer || tok == fflib.FFTok_double || tok == fflib.FFTok_string || tok == fflib.FFTok_bool || tok == fflib.FFTok_null { + switch currentKey { + + case ffj_t_Entities_Hashtags: + goto handle_Hashtags + + case ffj_t_Entities_Urls: + goto handle_Urls + + case ffj_t_Entities_UserMentions: + goto handle_UserMentions + + case ffj_t_Entitiesno_such_key: + err = fs.SkipField(tok) + if err != nil { + return fs.WrapErr(err) + } + state = fflib.FFParse_after_value + goto mainparse + } + } else { + goto wantedvalue + } + } + } + +handle_Hashtags: + + /* handler: uj.Hashtags type=[]benchmark.Hashtag kind=slice quoted=false*/ + + { + + { + if tok != fflib.FFTok_left_brace && tok != fflib.FFTok_null { + return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for ", tok)) + } + } + + if tok == fflib.FFTok_null { + uj.Hashtags = nil + } else { + + uj.Hashtags = make([]Hashtag, 0) + + wantVal := true + + for { + + var tmp_uj__Hashtags Hashtag + + tok = fs.Scan() + if tok == fflib.FFTok_error { + goto tokerror + } + if tok == fflib.FFTok_right_brace { + break + } + + if tok == fflib.FFTok_comma { + if wantVal == true { + // TODO(pquerna): this isn't an ideal error message, this handles + // things like [,,,] as an array value. + return fs.WrapErr(fmt.Errorf("wanted value token, but got token: %v", tok)) + } + continue + } else { + wantVal = true + } + + /* handler: tmp_uj__Hashtags type=benchmark.Hashtag kind=struct quoted=false*/ + + { + if tok == fflib.FFTok_null { + + state = fflib.FFParse_after_value + goto mainparse + } + + err = tmp_uj__Hashtags.UnmarshalJSONFFLexer(fs, fflib.FFParse_want_key) + if err != nil { + return err + } + state = fflib.FFParse_after_value + } + + uj.Hashtags = append(uj.Hashtags, tmp_uj__Hashtags) + wantVal = false + } + } + } + + state = fflib.FFParse_after_value + goto mainparse + +handle_Urls: + + /* handler: uj.Urls type=[]*string kind=slice quoted=false*/ + + { + + { + if tok != fflib.FFTok_left_brace && tok != fflib.FFTok_null { + return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for ", tok)) + } + } + + if tok == fflib.FFTok_null { + uj.Urls = nil + } else { + + uj.Urls = make([]*string, 0) + + wantVal := true + + for { + + var tmp_uj__Urls *string + + tok = fs.Scan() + if tok == fflib.FFTok_error { + goto tokerror + } + if tok == fflib.FFTok_right_brace { + break + } + + if tok == fflib.FFTok_comma { + if wantVal == true { + // TODO(pquerna): this isn't an ideal error message, this handles + // things like [,,,] as an array value. + return fs.WrapErr(fmt.Errorf("wanted value token, but got token: %v", tok)) + } + continue + } else { + wantVal = true + } + + /* handler: tmp_uj__Urls type=*string kind=ptr quoted=false*/ + + { + + if tok == fflib.FFTok_null { + tmp_uj__Urls = nil + } else { + if tmp_uj__Urls == nil { + tmp_uj__Urls = new(string) + } + + /* handler: tmp_uj__Urls type=string kind=string quoted=false*/ + + { + + { + if tok != fflib.FFTok_string && tok != fflib.FFTok_null { + return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for string", tok)) + } + } + + if tok == fflib.FFTok_null { + + tmp_uj__Urls = nil + + } else { + + var tval string + outBuf := fs.Output.Bytes() + + tval = string(string(outBuf)) + tmp_uj__Urls = &tval + + } + } + + } + } + + uj.Urls = append(uj.Urls, tmp_uj__Urls) + wantVal = false + } + } + } + + state = fflib.FFParse_after_value + goto mainparse + +handle_UserMentions: + + /* handler: uj.UserMentions type=[]*string kind=slice quoted=false*/ + + { + + { + if tok != fflib.FFTok_left_brace && tok != fflib.FFTok_null { + return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for ", tok)) + } + } + + if tok == fflib.FFTok_null { + uj.UserMentions = nil + } else { + + uj.UserMentions = make([]*string, 0) + + wantVal := true + + for { + + var tmp_uj__UserMentions *string + + tok = fs.Scan() + if tok == fflib.FFTok_error { + goto tokerror + } + if tok == fflib.FFTok_right_brace { + break + } + + if tok == fflib.FFTok_comma { + if wantVal == true { + // TODO(pquerna): this isn't an ideal error message, this handles + // things like [,,,] as an array value. + return fs.WrapErr(fmt.Errorf("wanted value token, but got token: %v", tok)) + } + continue + } else { + wantVal = true + } + + /* handler: tmp_uj__UserMentions type=*string kind=ptr quoted=false*/ + + { + + if tok == fflib.FFTok_null { + tmp_uj__UserMentions = nil + } else { + if tmp_uj__UserMentions == nil { + tmp_uj__UserMentions = new(string) + } + + /* handler: tmp_uj__UserMentions type=string kind=string quoted=false*/ + + { + + { + if tok != fflib.FFTok_string && tok != fflib.FFTok_null { + return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for string", tok)) + } + } + + if tok == fflib.FFTok_null { + + tmp_uj__UserMentions = nil + + } else { + + var tval string + outBuf := fs.Output.Bytes() + + tval = string(string(outBuf)) + tmp_uj__UserMentions = &tval + + } + } + + } + } + + uj.UserMentions = append(uj.UserMentions, tmp_uj__UserMentions) + wantVal = false + } + } + } + + state = fflib.FFParse_after_value + goto mainparse + +wantedvalue: + return fs.WrapErr(fmt.Errorf("wanted value token, but got token: %v", tok)) +wrongtokenerror: + return fs.WrapErr(fmt.Errorf("ffjson: wanted token: %v, but got token: %v output=%s", wantedTok, tok, fs.Output.String())) +tokerror: + if fs.BigError != nil { + return fs.WrapErr(fs.BigError) + } + err = fs.Error.ToError() + if err != nil { + return fs.WrapErr(err) + } + panic("ffjson-generated: unreachable, please report bug.") +done: + return nil +} + +func (mj *Hashtag) MarshalJSON() ([]byte, error) { + var buf fflib.Buffer + if mj == nil { + buf.WriteString("null") + return buf.Bytes(), nil + } + err := mj.MarshalJSONBuf(&buf) + if err != nil { + return nil, err + } + return buf.Bytes(), nil +} +func (mj *Hashtag) MarshalJSONBuf(buf fflib.EncodingBuffer) error { + if mj == nil { + buf.WriteString("null") + return nil + } + var err error + var obj []byte + _ = obj + _ = err + buf.WriteString(`{"indices":`) + if mj.Indices != nil { + buf.WriteString(`[`) + for i, v := range mj.Indices { + if i != 0 { + buf.WriteString(`,`) + } + fflib.FormatBits2(buf, uint64(v), 10, v < 0) + } + buf.WriteString(`]`) + } else { + buf.WriteString(`null`) + } + buf.WriteString(`,"text":`) + fflib.WriteJsonString(buf, string(mj.Text)) + buf.WriteByte('}') + return nil +} + +const ( + ffj_t_Hashtagbase = iota + ffj_t_Hashtagno_such_key + + ffj_t_Hashtag_Indices + + ffj_t_Hashtag_Text +) + +var ffj_key_Hashtag_Indices = []byte("indices") + +var ffj_key_Hashtag_Text = []byte("text") + +func (uj *Hashtag) UnmarshalJSON(input []byte) error { + fs := fflib.NewFFLexer(input) + return uj.UnmarshalJSONFFLexer(fs, fflib.FFParse_map_start) +} + +func (uj *Hashtag) UnmarshalJSONFFLexer(fs *fflib.FFLexer, state fflib.FFParseState) error { + var err error = nil + currentKey := ffj_t_Hashtagbase + _ = currentKey + tok := fflib.FFTok_init + wantedTok := fflib.FFTok_init + +mainparse: + for { + tok = fs.Scan() + // println(fmt.Sprintf("debug: tok: %v state: %v", tok, state)) + if tok == fflib.FFTok_error { + goto tokerror + } + + switch state { + + case fflib.FFParse_map_start: + if tok != fflib.FFTok_left_bracket { + wantedTok = fflib.FFTok_left_bracket + goto wrongtokenerror + } + state = fflib.FFParse_want_key + continue + + case fflib.FFParse_after_value: + if tok == fflib.FFTok_comma { + state = fflib.FFParse_want_key + } else if tok == fflib.FFTok_right_bracket { + goto done + } else { + wantedTok = fflib.FFTok_comma + goto wrongtokenerror + } + + case fflib.FFParse_want_key: + // json {} ended. goto exit. woo. + if tok == fflib.FFTok_right_bracket { + goto done + } + if tok != fflib.FFTok_string { + wantedTok = fflib.FFTok_string + goto wrongtokenerror + } + + kn := fs.Output.Bytes() + if len(kn) <= 0 { + // "" case. hrm. + currentKey = ffj_t_Hashtagno_such_key + state = fflib.FFParse_want_colon + goto mainparse + } else { + switch kn[0] { + + case 'i': + + if bytes.Equal(ffj_key_Hashtag_Indices, kn) { + currentKey = ffj_t_Hashtag_Indices + state = fflib.FFParse_want_colon + goto mainparse + } + + case 't': + + if bytes.Equal(ffj_key_Hashtag_Text, kn) { + currentKey = ffj_t_Hashtag_Text + state = fflib.FFParse_want_colon + goto mainparse + } + + } + + if fflib.SimpleLetterEqualFold(ffj_key_Hashtag_Text, kn) { + currentKey = ffj_t_Hashtag_Text + state = fflib.FFParse_want_colon + goto mainparse + } + + if fflib.EqualFoldRight(ffj_key_Hashtag_Indices, kn) { + currentKey = ffj_t_Hashtag_Indices + state = fflib.FFParse_want_colon + goto mainparse + } + + currentKey = ffj_t_Hashtagno_such_key + state = fflib.FFParse_want_colon + goto mainparse + } + + case fflib.FFParse_want_colon: + if tok != fflib.FFTok_colon { + wantedTok = fflib.FFTok_colon + goto wrongtokenerror + } + state = fflib.FFParse_want_value + continue + case fflib.FFParse_want_value: + + if tok == fflib.FFTok_left_brace || tok == fflib.FFTok_left_bracket || tok == fflib.FFTok_integer || tok == fflib.FFTok_double || tok == fflib.FFTok_string || tok == fflib.FFTok_bool || tok == fflib.FFTok_null { + switch currentKey { + + case ffj_t_Hashtag_Indices: + goto handle_Indices + + case ffj_t_Hashtag_Text: + goto handle_Text + + case ffj_t_Hashtagno_such_key: + err = fs.SkipField(tok) + if err != nil { + return fs.WrapErr(err) + } + state = fflib.FFParse_after_value + goto mainparse + } + } else { + goto wantedvalue + } + } + } + +handle_Indices: + + /* handler: uj.Indices type=[]int kind=slice quoted=false*/ + + { + + { + if tok != fflib.FFTok_left_brace && tok != fflib.FFTok_null { + return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for ", tok)) + } + } + + if tok == fflib.FFTok_null { + uj.Indices = nil + } else { + + uj.Indices = make([]int, 0) + + wantVal := true + + for { + + var tmp_uj__Indices int + + tok = fs.Scan() + if tok == fflib.FFTok_error { + goto tokerror + } + if tok == fflib.FFTok_right_brace { + break + } + + if tok == fflib.FFTok_comma { + if wantVal == true { + // TODO(pquerna): this isn't an ideal error message, this handles + // things like [,,,] as an array value. + return fs.WrapErr(fmt.Errorf("wanted value token, but got token: %v", tok)) + } + continue + } else { + wantVal = true + } + + /* handler: tmp_uj__Indices type=int kind=int quoted=false*/ + + { + if tok != fflib.FFTok_integer && tok != fflib.FFTok_null { + return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for int", tok)) + } + } + + { + + if tok == fflib.FFTok_null { + + } else { + + tval, err := fflib.ParseInt(fs.Output.Bytes(), 10, 64) + + if err != nil { + return fs.WrapErr(err) + } + + tmp_uj__Indices = int(tval) + + } + } + + uj.Indices = append(uj.Indices, tmp_uj__Indices) + wantVal = false + } + } + } + + state = fflib.FFParse_after_value + goto mainparse + +handle_Text: + + /* handler: uj.Text type=string kind=string quoted=false*/ + + { + + { + if tok != fflib.FFTok_string && tok != fflib.FFTok_null { + return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for string", tok)) + } + } + + if tok == fflib.FFTok_null { + + } else { + + outBuf := fs.Output.Bytes() + + uj.Text = string(string(outBuf)) + + } + } + + state = fflib.FFParse_after_value + goto mainparse + +wantedvalue: + return fs.WrapErr(fmt.Errorf("wanted value token, but got token: %v", tok)) +wrongtokenerror: + return fs.WrapErr(fmt.Errorf("ffjson: wanted token: %v, but got token: %v output=%s", wantedTok, tok, fs.Output.String())) +tokerror: + if fs.BigError != nil { + return fs.WrapErr(fs.BigError) + } + err = fs.Error.ToError() + if err != nil { + return fs.WrapErr(err) + } + panic("ffjson-generated: unreachable, please report bug.") +done: + return nil +} + +func (mj *LargeStruct) MarshalJSON() ([]byte, error) { + var buf fflib.Buffer + if mj == nil { + buf.WriteString("null") + return buf.Bytes(), nil + } + err := mj.MarshalJSONBuf(&buf) + if err != nil { + return nil, err + } + return buf.Bytes(), nil +} +func (mj *LargeStruct) MarshalJSONBuf(buf fflib.EncodingBuffer) error { + if mj == nil { + buf.WriteString("null") + return nil + } + var err error + var obj []byte + _ = obj + _ = err + buf.WriteString(`{"search_metadata":`) + + { + + err = mj.SearchMetadata.MarshalJSONBuf(buf) + if err != nil { + return err + } + + } + buf.WriteString(`,"statuses":`) + if mj.Statuses != nil { + buf.WriteString(`[`) + for i, v := range mj.Statuses { + if i != 0 { + buf.WriteString(`,`) + } + + { + + err = v.MarshalJSONBuf(buf) + if err != nil { + return err + } + + } + } + buf.WriteString(`]`) + } else { + buf.WriteString(`null`) + } + buf.WriteByte('}') + return nil +} + +const ( + ffj_t_LargeStructbase = iota + ffj_t_LargeStructno_such_key + + ffj_t_LargeStruct_SearchMetadata + + ffj_t_LargeStruct_Statuses +) + +var ffj_key_LargeStruct_SearchMetadata = []byte("search_metadata") + +var ffj_key_LargeStruct_Statuses = []byte("statuses") + +func (uj *LargeStruct) UnmarshalJSON(input []byte) error { + fs := fflib.NewFFLexer(input) + return uj.UnmarshalJSONFFLexer(fs, fflib.FFParse_map_start) +} + +func (uj *LargeStruct) UnmarshalJSONFFLexer(fs *fflib.FFLexer, state fflib.FFParseState) error { + var err error = nil + currentKey := ffj_t_LargeStructbase + _ = currentKey + tok := fflib.FFTok_init + wantedTok := fflib.FFTok_init + +mainparse: + for { + tok = fs.Scan() + // println(fmt.Sprintf("debug: tok: %v state: %v", tok, state)) + if tok == fflib.FFTok_error { + goto tokerror + } + + switch state { + + case fflib.FFParse_map_start: + if tok != fflib.FFTok_left_bracket { + wantedTok = fflib.FFTok_left_bracket + goto wrongtokenerror + } + state = fflib.FFParse_want_key + continue + + case fflib.FFParse_after_value: + if tok == fflib.FFTok_comma { + state = fflib.FFParse_want_key + } else if tok == fflib.FFTok_right_bracket { + goto done + } else { + wantedTok = fflib.FFTok_comma + goto wrongtokenerror + } + + case fflib.FFParse_want_key: + // json {} ended. goto exit. woo. + if tok == fflib.FFTok_right_bracket { + goto done + } + if tok != fflib.FFTok_string { + wantedTok = fflib.FFTok_string + goto wrongtokenerror + } + + kn := fs.Output.Bytes() + if len(kn) <= 0 { + // "" case. hrm. + currentKey = ffj_t_LargeStructno_such_key + state = fflib.FFParse_want_colon + goto mainparse + } else { + switch kn[0] { + + case 's': + + if bytes.Equal(ffj_key_LargeStruct_SearchMetadata, kn) { + currentKey = ffj_t_LargeStruct_SearchMetadata + state = fflib.FFParse_want_colon + goto mainparse + + } else if bytes.Equal(ffj_key_LargeStruct_Statuses, kn) { + currentKey = ffj_t_LargeStruct_Statuses + state = fflib.FFParse_want_colon + goto mainparse + } + + } + + if fflib.EqualFoldRight(ffj_key_LargeStruct_Statuses, kn) { + currentKey = ffj_t_LargeStruct_Statuses + state = fflib.FFParse_want_colon + goto mainparse + } + + if fflib.EqualFoldRight(ffj_key_LargeStruct_SearchMetadata, kn) { + currentKey = ffj_t_LargeStruct_SearchMetadata + state = fflib.FFParse_want_colon + goto mainparse + } + + currentKey = ffj_t_LargeStructno_such_key + state = fflib.FFParse_want_colon + goto mainparse + } + + case fflib.FFParse_want_colon: + if tok != fflib.FFTok_colon { + wantedTok = fflib.FFTok_colon + goto wrongtokenerror + } + state = fflib.FFParse_want_value + continue + case fflib.FFParse_want_value: + + if tok == fflib.FFTok_left_brace || tok == fflib.FFTok_left_bracket || tok == fflib.FFTok_integer || tok == fflib.FFTok_double || tok == fflib.FFTok_string || tok == fflib.FFTok_bool || tok == fflib.FFTok_null { + switch currentKey { + + case ffj_t_LargeStruct_SearchMetadata: + goto handle_SearchMetadata + + case ffj_t_LargeStruct_Statuses: + goto handle_Statuses + + case ffj_t_LargeStructno_such_key: + err = fs.SkipField(tok) + if err != nil { + return fs.WrapErr(err) + } + state = fflib.FFParse_after_value + goto mainparse + } + } else { + goto wantedvalue + } + } + } + +handle_SearchMetadata: + + /* handler: uj.SearchMetadata type=benchmark.SearchMetadata kind=struct quoted=false*/ + + { + if tok == fflib.FFTok_null { + + state = fflib.FFParse_after_value + goto mainparse + } + + err = uj.SearchMetadata.UnmarshalJSONFFLexer(fs, fflib.FFParse_want_key) + if err != nil { + return err + } + state = fflib.FFParse_after_value + } + + state = fflib.FFParse_after_value + goto mainparse + +handle_Statuses: + + /* handler: uj.Statuses type=[]benchmark.Status kind=slice quoted=false*/ + + { + + { + if tok != fflib.FFTok_left_brace && tok != fflib.FFTok_null { + return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for ", tok)) + } + } + + if tok == fflib.FFTok_null { + uj.Statuses = nil + } else { + + uj.Statuses = make([]Status, 0) + + wantVal := true + + for { + + var tmp_uj__Statuses Status + + tok = fs.Scan() + if tok == fflib.FFTok_error { + goto tokerror + } + if tok == fflib.FFTok_right_brace { + break + } + + if tok == fflib.FFTok_comma { + if wantVal == true { + // TODO(pquerna): this isn't an ideal error message, this handles + // things like [,,,] as an array value. + return fs.WrapErr(fmt.Errorf("wanted value token, but got token: %v", tok)) + } + continue + } else { + wantVal = true + } + + /* handler: tmp_uj__Statuses type=benchmark.Status kind=struct quoted=false*/ + + { + if tok == fflib.FFTok_null { + + state = fflib.FFParse_after_value + goto mainparse + } + + err = tmp_uj__Statuses.UnmarshalJSONFFLexer(fs, fflib.FFParse_want_key) + if err != nil { + return err + } + state = fflib.FFParse_after_value + } + + uj.Statuses = append(uj.Statuses, tmp_uj__Statuses) + wantVal = false + } + } + } + + state = fflib.FFParse_after_value + goto mainparse + +wantedvalue: + return fs.WrapErr(fmt.Errorf("wanted value token, but got token: %v", tok)) +wrongtokenerror: + return fs.WrapErr(fmt.Errorf("ffjson: wanted token: %v, but got token: %v output=%s", wantedTok, tok, fs.Output.String())) +tokerror: + if fs.BigError != nil { + return fs.WrapErr(fs.BigError) + } + err = fs.Error.ToError() + if err != nil { + return fs.WrapErr(err) + } + panic("ffjson-generated: unreachable, please report bug.") +done: + return nil +} + +func (mj *SearchMetadata) MarshalJSON() ([]byte, error) { + var buf fflib.Buffer + if mj == nil { + buf.WriteString("null") + return buf.Bytes(), nil + } + err := mj.MarshalJSONBuf(&buf) + if err != nil { + return nil, err + } + return buf.Bytes(), nil +} +func (mj *SearchMetadata) MarshalJSONBuf(buf fflib.EncodingBuffer) error { + if mj == nil { + buf.WriteString("null") + return nil + } + var err error + var obj []byte + _ = obj + _ = err + buf.WriteString(`{"completed_in":`) + fflib.AppendFloat(buf, float64(mj.CompletedIn), 'g', -1, 64) + buf.WriteString(`,"count":`) + fflib.FormatBits2(buf, uint64(mj.Count), 10, mj.Count < 0) + buf.WriteString(`,"max_id":`) + fflib.FormatBits2(buf, uint64(mj.MaxID), 10, mj.MaxID < 0) + buf.WriteString(`,"max_id_str":`) + fflib.WriteJsonString(buf, string(mj.MaxIDStr)) + buf.WriteString(`,"next_results":`) + fflib.WriteJsonString(buf, string(mj.NextResults)) + buf.WriteString(`,"query":`) + fflib.WriteJsonString(buf, string(mj.Query)) + buf.WriteString(`,"refresh_url":`) + fflib.WriteJsonString(buf, string(mj.RefreshURL)) + buf.WriteString(`,"since_id":`) + fflib.FormatBits2(buf, uint64(mj.SinceID), 10, mj.SinceID < 0) + buf.WriteString(`,"since_id_str":`) + fflib.WriteJsonString(buf, string(mj.SinceIDStr)) + buf.WriteByte('}') + return nil +} + +const ( + ffj_t_SearchMetadatabase = iota + ffj_t_SearchMetadatano_such_key + + ffj_t_SearchMetadata_CompletedIn + + ffj_t_SearchMetadata_Count + + ffj_t_SearchMetadata_MaxID + + ffj_t_SearchMetadata_MaxIDStr + + ffj_t_SearchMetadata_NextResults + + ffj_t_SearchMetadata_Query + + ffj_t_SearchMetadata_RefreshURL + + ffj_t_SearchMetadata_SinceID + + ffj_t_SearchMetadata_SinceIDStr +) + +var ffj_key_SearchMetadata_CompletedIn = []byte("completed_in") + +var ffj_key_SearchMetadata_Count = []byte("count") + +var ffj_key_SearchMetadata_MaxID = []byte("max_id") + +var ffj_key_SearchMetadata_MaxIDStr = []byte("max_id_str") + +var ffj_key_SearchMetadata_NextResults = []byte("next_results") + +var ffj_key_SearchMetadata_Query = []byte("query") + +var ffj_key_SearchMetadata_RefreshURL = []byte("refresh_url") + +var ffj_key_SearchMetadata_SinceID = []byte("since_id") + +var ffj_key_SearchMetadata_SinceIDStr = []byte("since_id_str") + +func (uj *SearchMetadata) UnmarshalJSON(input []byte) error { + fs := fflib.NewFFLexer(input) + return uj.UnmarshalJSONFFLexer(fs, fflib.FFParse_map_start) +} + +func (uj *SearchMetadata) UnmarshalJSONFFLexer(fs *fflib.FFLexer, state fflib.FFParseState) error { + var err error = nil + currentKey := ffj_t_SearchMetadatabase + _ = currentKey + tok := fflib.FFTok_init + wantedTok := fflib.FFTok_init + +mainparse: + for { + tok = fs.Scan() + // println(fmt.Sprintf("debug: tok: %v state: %v", tok, state)) + if tok == fflib.FFTok_error { + goto tokerror + } + + switch state { + + case fflib.FFParse_map_start: + if tok != fflib.FFTok_left_bracket { + wantedTok = fflib.FFTok_left_bracket + goto wrongtokenerror + } + state = fflib.FFParse_want_key + continue + + case fflib.FFParse_after_value: + if tok == fflib.FFTok_comma { + state = fflib.FFParse_want_key + } else if tok == fflib.FFTok_right_bracket { + goto done + } else { + wantedTok = fflib.FFTok_comma + goto wrongtokenerror + } + + case fflib.FFParse_want_key: + // json {} ended. goto exit. woo. + if tok == fflib.FFTok_right_bracket { + goto done + } + if tok != fflib.FFTok_string { + wantedTok = fflib.FFTok_string + goto wrongtokenerror + } + + kn := fs.Output.Bytes() + if len(kn) <= 0 { + // "" case. hrm. + currentKey = ffj_t_SearchMetadatano_such_key + state = fflib.FFParse_want_colon + goto mainparse + } else { + switch kn[0] { + + case 'c': + + if bytes.Equal(ffj_key_SearchMetadata_CompletedIn, kn) { + currentKey = ffj_t_SearchMetadata_CompletedIn + state = fflib.FFParse_want_colon + goto mainparse + + } else if bytes.Equal(ffj_key_SearchMetadata_Count, kn) { + currentKey = ffj_t_SearchMetadata_Count + state = fflib.FFParse_want_colon + goto mainparse + } + + case 'm': + + if bytes.Equal(ffj_key_SearchMetadata_MaxID, kn) { + currentKey = ffj_t_SearchMetadata_MaxID + state = fflib.FFParse_want_colon + goto mainparse + + } else if bytes.Equal(ffj_key_SearchMetadata_MaxIDStr, kn) { + currentKey = ffj_t_SearchMetadata_MaxIDStr + state = fflib.FFParse_want_colon + goto mainparse + } + + case 'n': + + if bytes.Equal(ffj_key_SearchMetadata_NextResults, kn) { + currentKey = ffj_t_SearchMetadata_NextResults + state = fflib.FFParse_want_colon + goto mainparse + } + + case 'q': + + if bytes.Equal(ffj_key_SearchMetadata_Query, kn) { + currentKey = ffj_t_SearchMetadata_Query + state = fflib.FFParse_want_colon + goto mainparse + } + + case 'r': + + if bytes.Equal(ffj_key_SearchMetadata_RefreshURL, kn) { + currentKey = ffj_t_SearchMetadata_RefreshURL + state = fflib.FFParse_want_colon + goto mainparse + } + + case 's': + + if bytes.Equal(ffj_key_SearchMetadata_SinceID, kn) { + currentKey = ffj_t_SearchMetadata_SinceID + state = fflib.FFParse_want_colon + goto mainparse + + } else if bytes.Equal(ffj_key_SearchMetadata_SinceIDStr, kn) { + currentKey = ffj_t_SearchMetadata_SinceIDStr + state = fflib.FFParse_want_colon + goto mainparse + } + + } + + if fflib.EqualFoldRight(ffj_key_SearchMetadata_SinceIDStr, kn) { + currentKey = ffj_t_SearchMetadata_SinceIDStr + state = fflib.FFParse_want_colon + goto mainparse + } + + if fflib.EqualFoldRight(ffj_key_SearchMetadata_SinceID, kn) { + currentKey = ffj_t_SearchMetadata_SinceID + state = fflib.FFParse_want_colon + goto mainparse + } + + if fflib.EqualFoldRight(ffj_key_SearchMetadata_RefreshURL, kn) { + currentKey = ffj_t_SearchMetadata_RefreshURL + state = fflib.FFParse_want_colon + goto mainparse + } + + if fflib.SimpleLetterEqualFold(ffj_key_SearchMetadata_Query, kn) { + currentKey = ffj_t_SearchMetadata_Query + state = fflib.FFParse_want_colon + goto mainparse + } + + if fflib.EqualFoldRight(ffj_key_SearchMetadata_NextResults, kn) { + currentKey = ffj_t_SearchMetadata_NextResults + state = fflib.FFParse_want_colon + goto mainparse + } + + if fflib.EqualFoldRight(ffj_key_SearchMetadata_MaxIDStr, kn) { + currentKey = ffj_t_SearchMetadata_MaxIDStr + state = fflib.FFParse_want_colon + goto mainparse + } + + if fflib.AsciiEqualFold(ffj_key_SearchMetadata_MaxID, kn) { + currentKey = ffj_t_SearchMetadata_MaxID + state = fflib.FFParse_want_colon + goto mainparse + } + + if fflib.SimpleLetterEqualFold(ffj_key_SearchMetadata_Count, kn) { + currentKey = ffj_t_SearchMetadata_Count + state = fflib.FFParse_want_colon + goto mainparse + } + + if fflib.AsciiEqualFold(ffj_key_SearchMetadata_CompletedIn, kn) { + currentKey = ffj_t_SearchMetadata_CompletedIn + state = fflib.FFParse_want_colon + goto mainparse + } + + currentKey = ffj_t_SearchMetadatano_such_key + state = fflib.FFParse_want_colon + goto mainparse + } + + case fflib.FFParse_want_colon: + if tok != fflib.FFTok_colon { + wantedTok = fflib.FFTok_colon + goto wrongtokenerror + } + state = fflib.FFParse_want_value + continue + case fflib.FFParse_want_value: + + if tok == fflib.FFTok_left_brace || tok == fflib.FFTok_left_bracket || tok == fflib.FFTok_integer || tok == fflib.FFTok_double || tok == fflib.FFTok_string || tok == fflib.FFTok_bool || tok == fflib.FFTok_null { + switch currentKey { + + case ffj_t_SearchMetadata_CompletedIn: + goto handle_CompletedIn + + case ffj_t_SearchMetadata_Count: + goto handle_Count + + case ffj_t_SearchMetadata_MaxID: + goto handle_MaxID + + case ffj_t_SearchMetadata_MaxIDStr: + goto handle_MaxIDStr + + case ffj_t_SearchMetadata_NextResults: + goto handle_NextResults + + case ffj_t_SearchMetadata_Query: + goto handle_Query + + case ffj_t_SearchMetadata_RefreshURL: + goto handle_RefreshURL + + case ffj_t_SearchMetadata_SinceID: + goto handle_SinceID + + case ffj_t_SearchMetadata_SinceIDStr: + goto handle_SinceIDStr + + case ffj_t_SearchMetadatano_such_key: + err = fs.SkipField(tok) + if err != nil { + return fs.WrapErr(err) + } + state = fflib.FFParse_after_value + goto mainparse + } + } else { + goto wantedvalue + } + } + } + +handle_CompletedIn: + + /* handler: uj.CompletedIn type=float64 kind=float64 quoted=false*/ + + { + if tok != fflib.FFTok_double && tok != fflib.FFTok_integer && tok != fflib.FFTok_null { + return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for float64", tok)) + } + } + + { + + if tok == fflib.FFTok_null { + + } else { + + tval, err := fflib.ParseFloat(fs.Output.Bytes(), 64) + + if err != nil { + return fs.WrapErr(err) + } + + uj.CompletedIn = float64(tval) + + } + } + + state = fflib.FFParse_after_value + goto mainparse + +handle_Count: + + /* handler: uj.Count type=int kind=int quoted=false*/ + + { + if tok != fflib.FFTok_integer && tok != fflib.FFTok_null { + return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for int", tok)) + } + } + + { + + if tok == fflib.FFTok_null { + + } else { + + tval, err := fflib.ParseInt(fs.Output.Bytes(), 10, 64) + + if err != nil { + return fs.WrapErr(err) + } + + uj.Count = int(tval) + + } + } + + state = fflib.FFParse_after_value + goto mainparse + +handle_MaxID: + + /* handler: uj.MaxID type=int kind=int quoted=false*/ + + { + if tok != fflib.FFTok_integer && tok != fflib.FFTok_null { + return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for int", tok)) + } + } + + { + + if tok == fflib.FFTok_null { + + } else { + + tval, err := fflib.ParseInt(fs.Output.Bytes(), 10, 64) + + if err != nil { + return fs.WrapErr(err) + } + + uj.MaxID = int(tval) + + } + } + + state = fflib.FFParse_after_value + goto mainparse + +handle_MaxIDStr: + + /* handler: uj.MaxIDStr type=string kind=string quoted=false*/ + + { + + { + if tok != fflib.FFTok_string && tok != fflib.FFTok_null { + return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for string", tok)) + } + } + + if tok == fflib.FFTok_null { + + } else { + + outBuf := fs.Output.Bytes() + + uj.MaxIDStr = string(string(outBuf)) + + } + } + + state = fflib.FFParse_after_value + goto mainparse + +handle_NextResults: + + /* handler: uj.NextResults type=string kind=string quoted=false*/ + + { + + { + if tok != fflib.FFTok_string && tok != fflib.FFTok_null { + return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for string", tok)) + } + } + + if tok == fflib.FFTok_null { + + } else { + + outBuf := fs.Output.Bytes() + + uj.NextResults = string(string(outBuf)) + + } + } + + state = fflib.FFParse_after_value + goto mainparse + +handle_Query: + + /* handler: uj.Query type=string kind=string quoted=false*/ + + { + + { + if tok != fflib.FFTok_string && tok != fflib.FFTok_null { + return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for string", tok)) + } + } + + if tok == fflib.FFTok_null { + + } else { + + outBuf := fs.Output.Bytes() + + uj.Query = string(string(outBuf)) + + } + } + + state = fflib.FFParse_after_value + goto mainparse + +handle_RefreshURL: + + /* handler: uj.RefreshURL type=string kind=string quoted=false*/ + + { + + { + if tok != fflib.FFTok_string && tok != fflib.FFTok_null { + return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for string", tok)) + } + } + + if tok == fflib.FFTok_null { + + } else { + + outBuf := fs.Output.Bytes() + + uj.RefreshURL = string(string(outBuf)) + + } + } + + state = fflib.FFParse_after_value + goto mainparse + +handle_SinceID: + + /* handler: uj.SinceID type=int kind=int quoted=false*/ + + { + if tok != fflib.FFTok_integer && tok != fflib.FFTok_null { + return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for int", tok)) + } + } + + { + + if tok == fflib.FFTok_null { + + } else { + + tval, err := fflib.ParseInt(fs.Output.Bytes(), 10, 64) + + if err != nil { + return fs.WrapErr(err) + } + + uj.SinceID = int(tval) + + } + } + + state = fflib.FFParse_after_value + goto mainparse + +handle_SinceIDStr: + + /* handler: uj.SinceIDStr type=string kind=string quoted=false*/ + + { + + { + if tok != fflib.FFTok_string && tok != fflib.FFTok_null { + return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for string", tok)) + } + } + + if tok == fflib.FFTok_null { + + } else { + + outBuf := fs.Output.Bytes() + + uj.SinceIDStr = string(string(outBuf)) + + } + } + + state = fflib.FFParse_after_value + goto mainparse + +wantedvalue: + return fs.WrapErr(fmt.Errorf("wanted value token, but got token: %v", tok)) +wrongtokenerror: + return fs.WrapErr(fmt.Errorf("ffjson: wanted token: %v, but got token: %v output=%s", wantedTok, tok, fs.Output.String())) +tokerror: + if fs.BigError != nil { + return fs.WrapErr(fs.BigError) + } + err = fs.Error.ToError() + if err != nil { + return fs.WrapErr(err) + } + panic("ffjson-generated: unreachable, please report bug.") +done: + return nil +} + +func (mj *Status) MarshalJSON() ([]byte, error) { + var buf fflib.Buffer + if mj == nil { + buf.WriteString("null") + return buf.Bytes(), nil + } + err := mj.MarshalJSONBuf(&buf) + if err != nil { + return nil, err + } + return buf.Bytes(), nil +} +func (mj *Status) MarshalJSONBuf(buf fflib.EncodingBuffer) error { + if mj == nil { + buf.WriteString("null") + return nil + } + var err error + var obj []byte + _ = obj + _ = err + if mj.Contributors != nil { + buf.WriteString(`{"contributors":`) + fflib.WriteJsonString(buf, string(*mj.Contributors)) + } else { + buf.WriteString(`{"contributors":null`) + } + if mj.Coordinates != nil { + buf.WriteString(`,"coordinates":`) + fflib.WriteJsonString(buf, string(*mj.Coordinates)) + } else { + buf.WriteString(`,"coordinates":null`) + } + buf.WriteString(`,"created_at":`) + fflib.WriteJsonString(buf, string(mj.CreatedAt)) + buf.WriteString(`,"entities":`) + + { + + err = mj.Entities.MarshalJSONBuf(buf) + if err != nil { + return err + } + + } + if mj.Favorited { + buf.WriteString(`,"favorited":true`) + } else { + buf.WriteString(`,"favorited":false`) + } + if mj.Geo != nil { + buf.WriteString(`,"geo":`) + fflib.WriteJsonString(buf, string(*mj.Geo)) + } else { + buf.WriteString(`,"geo":null`) + } + buf.WriteString(`,"id":`) + fflib.FormatBits2(buf, uint64(mj.ID), 10, mj.ID < 0) + buf.WriteString(`,"id_str":`) + fflib.WriteJsonString(buf, string(mj.IDStr)) + if mj.InReplyToScreenName != nil { + buf.WriteString(`,"in_reply_to_screen_name":`) + fflib.WriteJsonString(buf, string(*mj.InReplyToScreenName)) + } else { + buf.WriteString(`,"in_reply_to_screen_name":null`) + } + if mj.InReplyToStatusID != nil { + buf.WriteString(`,"in_reply_to_status_id":`) + fflib.WriteJsonString(buf, string(*mj.InReplyToStatusID)) + } else { + buf.WriteString(`,"in_reply_to_status_id":null`) + } + if mj.InReplyToStatusIDStr != nil { + buf.WriteString(`,"in_reply_to_status_id_str":`) + fflib.WriteJsonString(buf, string(*mj.InReplyToStatusIDStr)) + } else { + buf.WriteString(`,"in_reply_to_status_id_str":null`) + } + if mj.InReplyToUserID != nil { + buf.WriteString(`,"in_reply_to_user_id":`) + fflib.WriteJsonString(buf, string(*mj.InReplyToUserID)) + } else { + buf.WriteString(`,"in_reply_to_user_id":null`) + } + if mj.InReplyToUserIDStr != nil { + buf.WriteString(`,"in_reply_to_user_id_str":`) + fflib.WriteJsonString(buf, string(*mj.InReplyToUserIDStr)) + } else { + buf.WriteString(`,"in_reply_to_user_id_str":null`) + } + buf.WriteString(`,"metadata":`) + + { + + err = mj.Metadata.MarshalJSONBuf(buf) + if err != nil { + return err + } + + } + if mj.Place != nil { + buf.WriteString(`,"place":`) + fflib.WriteJsonString(buf, string(*mj.Place)) + } else { + buf.WriteString(`,"place":null`) + } + buf.WriteString(`,"retweet_count":`) + fflib.FormatBits2(buf, uint64(mj.RetweetCount), 10, mj.RetweetCount < 0) + if mj.Retweeted { + buf.WriteString(`,"retweeted":true`) + } else { + buf.WriteString(`,"retweeted":false`) + } + buf.WriteString(`,"source":`) + fflib.WriteJsonString(buf, string(mj.Source)) + buf.WriteString(`,"text":`) + fflib.WriteJsonString(buf, string(mj.Text)) + if mj.Truncated { + buf.WriteString(`,"truncated":true`) + } else { + buf.WriteString(`,"truncated":false`) + } + buf.WriteString(`,"user":`) + + { + + err = mj.User.MarshalJSONBuf(buf) + if err != nil { + return err + } + + } + buf.WriteByte('}') + return nil +} + +const ( + ffj_t_Statusbase = iota + ffj_t_Statusno_such_key + + ffj_t_Status_Contributors + + ffj_t_Status_Coordinates + + ffj_t_Status_CreatedAt + + ffj_t_Status_Entities + + ffj_t_Status_Favorited + + ffj_t_Status_Geo + + ffj_t_Status_ID + + ffj_t_Status_IDStr + + ffj_t_Status_InReplyToScreenName + + ffj_t_Status_InReplyToStatusID + + ffj_t_Status_InReplyToStatusIDStr + + ffj_t_Status_InReplyToUserID + + ffj_t_Status_InReplyToUserIDStr + + ffj_t_Status_Metadata + + ffj_t_Status_Place + + ffj_t_Status_RetweetCount + + ffj_t_Status_Retweeted + + ffj_t_Status_Source + + ffj_t_Status_Text + + ffj_t_Status_Truncated + + ffj_t_Status_User +) + +var ffj_key_Status_Contributors = []byte("contributors") + +var ffj_key_Status_Coordinates = []byte("coordinates") + +var ffj_key_Status_CreatedAt = []byte("created_at") + +var ffj_key_Status_Entities = []byte("entities") + +var ffj_key_Status_Favorited = []byte("favorited") + +var ffj_key_Status_Geo = []byte("geo") + +var ffj_key_Status_ID = []byte("id") + +var ffj_key_Status_IDStr = []byte("id_str") + +var ffj_key_Status_InReplyToScreenName = []byte("in_reply_to_screen_name") + +var ffj_key_Status_InReplyToStatusID = []byte("in_reply_to_status_id") + +var ffj_key_Status_InReplyToStatusIDStr = []byte("in_reply_to_status_id_str") + +var ffj_key_Status_InReplyToUserID = []byte("in_reply_to_user_id") + +var ffj_key_Status_InReplyToUserIDStr = []byte("in_reply_to_user_id_str") + +var ffj_key_Status_Metadata = []byte("metadata") + +var ffj_key_Status_Place = []byte("place") + +var ffj_key_Status_RetweetCount = []byte("retweet_count") + +var ffj_key_Status_Retweeted = []byte("retweeted") + +var ffj_key_Status_Source = []byte("source") + +var ffj_key_Status_Text = []byte("text") + +var ffj_key_Status_Truncated = []byte("truncated") + +var ffj_key_Status_User = []byte("user") + +func (uj *Status) UnmarshalJSON(input []byte) error { + fs := fflib.NewFFLexer(input) + return uj.UnmarshalJSONFFLexer(fs, fflib.FFParse_map_start) +} + +func (uj *Status) UnmarshalJSONFFLexer(fs *fflib.FFLexer, state fflib.FFParseState) error { + var err error = nil + currentKey := ffj_t_Statusbase + _ = currentKey + tok := fflib.FFTok_init + wantedTok := fflib.FFTok_init + +mainparse: + for { + tok = fs.Scan() + // println(fmt.Sprintf("debug: tok: %v state: %v", tok, state)) + if tok == fflib.FFTok_error { + goto tokerror + } + + switch state { + + case fflib.FFParse_map_start: + if tok != fflib.FFTok_left_bracket { + wantedTok = fflib.FFTok_left_bracket + goto wrongtokenerror + } + state = fflib.FFParse_want_key + continue + + case fflib.FFParse_after_value: + if tok == fflib.FFTok_comma { + state = fflib.FFParse_want_key + } else if tok == fflib.FFTok_right_bracket { + goto done + } else { + wantedTok = fflib.FFTok_comma + goto wrongtokenerror + } + + case fflib.FFParse_want_key: + // json {} ended. goto exit. woo. + if tok == fflib.FFTok_right_bracket { + goto done + } + if tok != fflib.FFTok_string { + wantedTok = fflib.FFTok_string + goto wrongtokenerror + } + + kn := fs.Output.Bytes() + if len(kn) <= 0 { + // "" case. hrm. + currentKey = ffj_t_Statusno_such_key + state = fflib.FFParse_want_colon + goto mainparse + } else { + switch kn[0] { + + case 'c': + + if bytes.Equal(ffj_key_Status_Contributors, kn) { + currentKey = ffj_t_Status_Contributors + state = fflib.FFParse_want_colon + goto mainparse + + } else if bytes.Equal(ffj_key_Status_Coordinates, kn) { + currentKey = ffj_t_Status_Coordinates + state = fflib.FFParse_want_colon + goto mainparse + + } else if bytes.Equal(ffj_key_Status_CreatedAt, kn) { + currentKey = ffj_t_Status_CreatedAt + state = fflib.FFParse_want_colon + goto mainparse + } + + case 'e': + + if bytes.Equal(ffj_key_Status_Entities, kn) { + currentKey = ffj_t_Status_Entities + state = fflib.FFParse_want_colon + goto mainparse + } + + case 'f': + + if bytes.Equal(ffj_key_Status_Favorited, kn) { + currentKey = ffj_t_Status_Favorited + state = fflib.FFParse_want_colon + goto mainparse + } + + case 'g': + + if bytes.Equal(ffj_key_Status_Geo, kn) { + currentKey = ffj_t_Status_Geo + state = fflib.FFParse_want_colon + goto mainparse + } + + case 'i': + + if bytes.Equal(ffj_key_Status_ID, kn) { + currentKey = ffj_t_Status_ID + state = fflib.FFParse_want_colon + goto mainparse + + } else if bytes.Equal(ffj_key_Status_IDStr, kn) { + currentKey = ffj_t_Status_IDStr + state = fflib.FFParse_want_colon + goto mainparse + + } else if bytes.Equal(ffj_key_Status_InReplyToScreenName, kn) { + currentKey = ffj_t_Status_InReplyToScreenName + state = fflib.FFParse_want_colon + goto mainparse + + } else if bytes.Equal(ffj_key_Status_InReplyToStatusID, kn) { + currentKey = ffj_t_Status_InReplyToStatusID + state = fflib.FFParse_want_colon + goto mainparse + + } else if bytes.Equal(ffj_key_Status_InReplyToStatusIDStr, kn) { + currentKey = ffj_t_Status_InReplyToStatusIDStr + state = fflib.FFParse_want_colon + goto mainparse + + } else if bytes.Equal(ffj_key_Status_InReplyToUserID, kn) { + currentKey = ffj_t_Status_InReplyToUserID + state = fflib.FFParse_want_colon + goto mainparse + + } else if bytes.Equal(ffj_key_Status_InReplyToUserIDStr, kn) { + currentKey = ffj_t_Status_InReplyToUserIDStr + state = fflib.FFParse_want_colon + goto mainparse + } + + case 'm': + + if bytes.Equal(ffj_key_Status_Metadata, kn) { + currentKey = ffj_t_Status_Metadata + state = fflib.FFParse_want_colon + goto mainparse + } + + case 'p': + + if bytes.Equal(ffj_key_Status_Place, kn) { + currentKey = ffj_t_Status_Place + state = fflib.FFParse_want_colon + goto mainparse + } + + case 'r': + + if bytes.Equal(ffj_key_Status_RetweetCount, kn) { + currentKey = ffj_t_Status_RetweetCount + state = fflib.FFParse_want_colon + goto mainparse + + } else if bytes.Equal(ffj_key_Status_Retweeted, kn) { + currentKey = ffj_t_Status_Retweeted + state = fflib.FFParse_want_colon + goto mainparse + } + + case 's': + + if bytes.Equal(ffj_key_Status_Source, kn) { + currentKey = ffj_t_Status_Source + state = fflib.FFParse_want_colon + goto mainparse + } + + case 't': + + if bytes.Equal(ffj_key_Status_Text, kn) { + currentKey = ffj_t_Status_Text + state = fflib.FFParse_want_colon + goto mainparse + + } else if bytes.Equal(ffj_key_Status_Truncated, kn) { + currentKey = ffj_t_Status_Truncated + state = fflib.FFParse_want_colon + goto mainparse + } + + case 'u': + + if bytes.Equal(ffj_key_Status_User, kn) { + currentKey = ffj_t_Status_User + state = fflib.FFParse_want_colon + goto mainparse + } + + } + + if fflib.EqualFoldRight(ffj_key_Status_User, kn) { + currentKey = ffj_t_Status_User + state = fflib.FFParse_want_colon + goto mainparse + } + + if fflib.SimpleLetterEqualFold(ffj_key_Status_Truncated, kn) { + currentKey = ffj_t_Status_Truncated + state = fflib.FFParse_want_colon + goto mainparse + } + + if fflib.SimpleLetterEqualFold(ffj_key_Status_Text, kn) { + currentKey = ffj_t_Status_Text + state = fflib.FFParse_want_colon + goto mainparse + } + + if fflib.EqualFoldRight(ffj_key_Status_Source, kn) { + currentKey = ffj_t_Status_Source + state = fflib.FFParse_want_colon + goto mainparse + } + + if fflib.SimpleLetterEqualFold(ffj_key_Status_Retweeted, kn) { + currentKey = ffj_t_Status_Retweeted + state = fflib.FFParse_want_colon + goto mainparse + } + + if fflib.AsciiEqualFold(ffj_key_Status_RetweetCount, kn) { + currentKey = ffj_t_Status_RetweetCount + state = fflib.FFParse_want_colon + goto mainparse + } + + if fflib.SimpleLetterEqualFold(ffj_key_Status_Place, kn) { + currentKey = ffj_t_Status_Place + state = fflib.FFParse_want_colon + goto mainparse + } + + if fflib.SimpleLetterEqualFold(ffj_key_Status_Metadata, kn) { + currentKey = ffj_t_Status_Metadata + state = fflib.FFParse_want_colon + goto mainparse + } + + if fflib.EqualFoldRight(ffj_key_Status_InReplyToUserIDStr, kn) { + currentKey = ffj_t_Status_InReplyToUserIDStr + state = fflib.FFParse_want_colon + goto mainparse + } + + if fflib.EqualFoldRight(ffj_key_Status_InReplyToUserID, kn) { + currentKey = ffj_t_Status_InReplyToUserID + state = fflib.FFParse_want_colon + goto mainparse + } + + if fflib.EqualFoldRight(ffj_key_Status_InReplyToStatusIDStr, kn) { + currentKey = ffj_t_Status_InReplyToStatusIDStr + state = fflib.FFParse_want_colon + goto mainparse + } + + if fflib.EqualFoldRight(ffj_key_Status_InReplyToStatusID, kn) { + currentKey = ffj_t_Status_InReplyToStatusID + state = fflib.FFParse_want_colon + goto mainparse + } + + if fflib.EqualFoldRight(ffj_key_Status_InReplyToScreenName, kn) { + currentKey = ffj_t_Status_InReplyToScreenName + state = fflib.FFParse_want_colon + goto mainparse + } + + if fflib.EqualFoldRight(ffj_key_Status_IDStr, kn) { + currentKey = ffj_t_Status_IDStr + state = fflib.FFParse_want_colon + goto mainparse + } + + if fflib.SimpleLetterEqualFold(ffj_key_Status_ID, kn) { + currentKey = ffj_t_Status_ID + state = fflib.FFParse_want_colon + goto mainparse + } + + if fflib.SimpleLetterEqualFold(ffj_key_Status_Geo, kn) { + currentKey = ffj_t_Status_Geo + state = fflib.FFParse_want_colon + goto mainparse + } + + if fflib.SimpleLetterEqualFold(ffj_key_Status_Favorited, kn) { + currentKey = ffj_t_Status_Favorited + state = fflib.FFParse_want_colon + goto mainparse + } + + if fflib.EqualFoldRight(ffj_key_Status_Entities, kn) { + currentKey = ffj_t_Status_Entities + state = fflib.FFParse_want_colon + goto mainparse + } + + if fflib.AsciiEqualFold(ffj_key_Status_CreatedAt, kn) { + currentKey = ffj_t_Status_CreatedAt + state = fflib.FFParse_want_colon + goto mainparse + } + + if fflib.EqualFoldRight(ffj_key_Status_Coordinates, kn) { + currentKey = ffj_t_Status_Coordinates + state = fflib.FFParse_want_colon + goto mainparse + } + + if fflib.EqualFoldRight(ffj_key_Status_Contributors, kn) { + currentKey = ffj_t_Status_Contributors + state = fflib.FFParse_want_colon + goto mainparse + } + + currentKey = ffj_t_Statusno_such_key + state = fflib.FFParse_want_colon + goto mainparse + } + + case fflib.FFParse_want_colon: + if tok != fflib.FFTok_colon { + wantedTok = fflib.FFTok_colon + goto wrongtokenerror + } + state = fflib.FFParse_want_value + continue + case fflib.FFParse_want_value: + + if tok == fflib.FFTok_left_brace || tok == fflib.FFTok_left_bracket || tok == fflib.FFTok_integer || tok == fflib.FFTok_double || tok == fflib.FFTok_string || tok == fflib.FFTok_bool || tok == fflib.FFTok_null { + switch currentKey { + + case ffj_t_Status_Contributors: + goto handle_Contributors + + case ffj_t_Status_Coordinates: + goto handle_Coordinates + + case ffj_t_Status_CreatedAt: + goto handle_CreatedAt + + case ffj_t_Status_Entities: + goto handle_Entities + + case ffj_t_Status_Favorited: + goto handle_Favorited + + case ffj_t_Status_Geo: + goto handle_Geo + + case ffj_t_Status_ID: + goto handle_ID + + case ffj_t_Status_IDStr: + goto handle_IDStr + + case ffj_t_Status_InReplyToScreenName: + goto handle_InReplyToScreenName + + case ffj_t_Status_InReplyToStatusID: + goto handle_InReplyToStatusID + + case ffj_t_Status_InReplyToStatusIDStr: + goto handle_InReplyToStatusIDStr + + case ffj_t_Status_InReplyToUserID: + goto handle_InReplyToUserID + + case ffj_t_Status_InReplyToUserIDStr: + goto handle_InReplyToUserIDStr + + case ffj_t_Status_Metadata: + goto handle_Metadata + + case ffj_t_Status_Place: + goto handle_Place + + case ffj_t_Status_RetweetCount: + goto handle_RetweetCount + + case ffj_t_Status_Retweeted: + goto handle_Retweeted + + case ffj_t_Status_Source: + goto handle_Source + + case ffj_t_Status_Text: + goto handle_Text + + case ffj_t_Status_Truncated: + goto handle_Truncated + + case ffj_t_Status_User: + goto handle_User + + case ffj_t_Statusno_such_key: + err = fs.SkipField(tok) + if err != nil { + return fs.WrapErr(err) + } + state = fflib.FFParse_after_value + goto mainparse + } + } else { + goto wantedvalue + } + } + } + +handle_Contributors: + + /* handler: uj.Contributors type=string kind=string quoted=false*/ + + { + + { + if tok != fflib.FFTok_string && tok != fflib.FFTok_null { + return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for string", tok)) + } + } + + if tok == fflib.FFTok_null { + + uj.Contributors = nil + + } else { + + var tval string + outBuf := fs.Output.Bytes() + + tval = string(string(outBuf)) + uj.Contributors = &tval + + } + } + + state = fflib.FFParse_after_value + goto mainparse + +handle_Coordinates: + + /* handler: uj.Coordinates type=string kind=string quoted=false*/ + + { + + { + if tok != fflib.FFTok_string && tok != fflib.FFTok_null { + return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for string", tok)) + } + } + + if tok == fflib.FFTok_null { + + uj.Coordinates = nil + + } else { + + var tval string + outBuf := fs.Output.Bytes() + + tval = string(string(outBuf)) + uj.Coordinates = &tval + + } + } + + state = fflib.FFParse_after_value + goto mainparse + +handle_CreatedAt: + + /* handler: uj.CreatedAt type=string kind=string quoted=false*/ + + { + + { + if tok != fflib.FFTok_string && tok != fflib.FFTok_null { + return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for string", tok)) + } + } + + if tok == fflib.FFTok_null { + + } else { + + outBuf := fs.Output.Bytes() + + uj.CreatedAt = string(string(outBuf)) + + } + } + + state = fflib.FFParse_after_value + goto mainparse + +handle_Entities: + + /* handler: uj.Entities type=benchmark.Entities kind=struct quoted=false*/ + + { + if tok == fflib.FFTok_null { + + state = fflib.FFParse_after_value + goto mainparse + } + + err = uj.Entities.UnmarshalJSONFFLexer(fs, fflib.FFParse_want_key) + if err != nil { + return err + } + state = fflib.FFParse_after_value + } + + state = fflib.FFParse_after_value + goto mainparse + +handle_Favorited: + + /* handler: uj.Favorited type=bool kind=bool quoted=false*/ + + { + if tok != fflib.FFTok_bool && tok != fflib.FFTok_null { + return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for bool", tok)) + } + } + + { + if tok == fflib.FFTok_null { + + } else { + tmpb := fs.Output.Bytes() + + if bytes.Compare([]byte{'t', 'r', 'u', 'e'}, tmpb) == 0 { + + uj.Favorited = true + + } else if bytes.Compare([]byte{'f', 'a', 'l', 's', 'e'}, tmpb) == 0 { + + uj.Favorited = false + + } else { + err = errors.New("unexpected bytes for true/false value") + return fs.WrapErr(err) + } + + } + } + + state = fflib.FFParse_after_value + goto mainparse + +handle_Geo: + + /* handler: uj.Geo type=string kind=string quoted=false*/ + + { + + { + if tok != fflib.FFTok_string && tok != fflib.FFTok_null { + return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for string", tok)) + } + } + + if tok == fflib.FFTok_null { + + uj.Geo = nil + + } else { + + var tval string + outBuf := fs.Output.Bytes() + + tval = string(string(outBuf)) + uj.Geo = &tval + + } + } + + state = fflib.FFParse_after_value + goto mainparse + +handle_ID: + + /* handler: uj.ID type=int64 kind=int64 quoted=false*/ + + { + if tok != fflib.FFTok_integer && tok != fflib.FFTok_null { + return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for int64", tok)) + } + } + + { + + if tok == fflib.FFTok_null { + + } else { + + tval, err := fflib.ParseInt(fs.Output.Bytes(), 10, 64) + + if err != nil { + return fs.WrapErr(err) + } + + uj.ID = int64(tval) + + } + } + + state = fflib.FFParse_after_value + goto mainparse + +handle_IDStr: + + /* handler: uj.IDStr type=string kind=string quoted=false*/ + + { + + { + if tok != fflib.FFTok_string && tok != fflib.FFTok_null { + return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for string", tok)) + } + } + + if tok == fflib.FFTok_null { + + } else { + + outBuf := fs.Output.Bytes() + + uj.IDStr = string(string(outBuf)) + + } + } + + state = fflib.FFParse_after_value + goto mainparse + +handle_InReplyToScreenName: + + /* handler: uj.InReplyToScreenName type=string kind=string quoted=false*/ + + { + + { + if tok != fflib.FFTok_string && tok != fflib.FFTok_null { + return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for string", tok)) + } + } + + if tok == fflib.FFTok_null { + + uj.InReplyToScreenName = nil + + } else { + + var tval string + outBuf := fs.Output.Bytes() + + tval = string(string(outBuf)) + uj.InReplyToScreenName = &tval + + } + } + + state = fflib.FFParse_after_value + goto mainparse + +handle_InReplyToStatusID: + + /* handler: uj.InReplyToStatusID type=string kind=string quoted=false*/ + + { + + { + if tok != fflib.FFTok_string && tok != fflib.FFTok_null { + return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for string", tok)) + } + } + + if tok == fflib.FFTok_null { + + uj.InReplyToStatusID = nil + + } else { + + var tval string + outBuf := fs.Output.Bytes() + + tval = string(string(outBuf)) + uj.InReplyToStatusID = &tval + + } + } + + state = fflib.FFParse_after_value + goto mainparse + +handle_InReplyToStatusIDStr: + + /* handler: uj.InReplyToStatusIDStr type=string kind=string quoted=false*/ + + { + + { + if tok != fflib.FFTok_string && tok != fflib.FFTok_null { + return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for string", tok)) + } + } + + if tok == fflib.FFTok_null { + + uj.InReplyToStatusIDStr = nil + + } else { + + var tval string + outBuf := fs.Output.Bytes() + + tval = string(string(outBuf)) + uj.InReplyToStatusIDStr = &tval + + } + } + + state = fflib.FFParse_after_value + goto mainparse + +handle_InReplyToUserID: + + /* handler: uj.InReplyToUserID type=string kind=string quoted=false*/ + + { + + { + if tok != fflib.FFTok_string && tok != fflib.FFTok_null { + return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for string", tok)) + } + } + + if tok == fflib.FFTok_null { + + uj.InReplyToUserID = nil + + } else { + + var tval string + outBuf := fs.Output.Bytes() + + tval = string(string(outBuf)) + uj.InReplyToUserID = &tval + + } + } + + state = fflib.FFParse_after_value + goto mainparse + +handle_InReplyToUserIDStr: + + /* handler: uj.InReplyToUserIDStr type=string kind=string quoted=false*/ + + { + + { + if tok != fflib.FFTok_string && tok != fflib.FFTok_null { + return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for string", tok)) + } + } + + if tok == fflib.FFTok_null { + + uj.InReplyToUserIDStr = nil + + } else { + + var tval string + outBuf := fs.Output.Bytes() + + tval = string(string(outBuf)) + uj.InReplyToUserIDStr = &tval + + } + } + + state = fflib.FFParse_after_value + goto mainparse + +handle_Metadata: + + /* handler: uj.Metadata type=benchmark.StatusMetadata kind=struct quoted=false*/ + + { + if tok == fflib.FFTok_null { + + state = fflib.FFParse_after_value + goto mainparse + } + + err = uj.Metadata.UnmarshalJSONFFLexer(fs, fflib.FFParse_want_key) + if err != nil { + return err + } + state = fflib.FFParse_after_value + } + + state = fflib.FFParse_after_value + goto mainparse + +handle_Place: + + /* handler: uj.Place type=string kind=string quoted=false*/ + + { + + { + if tok != fflib.FFTok_string && tok != fflib.FFTok_null { + return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for string", tok)) + } + } + + if tok == fflib.FFTok_null { + + uj.Place = nil + + } else { + + var tval string + outBuf := fs.Output.Bytes() + + tval = string(string(outBuf)) + uj.Place = &tval + + } + } + + state = fflib.FFParse_after_value + goto mainparse + +handle_RetweetCount: + + /* handler: uj.RetweetCount type=int kind=int quoted=false*/ + + { + if tok != fflib.FFTok_integer && tok != fflib.FFTok_null { + return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for int", tok)) + } + } + + { + + if tok == fflib.FFTok_null { + + } else { + + tval, err := fflib.ParseInt(fs.Output.Bytes(), 10, 64) + + if err != nil { + return fs.WrapErr(err) + } + + uj.RetweetCount = int(tval) + + } + } + + state = fflib.FFParse_after_value + goto mainparse + +handle_Retweeted: + + /* handler: uj.Retweeted type=bool kind=bool quoted=false*/ + + { + if tok != fflib.FFTok_bool && tok != fflib.FFTok_null { + return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for bool", tok)) + } + } + + { + if tok == fflib.FFTok_null { + + } else { + tmpb := fs.Output.Bytes() + + if bytes.Compare([]byte{'t', 'r', 'u', 'e'}, tmpb) == 0 { + + uj.Retweeted = true + + } else if bytes.Compare([]byte{'f', 'a', 'l', 's', 'e'}, tmpb) == 0 { + + uj.Retweeted = false + + } else { + err = errors.New("unexpected bytes for true/false value") + return fs.WrapErr(err) + } + + } + } + + state = fflib.FFParse_after_value + goto mainparse + +handle_Source: + + /* handler: uj.Source type=string kind=string quoted=false*/ + + { + + { + if tok != fflib.FFTok_string && tok != fflib.FFTok_null { + return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for string", tok)) + } + } + + if tok == fflib.FFTok_null { + + } else { + + outBuf := fs.Output.Bytes() + + uj.Source = string(string(outBuf)) + + } + } + + state = fflib.FFParse_after_value + goto mainparse + +handle_Text: + + /* handler: uj.Text type=string kind=string quoted=false*/ + + { + + { + if tok != fflib.FFTok_string && tok != fflib.FFTok_null { + return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for string", tok)) + } + } + + if tok == fflib.FFTok_null { + + } else { + + outBuf := fs.Output.Bytes() + + uj.Text = string(string(outBuf)) + + } + } + + state = fflib.FFParse_after_value + goto mainparse + +handle_Truncated: + + /* handler: uj.Truncated type=bool kind=bool quoted=false*/ + + { + if tok != fflib.FFTok_bool && tok != fflib.FFTok_null { + return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for bool", tok)) + } + } + + { + if tok == fflib.FFTok_null { + + } else { + tmpb := fs.Output.Bytes() + + if bytes.Compare([]byte{'t', 'r', 'u', 'e'}, tmpb) == 0 { + + uj.Truncated = true + + } else if bytes.Compare([]byte{'f', 'a', 'l', 's', 'e'}, tmpb) == 0 { + + uj.Truncated = false + + } else { + err = errors.New("unexpected bytes for true/false value") + return fs.WrapErr(err) + } + + } + } + + state = fflib.FFParse_after_value + goto mainparse + +handle_User: + + /* handler: uj.User type=benchmark.User kind=struct quoted=false*/ + + { + if tok == fflib.FFTok_null { + + state = fflib.FFParse_after_value + goto mainparse + } + + err = uj.User.UnmarshalJSONFFLexer(fs, fflib.FFParse_want_key) + if err != nil { + return err + } + state = fflib.FFParse_after_value + } + + state = fflib.FFParse_after_value + goto mainparse + +wantedvalue: + return fs.WrapErr(fmt.Errorf("wanted value token, but got token: %v", tok)) +wrongtokenerror: + return fs.WrapErr(fmt.Errorf("ffjson: wanted token: %v, but got token: %v output=%s", wantedTok, tok, fs.Output.String())) +tokerror: + if fs.BigError != nil { + return fs.WrapErr(fs.BigError) + } + err = fs.Error.ToError() + if err != nil { + return fs.WrapErr(err) + } + panic("ffjson-generated: unreachable, please report bug.") +done: + return nil +} + +func (mj *StatusMetadata) MarshalJSON() ([]byte, error) { + var buf fflib.Buffer + if mj == nil { + buf.WriteString("null") + return buf.Bytes(), nil + } + err := mj.MarshalJSONBuf(&buf) + if err != nil { + return nil, err + } + return buf.Bytes(), nil +} +func (mj *StatusMetadata) MarshalJSONBuf(buf fflib.EncodingBuffer) error { + if mj == nil { + buf.WriteString("null") + return nil + } + var err error + var obj []byte + _ = obj + _ = err + buf.WriteString(`{"iso_language_code":`) + fflib.WriteJsonString(buf, string(mj.IsoLanguageCode)) + buf.WriteString(`,"result_type":`) + fflib.WriteJsonString(buf, string(mj.ResultType)) + buf.WriteByte('}') + return nil +} + +const ( + ffj_t_StatusMetadatabase = iota + ffj_t_StatusMetadatano_such_key + + ffj_t_StatusMetadata_IsoLanguageCode + + ffj_t_StatusMetadata_ResultType +) + +var ffj_key_StatusMetadata_IsoLanguageCode = []byte("iso_language_code") + +var ffj_key_StatusMetadata_ResultType = []byte("result_type") + +func (uj *StatusMetadata) UnmarshalJSON(input []byte) error { + fs := fflib.NewFFLexer(input) + return uj.UnmarshalJSONFFLexer(fs, fflib.FFParse_map_start) +} + +func (uj *StatusMetadata) UnmarshalJSONFFLexer(fs *fflib.FFLexer, state fflib.FFParseState) error { + var err error = nil + currentKey := ffj_t_StatusMetadatabase + _ = currentKey + tok := fflib.FFTok_init + wantedTok := fflib.FFTok_init + +mainparse: + for { + tok = fs.Scan() + // println(fmt.Sprintf("debug: tok: %v state: %v", tok, state)) + if tok == fflib.FFTok_error { + goto tokerror + } + + switch state { + + case fflib.FFParse_map_start: + if tok != fflib.FFTok_left_bracket { + wantedTok = fflib.FFTok_left_bracket + goto wrongtokenerror + } + state = fflib.FFParse_want_key + continue + + case fflib.FFParse_after_value: + if tok == fflib.FFTok_comma { + state = fflib.FFParse_want_key + } else if tok == fflib.FFTok_right_bracket { + goto done + } else { + wantedTok = fflib.FFTok_comma + goto wrongtokenerror + } + + case fflib.FFParse_want_key: + // json {} ended. goto exit. woo. + if tok == fflib.FFTok_right_bracket { + goto done + } + if tok != fflib.FFTok_string { + wantedTok = fflib.FFTok_string + goto wrongtokenerror + } + + kn := fs.Output.Bytes() + if len(kn) <= 0 { + // "" case. hrm. + currentKey = ffj_t_StatusMetadatano_such_key + state = fflib.FFParse_want_colon + goto mainparse + } else { + switch kn[0] { + + case 'i': + + if bytes.Equal(ffj_key_StatusMetadata_IsoLanguageCode, kn) { + currentKey = ffj_t_StatusMetadata_IsoLanguageCode + state = fflib.FFParse_want_colon + goto mainparse + } + + case 'r': + + if bytes.Equal(ffj_key_StatusMetadata_ResultType, kn) { + currentKey = ffj_t_StatusMetadata_ResultType + state = fflib.FFParse_want_colon + goto mainparse + } + + } + + if fflib.EqualFoldRight(ffj_key_StatusMetadata_ResultType, kn) { + currentKey = ffj_t_StatusMetadata_ResultType + state = fflib.FFParse_want_colon + goto mainparse + } + + if fflib.EqualFoldRight(ffj_key_StatusMetadata_IsoLanguageCode, kn) { + currentKey = ffj_t_StatusMetadata_IsoLanguageCode + state = fflib.FFParse_want_colon + goto mainparse + } + + currentKey = ffj_t_StatusMetadatano_such_key + state = fflib.FFParse_want_colon + goto mainparse + } + + case fflib.FFParse_want_colon: + if tok != fflib.FFTok_colon { + wantedTok = fflib.FFTok_colon + goto wrongtokenerror + } + state = fflib.FFParse_want_value + continue + case fflib.FFParse_want_value: + + if tok == fflib.FFTok_left_brace || tok == fflib.FFTok_left_bracket || tok == fflib.FFTok_integer || tok == fflib.FFTok_double || tok == fflib.FFTok_string || tok == fflib.FFTok_bool || tok == fflib.FFTok_null { + switch currentKey { + + case ffj_t_StatusMetadata_IsoLanguageCode: + goto handle_IsoLanguageCode + + case ffj_t_StatusMetadata_ResultType: + goto handle_ResultType + + case ffj_t_StatusMetadatano_such_key: + err = fs.SkipField(tok) + if err != nil { + return fs.WrapErr(err) + } + state = fflib.FFParse_after_value + goto mainparse + } + } else { + goto wantedvalue + } + } + } + +handle_IsoLanguageCode: + + /* handler: uj.IsoLanguageCode type=string kind=string quoted=false*/ + + { + + { + if tok != fflib.FFTok_string && tok != fflib.FFTok_null { + return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for string", tok)) + } + } + + if tok == fflib.FFTok_null { + + } else { + + outBuf := fs.Output.Bytes() + + uj.IsoLanguageCode = string(string(outBuf)) + + } + } + + state = fflib.FFParse_after_value + goto mainparse + +handle_ResultType: + + /* handler: uj.ResultType type=string kind=string quoted=false*/ + + { + + { + if tok != fflib.FFTok_string && tok != fflib.FFTok_null { + return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for string", tok)) + } + } + + if tok == fflib.FFTok_null { + + } else { + + outBuf := fs.Output.Bytes() + + uj.ResultType = string(string(outBuf)) + + } + } + + state = fflib.FFParse_after_value + goto mainparse + +wantedvalue: + return fs.WrapErr(fmt.Errorf("wanted value token, but got token: %v", tok)) +wrongtokenerror: + return fs.WrapErr(fmt.Errorf("ffjson: wanted token: %v, but got token: %v output=%s", wantedTok, tok, fs.Output.String())) +tokerror: + if fs.BigError != nil { + return fs.WrapErr(fs.BigError) + } + err = fs.Error.ToError() + if err != nil { + return fs.WrapErr(err) + } + panic("ffjson-generated: unreachable, please report bug.") +done: + return nil +} + +func (mj *URL) MarshalJSON() ([]byte, error) { + var buf fflib.Buffer + if mj == nil { + buf.WriteString("null") + return buf.Bytes(), nil + } + err := mj.MarshalJSONBuf(&buf) + if err != nil { + return nil, err + } + return buf.Bytes(), nil +} +func (mj *URL) MarshalJSONBuf(buf fflib.EncodingBuffer) error { + if mj == nil { + buf.WriteString("null") + return nil + } + var err error + var obj []byte + _ = obj + _ = err + if mj.ExpandedURL != nil { + buf.WriteString(`{"expanded_url":`) + fflib.WriteJsonString(buf, string(*mj.ExpandedURL)) + } else { + buf.WriteString(`{"expanded_url":null`) + } + buf.WriteString(`,"indices":`) + if mj.Indices != nil { + buf.WriteString(`[`) + for i, v := range mj.Indices { + if i != 0 { + buf.WriteString(`,`) + } + fflib.FormatBits2(buf, uint64(v), 10, v < 0) + } + buf.WriteString(`]`) + } else { + buf.WriteString(`null`) + } + buf.WriteString(`,"url":`) + fflib.WriteJsonString(buf, string(mj.URL)) + buf.WriteByte('}') + return nil +} + +const ( + ffj_t_URLbase = iota + ffj_t_URLno_such_key + + ffj_t_URL_ExpandedURL + + ffj_t_URL_Indices + + ffj_t_URL_URL +) + +var ffj_key_URL_ExpandedURL = []byte("expanded_url") + +var ffj_key_URL_Indices = []byte("indices") + +var ffj_key_URL_URL = []byte("url") + +func (uj *URL) UnmarshalJSON(input []byte) error { + fs := fflib.NewFFLexer(input) + return uj.UnmarshalJSONFFLexer(fs, fflib.FFParse_map_start) +} + +func (uj *URL) UnmarshalJSONFFLexer(fs *fflib.FFLexer, state fflib.FFParseState) error { + var err error = nil + currentKey := ffj_t_URLbase + _ = currentKey + tok := fflib.FFTok_init + wantedTok := fflib.FFTok_init + +mainparse: + for { + tok = fs.Scan() + // println(fmt.Sprintf("debug: tok: %v state: %v", tok, state)) + if tok == fflib.FFTok_error { + goto tokerror + } + + switch state { + + case fflib.FFParse_map_start: + if tok != fflib.FFTok_left_bracket { + wantedTok = fflib.FFTok_left_bracket + goto wrongtokenerror + } + state = fflib.FFParse_want_key + continue + + case fflib.FFParse_after_value: + if tok == fflib.FFTok_comma { + state = fflib.FFParse_want_key + } else if tok == fflib.FFTok_right_bracket { + goto done + } else { + wantedTok = fflib.FFTok_comma + goto wrongtokenerror + } + + case fflib.FFParse_want_key: + // json {} ended. goto exit. woo. + if tok == fflib.FFTok_right_bracket { + goto done + } + if tok != fflib.FFTok_string { + wantedTok = fflib.FFTok_string + goto wrongtokenerror + } + + kn := fs.Output.Bytes() + if len(kn) <= 0 { + // "" case. hrm. + currentKey = ffj_t_URLno_such_key + state = fflib.FFParse_want_colon + goto mainparse + } else { + switch kn[0] { + + case 'e': + + if bytes.Equal(ffj_key_URL_ExpandedURL, kn) { + currentKey = ffj_t_URL_ExpandedURL + state = fflib.FFParse_want_colon + goto mainparse + } + + case 'i': + + if bytes.Equal(ffj_key_URL_Indices, kn) { + currentKey = ffj_t_URL_Indices + state = fflib.FFParse_want_colon + goto mainparse + } + + case 'u': + + if bytes.Equal(ffj_key_URL_URL, kn) { + currentKey = ffj_t_URL_URL + state = fflib.FFParse_want_colon + goto mainparse + } + + } + + if fflib.SimpleLetterEqualFold(ffj_key_URL_URL, kn) { + currentKey = ffj_t_URL_URL + state = fflib.FFParse_want_colon + goto mainparse + } + + if fflib.EqualFoldRight(ffj_key_URL_Indices, kn) { + currentKey = ffj_t_URL_Indices + state = fflib.FFParse_want_colon + goto mainparse + } + + if fflib.AsciiEqualFold(ffj_key_URL_ExpandedURL, kn) { + currentKey = ffj_t_URL_ExpandedURL + state = fflib.FFParse_want_colon + goto mainparse + } + + currentKey = ffj_t_URLno_such_key + state = fflib.FFParse_want_colon + goto mainparse + } + + case fflib.FFParse_want_colon: + if tok != fflib.FFTok_colon { + wantedTok = fflib.FFTok_colon + goto wrongtokenerror + } + state = fflib.FFParse_want_value + continue + case fflib.FFParse_want_value: + + if tok == fflib.FFTok_left_brace || tok == fflib.FFTok_left_bracket || tok == fflib.FFTok_integer || tok == fflib.FFTok_double || tok == fflib.FFTok_string || tok == fflib.FFTok_bool || tok == fflib.FFTok_null { + switch currentKey { + + case ffj_t_URL_ExpandedURL: + goto handle_ExpandedURL + + case ffj_t_URL_Indices: + goto handle_Indices + + case ffj_t_URL_URL: + goto handle_URL + + case ffj_t_URLno_such_key: + err = fs.SkipField(tok) + if err != nil { + return fs.WrapErr(err) + } + state = fflib.FFParse_after_value + goto mainparse + } + } else { + goto wantedvalue + } + } + } + +handle_ExpandedURL: + + /* handler: uj.ExpandedURL type=string kind=string quoted=false*/ + + { + + { + if tok != fflib.FFTok_string && tok != fflib.FFTok_null { + return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for string", tok)) + } + } + + if tok == fflib.FFTok_null { + + uj.ExpandedURL = nil + + } else { + + var tval string + outBuf := fs.Output.Bytes() + + tval = string(string(outBuf)) + uj.ExpandedURL = &tval + + } + } + + state = fflib.FFParse_after_value + goto mainparse + +handle_Indices: + + /* handler: uj.Indices type=[]int kind=slice quoted=false*/ + + { + + { + if tok != fflib.FFTok_left_brace && tok != fflib.FFTok_null { + return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for ", tok)) + } + } + + if tok == fflib.FFTok_null { + uj.Indices = nil + } else { + + uj.Indices = make([]int, 0) + + wantVal := true + + for { + + var tmp_uj__Indices int + + tok = fs.Scan() + if tok == fflib.FFTok_error { + goto tokerror + } + if tok == fflib.FFTok_right_brace { + break + } + + if tok == fflib.FFTok_comma { + if wantVal == true { + // TODO(pquerna): this isn't an ideal error message, this handles + // things like [,,,] as an array value. + return fs.WrapErr(fmt.Errorf("wanted value token, but got token: %v", tok)) + } + continue + } else { + wantVal = true + } + + /* handler: tmp_uj__Indices type=int kind=int quoted=false*/ + + { + if tok != fflib.FFTok_integer && tok != fflib.FFTok_null { + return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for int", tok)) + } + } + + { + + if tok == fflib.FFTok_null { + + } else { + + tval, err := fflib.ParseInt(fs.Output.Bytes(), 10, 64) + + if err != nil { + return fs.WrapErr(err) + } + + tmp_uj__Indices = int(tval) + + } + } + + uj.Indices = append(uj.Indices, tmp_uj__Indices) + wantVal = false + } + } + } + + state = fflib.FFParse_after_value + goto mainparse + +handle_URL: + + /* handler: uj.URL type=string kind=string quoted=false*/ + + { + + { + if tok != fflib.FFTok_string && tok != fflib.FFTok_null { + return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for string", tok)) + } + } + + if tok == fflib.FFTok_null { + + } else { + + outBuf := fs.Output.Bytes() + + uj.URL = string(string(outBuf)) + + } + } + + state = fflib.FFParse_after_value + goto mainparse + +wantedvalue: + return fs.WrapErr(fmt.Errorf("wanted value token, but got token: %v", tok)) +wrongtokenerror: + return fs.WrapErr(fmt.Errorf("ffjson: wanted token: %v, but got token: %v output=%s", wantedTok, tok, fs.Output.String())) +tokerror: + if fs.BigError != nil { + return fs.WrapErr(fs.BigError) + } + err = fs.Error.ToError() + if err != nil { + return fs.WrapErr(err) + } + panic("ffjson-generated: unreachable, please report bug.") +done: + return nil +} + +func (mj *User) MarshalJSON() ([]byte, error) { + var buf fflib.Buffer + if mj == nil { + buf.WriteString("null") + return buf.Bytes(), nil + } + err := mj.MarshalJSONBuf(&buf) + if err != nil { + return nil, err + } + return buf.Bytes(), nil +} +func (mj *User) MarshalJSONBuf(buf fflib.EncodingBuffer) error { + if mj == nil { + buf.WriteString("null") + return nil + } + var err error + var obj []byte + _ = obj + _ = err + if mj.ContributorsEnabled { + buf.WriteString(`{"contributors_enabled":true`) + } else { + buf.WriteString(`{"contributors_enabled":false`) + } + buf.WriteString(`,"created_at":`) + fflib.WriteJsonString(buf, string(mj.CreatedAt)) + if mj.DefaultProfile { + buf.WriteString(`,"default_profile":true`) + } else { + buf.WriteString(`,"default_profile":false`) + } + if mj.DefaultProfileImage { + buf.WriteString(`,"default_profile_image":true`) + } else { + buf.WriteString(`,"default_profile_image":false`) + } + buf.WriteString(`,"description":`) + fflib.WriteJsonString(buf, string(mj.Description)) + buf.WriteString(`,"entities":`) + + { + + err = mj.Entities.MarshalJSONBuf(buf) + if err != nil { + return err + } + + } + buf.WriteString(`,"favourites_count":`) + fflib.FormatBits2(buf, uint64(mj.FavouritesCount), 10, mj.FavouritesCount < 0) + if mj.FollowRequestSent != nil { + buf.WriteString(`,"follow_request_sent":`) + fflib.WriteJsonString(buf, string(*mj.FollowRequestSent)) + } else { + buf.WriteString(`,"follow_request_sent":null`) + } + buf.WriteString(`,"followers_count":`) + fflib.FormatBits2(buf, uint64(mj.FollowersCount), 10, mj.FollowersCount < 0) + if mj.Following != nil { + buf.WriteString(`,"following":`) + fflib.WriteJsonString(buf, string(*mj.Following)) + } else { + buf.WriteString(`,"following":null`) + } + buf.WriteString(`,"friends_count":`) + fflib.FormatBits2(buf, uint64(mj.FriendsCount), 10, mj.FriendsCount < 0) + if mj.GeoEnabled { + buf.WriteString(`,"geo_enabled":true`) + } else { + buf.WriteString(`,"geo_enabled":false`) + } + buf.WriteString(`,"id":`) + fflib.FormatBits2(buf, uint64(mj.ID), 10, mj.ID < 0) + buf.WriteString(`,"id_str":`) + fflib.WriteJsonString(buf, string(mj.IDStr)) + if mj.IsTranslator { + buf.WriteString(`,"is_translator":true`) + } else { + buf.WriteString(`,"is_translator":false`) + } + buf.WriteString(`,"lang":`) + fflib.WriteJsonString(buf, string(mj.Lang)) + buf.WriteString(`,"listed_count":`) + fflib.FormatBits2(buf, uint64(mj.ListedCount), 10, mj.ListedCount < 0) + buf.WriteString(`,"location":`) + fflib.WriteJsonString(buf, string(mj.Location)) + buf.WriteString(`,"name":`) + fflib.WriteJsonString(buf, string(mj.Name)) + if mj.Notifications != nil { + buf.WriteString(`,"notifications":`) + fflib.WriteJsonString(buf, string(*mj.Notifications)) + } else { + buf.WriteString(`,"notifications":null`) + } + buf.WriteString(`,"profile_background_color":`) + fflib.WriteJsonString(buf, string(mj.ProfileBackgroundColor)) + buf.WriteString(`,"profile_background_image_url":`) + fflib.WriteJsonString(buf, string(mj.ProfileBackgroundImageURL)) + buf.WriteString(`,"profile_background_image_url_https":`) + fflib.WriteJsonString(buf, string(mj.ProfileBackgroundImageURLHTTPS)) + if mj.ProfileBackgroundTile { + buf.WriteString(`,"profile_background_tile":true`) + } else { + buf.WriteString(`,"profile_background_tile":false`) + } + buf.WriteString(`,"profile_image_url":`) + fflib.WriteJsonString(buf, string(mj.ProfileImageURL)) + buf.WriteString(`,"profile_image_url_https":`) + fflib.WriteJsonString(buf, string(mj.ProfileImageURLHTTPS)) + buf.WriteString(`,"profile_link_color":`) + fflib.WriteJsonString(buf, string(mj.ProfileLinkColor)) + buf.WriteString(`,"profile_sidebar_border_color":`) + fflib.WriteJsonString(buf, string(mj.ProfileSidebarBorderColor)) + buf.WriteString(`,"profile_sidebar_fill_color":`) + fflib.WriteJsonString(buf, string(mj.ProfileSidebarFillColor)) + buf.WriteString(`,"profile_text_color":`) + fflib.WriteJsonString(buf, string(mj.ProfileTextColor)) + if mj.ProfileUseBackgroundImage { + buf.WriteString(`,"profile_use_background_image":true`) + } else { + buf.WriteString(`,"profile_use_background_image":false`) + } + if mj.Protected { + buf.WriteString(`,"protected":true`) + } else { + buf.WriteString(`,"protected":false`) + } + buf.WriteString(`,"screen_name":`) + fflib.WriteJsonString(buf, string(mj.ScreenName)) + if mj.ShowAllInlineMedia { + buf.WriteString(`,"show_all_inline_media":true`) + } else { + buf.WriteString(`,"show_all_inline_media":false`) + } + buf.WriteString(`,"statuses_count":`) + fflib.FormatBits2(buf, uint64(mj.StatusesCount), 10, mj.StatusesCount < 0) + buf.WriteString(`,"time_zone":`) + fflib.WriteJsonString(buf, string(mj.TimeZone)) + if mj.URL != nil { + buf.WriteString(`,"url":`) + fflib.WriteJsonString(buf, string(*mj.URL)) + } else { + buf.WriteString(`,"url":null`) + } + buf.WriteString(`,"utc_offset":`) + fflib.FormatBits2(buf, uint64(mj.UtcOffset), 10, mj.UtcOffset < 0) + if mj.Verified { + buf.WriteString(`,"verified":true`) + } else { + buf.WriteString(`,"verified":false`) + } + buf.WriteByte('}') + return nil +} + +const ( + ffj_t_Userbase = iota + ffj_t_Userno_such_key + + ffj_t_User_ContributorsEnabled + + ffj_t_User_CreatedAt + + ffj_t_User_DefaultProfile + + ffj_t_User_DefaultProfileImage + + ffj_t_User_Description + + ffj_t_User_Entities + + ffj_t_User_FavouritesCount + + ffj_t_User_FollowRequestSent + + ffj_t_User_FollowersCount + + ffj_t_User_Following + + ffj_t_User_FriendsCount + + ffj_t_User_GeoEnabled + + ffj_t_User_ID + + ffj_t_User_IDStr + + ffj_t_User_IsTranslator + + ffj_t_User_Lang + + ffj_t_User_ListedCount + + ffj_t_User_Location + + ffj_t_User_Name + + ffj_t_User_Notifications + + ffj_t_User_ProfileBackgroundColor + + ffj_t_User_ProfileBackgroundImageURL + + ffj_t_User_ProfileBackgroundImageURLHTTPS + + ffj_t_User_ProfileBackgroundTile + + ffj_t_User_ProfileImageURL + + ffj_t_User_ProfileImageURLHTTPS + + ffj_t_User_ProfileLinkColor + + ffj_t_User_ProfileSidebarBorderColor + + ffj_t_User_ProfileSidebarFillColor + + ffj_t_User_ProfileTextColor + + ffj_t_User_ProfileUseBackgroundImage + + ffj_t_User_Protected + + ffj_t_User_ScreenName + + ffj_t_User_ShowAllInlineMedia + + ffj_t_User_StatusesCount + + ffj_t_User_TimeZone + + ffj_t_User_URL + + ffj_t_User_UtcOffset + + ffj_t_User_Verified +) + +var ffj_key_User_ContributorsEnabled = []byte("contributors_enabled") + +var ffj_key_User_CreatedAt = []byte("created_at") + +var ffj_key_User_DefaultProfile = []byte("default_profile") + +var ffj_key_User_DefaultProfileImage = []byte("default_profile_image") + +var ffj_key_User_Description = []byte("description") + +var ffj_key_User_Entities = []byte("entities") + +var ffj_key_User_FavouritesCount = []byte("favourites_count") + +var ffj_key_User_FollowRequestSent = []byte("follow_request_sent") + +var ffj_key_User_FollowersCount = []byte("followers_count") + +var ffj_key_User_Following = []byte("following") + +var ffj_key_User_FriendsCount = []byte("friends_count") + +var ffj_key_User_GeoEnabled = []byte("geo_enabled") + +var ffj_key_User_ID = []byte("id") + +var ffj_key_User_IDStr = []byte("id_str") + +var ffj_key_User_IsTranslator = []byte("is_translator") + +var ffj_key_User_Lang = []byte("lang") + +var ffj_key_User_ListedCount = []byte("listed_count") + +var ffj_key_User_Location = []byte("location") + +var ffj_key_User_Name = []byte("name") + +var ffj_key_User_Notifications = []byte("notifications") + +var ffj_key_User_ProfileBackgroundColor = []byte("profile_background_color") + +var ffj_key_User_ProfileBackgroundImageURL = []byte("profile_background_image_url") + +var ffj_key_User_ProfileBackgroundImageURLHTTPS = []byte("profile_background_image_url_https") + +var ffj_key_User_ProfileBackgroundTile = []byte("profile_background_tile") + +var ffj_key_User_ProfileImageURL = []byte("profile_image_url") + +var ffj_key_User_ProfileImageURLHTTPS = []byte("profile_image_url_https") + +var ffj_key_User_ProfileLinkColor = []byte("profile_link_color") + +var ffj_key_User_ProfileSidebarBorderColor = []byte("profile_sidebar_border_color") + +var ffj_key_User_ProfileSidebarFillColor = []byte("profile_sidebar_fill_color") + +var ffj_key_User_ProfileTextColor = []byte("profile_text_color") + +var ffj_key_User_ProfileUseBackgroundImage = []byte("profile_use_background_image") + +var ffj_key_User_Protected = []byte("protected") + +var ffj_key_User_ScreenName = []byte("screen_name") + +var ffj_key_User_ShowAllInlineMedia = []byte("show_all_inline_media") + +var ffj_key_User_StatusesCount = []byte("statuses_count") + +var ffj_key_User_TimeZone = []byte("time_zone") + +var ffj_key_User_URL = []byte("url") + +var ffj_key_User_UtcOffset = []byte("utc_offset") + +var ffj_key_User_Verified = []byte("verified") + +func (uj *User) UnmarshalJSON(input []byte) error { + fs := fflib.NewFFLexer(input) + return uj.UnmarshalJSONFFLexer(fs, fflib.FFParse_map_start) +} + +func (uj *User) UnmarshalJSONFFLexer(fs *fflib.FFLexer, state fflib.FFParseState) error { + var err error = nil + currentKey := ffj_t_Userbase + _ = currentKey + tok := fflib.FFTok_init + wantedTok := fflib.FFTok_init + +mainparse: + for { + tok = fs.Scan() + // println(fmt.Sprintf("debug: tok: %v state: %v", tok, state)) + if tok == fflib.FFTok_error { + goto tokerror + } + + switch state { + + case fflib.FFParse_map_start: + if tok != fflib.FFTok_left_bracket { + wantedTok = fflib.FFTok_left_bracket + goto wrongtokenerror + } + state = fflib.FFParse_want_key + continue + + case fflib.FFParse_after_value: + if tok == fflib.FFTok_comma { + state = fflib.FFParse_want_key + } else if tok == fflib.FFTok_right_bracket { + goto done + } else { + wantedTok = fflib.FFTok_comma + goto wrongtokenerror + } + + case fflib.FFParse_want_key: + // json {} ended. goto exit. woo. + if tok == fflib.FFTok_right_bracket { + goto done + } + if tok != fflib.FFTok_string { + wantedTok = fflib.FFTok_string + goto wrongtokenerror + } + + kn := fs.Output.Bytes() + if len(kn) <= 0 { + // "" case. hrm. + currentKey = ffj_t_Userno_such_key + state = fflib.FFParse_want_colon + goto mainparse + } else { + switch kn[0] { + + case 'c': + + if bytes.Equal(ffj_key_User_ContributorsEnabled, kn) { + currentKey = ffj_t_User_ContributorsEnabled + state = fflib.FFParse_want_colon + goto mainparse + + } else if bytes.Equal(ffj_key_User_CreatedAt, kn) { + currentKey = ffj_t_User_CreatedAt + state = fflib.FFParse_want_colon + goto mainparse + } + + case 'd': + + if bytes.Equal(ffj_key_User_DefaultProfile, kn) { + currentKey = ffj_t_User_DefaultProfile + state = fflib.FFParse_want_colon + goto mainparse + + } else if bytes.Equal(ffj_key_User_DefaultProfileImage, kn) { + currentKey = ffj_t_User_DefaultProfileImage + state = fflib.FFParse_want_colon + goto mainparse + + } else if bytes.Equal(ffj_key_User_Description, kn) { + currentKey = ffj_t_User_Description + state = fflib.FFParse_want_colon + goto mainparse + } + + case 'e': + + if bytes.Equal(ffj_key_User_Entities, kn) { + currentKey = ffj_t_User_Entities + state = fflib.FFParse_want_colon + goto mainparse + } + + case 'f': + + if bytes.Equal(ffj_key_User_FavouritesCount, kn) { + currentKey = ffj_t_User_FavouritesCount + state = fflib.FFParse_want_colon + goto mainparse + + } else if bytes.Equal(ffj_key_User_FollowRequestSent, kn) { + currentKey = ffj_t_User_FollowRequestSent + state = fflib.FFParse_want_colon + goto mainparse + + } else if bytes.Equal(ffj_key_User_FollowersCount, kn) { + currentKey = ffj_t_User_FollowersCount + state = fflib.FFParse_want_colon + goto mainparse + + } else if bytes.Equal(ffj_key_User_Following, kn) { + currentKey = ffj_t_User_Following + state = fflib.FFParse_want_colon + goto mainparse + + } else if bytes.Equal(ffj_key_User_FriendsCount, kn) { + currentKey = ffj_t_User_FriendsCount + state = fflib.FFParse_want_colon + goto mainparse + } + + case 'g': + + if bytes.Equal(ffj_key_User_GeoEnabled, kn) { + currentKey = ffj_t_User_GeoEnabled + state = fflib.FFParse_want_colon + goto mainparse + } + + case 'i': + + if bytes.Equal(ffj_key_User_ID, kn) { + currentKey = ffj_t_User_ID + state = fflib.FFParse_want_colon + goto mainparse + + } else if bytes.Equal(ffj_key_User_IDStr, kn) { + currentKey = ffj_t_User_IDStr + state = fflib.FFParse_want_colon + goto mainparse + + } else if bytes.Equal(ffj_key_User_IsTranslator, kn) { + currentKey = ffj_t_User_IsTranslator + state = fflib.FFParse_want_colon + goto mainparse + } + + case 'l': + + if bytes.Equal(ffj_key_User_Lang, kn) { + currentKey = ffj_t_User_Lang + state = fflib.FFParse_want_colon + goto mainparse + + } else if bytes.Equal(ffj_key_User_ListedCount, kn) { + currentKey = ffj_t_User_ListedCount + state = fflib.FFParse_want_colon + goto mainparse + + } else if bytes.Equal(ffj_key_User_Location, kn) { + currentKey = ffj_t_User_Location + state = fflib.FFParse_want_colon + goto mainparse + } + + case 'n': + + if bytes.Equal(ffj_key_User_Name, kn) { + currentKey = ffj_t_User_Name + state = fflib.FFParse_want_colon + goto mainparse + + } else if bytes.Equal(ffj_key_User_Notifications, kn) { + currentKey = ffj_t_User_Notifications + state = fflib.FFParse_want_colon + goto mainparse + } + + case 'p': + + if bytes.Equal(ffj_key_User_ProfileBackgroundColor, kn) { + currentKey = ffj_t_User_ProfileBackgroundColor + state = fflib.FFParse_want_colon + goto mainparse + + } else if bytes.Equal(ffj_key_User_ProfileBackgroundImageURL, kn) { + currentKey = ffj_t_User_ProfileBackgroundImageURL + state = fflib.FFParse_want_colon + goto mainparse + + } else if bytes.Equal(ffj_key_User_ProfileBackgroundImageURLHTTPS, kn) { + currentKey = ffj_t_User_ProfileBackgroundImageURLHTTPS + state = fflib.FFParse_want_colon + goto mainparse + + } else if bytes.Equal(ffj_key_User_ProfileBackgroundTile, kn) { + currentKey = ffj_t_User_ProfileBackgroundTile + state = fflib.FFParse_want_colon + goto mainparse + + } else if bytes.Equal(ffj_key_User_ProfileImageURL, kn) { + currentKey = ffj_t_User_ProfileImageURL + state = fflib.FFParse_want_colon + goto mainparse + + } else if bytes.Equal(ffj_key_User_ProfileImageURLHTTPS, kn) { + currentKey = ffj_t_User_ProfileImageURLHTTPS + state = fflib.FFParse_want_colon + goto mainparse + + } else if bytes.Equal(ffj_key_User_ProfileLinkColor, kn) { + currentKey = ffj_t_User_ProfileLinkColor + state = fflib.FFParse_want_colon + goto mainparse + + } else if bytes.Equal(ffj_key_User_ProfileSidebarBorderColor, kn) { + currentKey = ffj_t_User_ProfileSidebarBorderColor + state = fflib.FFParse_want_colon + goto mainparse + + } else if bytes.Equal(ffj_key_User_ProfileSidebarFillColor, kn) { + currentKey = ffj_t_User_ProfileSidebarFillColor + state = fflib.FFParse_want_colon + goto mainparse + + } else if bytes.Equal(ffj_key_User_ProfileTextColor, kn) { + currentKey = ffj_t_User_ProfileTextColor + state = fflib.FFParse_want_colon + goto mainparse + + } else if bytes.Equal(ffj_key_User_ProfileUseBackgroundImage, kn) { + currentKey = ffj_t_User_ProfileUseBackgroundImage + state = fflib.FFParse_want_colon + goto mainparse + + } else if bytes.Equal(ffj_key_User_Protected, kn) { + currentKey = ffj_t_User_Protected + state = fflib.FFParse_want_colon + goto mainparse + } + + case 's': + + if bytes.Equal(ffj_key_User_ScreenName, kn) { + currentKey = ffj_t_User_ScreenName + state = fflib.FFParse_want_colon + goto mainparse + + } else if bytes.Equal(ffj_key_User_ShowAllInlineMedia, kn) { + currentKey = ffj_t_User_ShowAllInlineMedia + state = fflib.FFParse_want_colon + goto mainparse + + } else if bytes.Equal(ffj_key_User_StatusesCount, kn) { + currentKey = ffj_t_User_StatusesCount + state = fflib.FFParse_want_colon + goto mainparse + } + + case 't': + + if bytes.Equal(ffj_key_User_TimeZone, kn) { + currentKey = ffj_t_User_TimeZone + state = fflib.FFParse_want_colon + goto mainparse + } + + case 'u': + + if bytes.Equal(ffj_key_User_URL, kn) { + currentKey = ffj_t_User_URL + state = fflib.FFParse_want_colon + goto mainparse + + } else if bytes.Equal(ffj_key_User_UtcOffset, kn) { + currentKey = ffj_t_User_UtcOffset + state = fflib.FFParse_want_colon + goto mainparse + } + + case 'v': + + if bytes.Equal(ffj_key_User_Verified, kn) { + currentKey = ffj_t_User_Verified + state = fflib.FFParse_want_colon + goto mainparse + } + + } + + if fflib.SimpleLetterEqualFold(ffj_key_User_Verified, kn) { + currentKey = ffj_t_User_Verified + state = fflib.FFParse_want_colon + goto mainparse + } + + if fflib.EqualFoldRight(ffj_key_User_UtcOffset, kn) { + currentKey = ffj_t_User_UtcOffset + state = fflib.FFParse_want_colon + goto mainparse + } + + if fflib.SimpleLetterEqualFold(ffj_key_User_URL, kn) { + currentKey = ffj_t_User_URL + state = fflib.FFParse_want_colon + goto mainparse + } + + if fflib.AsciiEqualFold(ffj_key_User_TimeZone, kn) { + currentKey = ffj_t_User_TimeZone + state = fflib.FFParse_want_colon + goto mainparse + } + + if fflib.EqualFoldRight(ffj_key_User_StatusesCount, kn) { + currentKey = ffj_t_User_StatusesCount + state = fflib.FFParse_want_colon + goto mainparse + } + + if fflib.EqualFoldRight(ffj_key_User_ShowAllInlineMedia, kn) { + currentKey = ffj_t_User_ShowAllInlineMedia + state = fflib.FFParse_want_colon + goto mainparse + } + + if fflib.EqualFoldRight(ffj_key_User_ScreenName, kn) { + currentKey = ffj_t_User_ScreenName + state = fflib.FFParse_want_colon + goto mainparse + } + + if fflib.SimpleLetterEqualFold(ffj_key_User_Protected, kn) { + currentKey = ffj_t_User_Protected + state = fflib.FFParse_want_colon + goto mainparse + } + + if fflib.EqualFoldRight(ffj_key_User_ProfileUseBackgroundImage, kn) { + currentKey = ffj_t_User_ProfileUseBackgroundImage + state = fflib.FFParse_want_colon + goto mainparse + } + + if fflib.AsciiEqualFold(ffj_key_User_ProfileTextColor, kn) { + currentKey = ffj_t_User_ProfileTextColor + state = fflib.FFParse_want_colon + goto mainparse + } + + if fflib.EqualFoldRight(ffj_key_User_ProfileSidebarFillColor, kn) { + currentKey = ffj_t_User_ProfileSidebarFillColor + state = fflib.FFParse_want_colon + goto mainparse + } + + if fflib.EqualFoldRight(ffj_key_User_ProfileSidebarBorderColor, kn) { + currentKey = ffj_t_User_ProfileSidebarBorderColor + state = fflib.FFParse_want_colon + goto mainparse + } + + if fflib.EqualFoldRight(ffj_key_User_ProfileLinkColor, kn) { + currentKey = ffj_t_User_ProfileLinkColor + state = fflib.FFParse_want_colon + goto mainparse + } + + if fflib.EqualFoldRight(ffj_key_User_ProfileImageURLHTTPS, kn) { + currentKey = ffj_t_User_ProfileImageURLHTTPS + state = fflib.FFParse_want_colon + goto mainparse + } + + if fflib.AsciiEqualFold(ffj_key_User_ProfileImageURL, kn) { + currentKey = ffj_t_User_ProfileImageURL + state = fflib.FFParse_want_colon + goto mainparse + } + + if fflib.EqualFoldRight(ffj_key_User_ProfileBackgroundTile, kn) { + currentKey = ffj_t_User_ProfileBackgroundTile + state = fflib.FFParse_want_colon + goto mainparse + } + + if fflib.EqualFoldRight(ffj_key_User_ProfileBackgroundImageURLHTTPS, kn) { + currentKey = ffj_t_User_ProfileBackgroundImageURLHTTPS + state = fflib.FFParse_want_colon + goto mainparse + } + + if fflib.EqualFoldRight(ffj_key_User_ProfileBackgroundImageURL, kn) { + currentKey = ffj_t_User_ProfileBackgroundImageURL + state = fflib.FFParse_want_colon + goto mainparse + } + + if fflib.EqualFoldRight(ffj_key_User_ProfileBackgroundColor, kn) { + currentKey = ffj_t_User_ProfileBackgroundColor + state = fflib.FFParse_want_colon + goto mainparse + } + + if fflib.EqualFoldRight(ffj_key_User_Notifications, kn) { + currentKey = ffj_t_User_Notifications + state = fflib.FFParse_want_colon + goto mainparse + } + + if fflib.SimpleLetterEqualFold(ffj_key_User_Name, kn) { + currentKey = ffj_t_User_Name + state = fflib.FFParse_want_colon + goto mainparse + } + + if fflib.SimpleLetterEqualFold(ffj_key_User_Location, kn) { + currentKey = ffj_t_User_Location + state = fflib.FFParse_want_colon + goto mainparse + } + + if fflib.EqualFoldRight(ffj_key_User_ListedCount, kn) { + currentKey = ffj_t_User_ListedCount + state = fflib.FFParse_want_colon + goto mainparse + } + + if fflib.SimpleLetterEqualFold(ffj_key_User_Lang, kn) { + currentKey = ffj_t_User_Lang + state = fflib.FFParse_want_colon + goto mainparse + } + + if fflib.EqualFoldRight(ffj_key_User_IsTranslator, kn) { + currentKey = ffj_t_User_IsTranslator + state = fflib.FFParse_want_colon + goto mainparse + } + + if fflib.EqualFoldRight(ffj_key_User_IDStr, kn) { + currentKey = ffj_t_User_IDStr + state = fflib.FFParse_want_colon + goto mainparse + } + + if fflib.SimpleLetterEqualFold(ffj_key_User_ID, kn) { + currentKey = ffj_t_User_ID + state = fflib.FFParse_want_colon + goto mainparse + } + + if fflib.AsciiEqualFold(ffj_key_User_GeoEnabled, kn) { + currentKey = ffj_t_User_GeoEnabled + state = fflib.FFParse_want_colon + goto mainparse + } + + if fflib.EqualFoldRight(ffj_key_User_FriendsCount, kn) { + currentKey = ffj_t_User_FriendsCount + state = fflib.FFParse_want_colon + goto mainparse + } + + if fflib.SimpleLetterEqualFold(ffj_key_User_Following, kn) { + currentKey = ffj_t_User_Following + state = fflib.FFParse_want_colon + goto mainparse + } + + if fflib.EqualFoldRight(ffj_key_User_FollowersCount, kn) { + currentKey = ffj_t_User_FollowersCount + state = fflib.FFParse_want_colon + goto mainparse + } + + if fflib.EqualFoldRight(ffj_key_User_FollowRequestSent, kn) { + currentKey = ffj_t_User_FollowRequestSent + state = fflib.FFParse_want_colon + goto mainparse + } + + if fflib.EqualFoldRight(ffj_key_User_FavouritesCount, kn) { + currentKey = ffj_t_User_FavouritesCount + state = fflib.FFParse_want_colon + goto mainparse + } + + if fflib.EqualFoldRight(ffj_key_User_Entities, kn) { + currentKey = ffj_t_User_Entities + state = fflib.FFParse_want_colon + goto mainparse + } + + if fflib.EqualFoldRight(ffj_key_User_Description, kn) { + currentKey = ffj_t_User_Description + state = fflib.FFParse_want_colon + goto mainparse + } + + if fflib.AsciiEqualFold(ffj_key_User_DefaultProfileImage, kn) { + currentKey = ffj_t_User_DefaultProfileImage + state = fflib.FFParse_want_colon + goto mainparse + } + + if fflib.AsciiEqualFold(ffj_key_User_DefaultProfile, kn) { + currentKey = ffj_t_User_DefaultProfile + state = fflib.FFParse_want_colon + goto mainparse + } + + if fflib.AsciiEqualFold(ffj_key_User_CreatedAt, kn) { + currentKey = ffj_t_User_CreatedAt + state = fflib.FFParse_want_colon + goto mainparse + } + + if fflib.EqualFoldRight(ffj_key_User_ContributorsEnabled, kn) { + currentKey = ffj_t_User_ContributorsEnabled + state = fflib.FFParse_want_colon + goto mainparse + } + + currentKey = ffj_t_Userno_such_key + state = fflib.FFParse_want_colon + goto mainparse + } + + case fflib.FFParse_want_colon: + if tok != fflib.FFTok_colon { + wantedTok = fflib.FFTok_colon + goto wrongtokenerror + } + state = fflib.FFParse_want_value + continue + case fflib.FFParse_want_value: + + if tok == fflib.FFTok_left_brace || tok == fflib.FFTok_left_bracket || tok == fflib.FFTok_integer || tok == fflib.FFTok_double || tok == fflib.FFTok_string || tok == fflib.FFTok_bool || tok == fflib.FFTok_null { + switch currentKey { + + case ffj_t_User_ContributorsEnabled: + goto handle_ContributorsEnabled + + case ffj_t_User_CreatedAt: + goto handle_CreatedAt + + case ffj_t_User_DefaultProfile: + goto handle_DefaultProfile + + case ffj_t_User_DefaultProfileImage: + goto handle_DefaultProfileImage + + case ffj_t_User_Description: + goto handle_Description + + case ffj_t_User_Entities: + goto handle_Entities + + case ffj_t_User_FavouritesCount: + goto handle_FavouritesCount + + case ffj_t_User_FollowRequestSent: + goto handle_FollowRequestSent + + case ffj_t_User_FollowersCount: + goto handle_FollowersCount + + case ffj_t_User_Following: + goto handle_Following + + case ffj_t_User_FriendsCount: + goto handle_FriendsCount + + case ffj_t_User_GeoEnabled: + goto handle_GeoEnabled + + case ffj_t_User_ID: + goto handle_ID + + case ffj_t_User_IDStr: + goto handle_IDStr + + case ffj_t_User_IsTranslator: + goto handle_IsTranslator + + case ffj_t_User_Lang: + goto handle_Lang + + case ffj_t_User_ListedCount: + goto handle_ListedCount + + case ffj_t_User_Location: + goto handle_Location + + case ffj_t_User_Name: + goto handle_Name + + case ffj_t_User_Notifications: + goto handle_Notifications + + case ffj_t_User_ProfileBackgroundColor: + goto handle_ProfileBackgroundColor + + case ffj_t_User_ProfileBackgroundImageURL: + goto handle_ProfileBackgroundImageURL + + case ffj_t_User_ProfileBackgroundImageURLHTTPS: + goto handle_ProfileBackgroundImageURLHTTPS + + case ffj_t_User_ProfileBackgroundTile: + goto handle_ProfileBackgroundTile + + case ffj_t_User_ProfileImageURL: + goto handle_ProfileImageURL + + case ffj_t_User_ProfileImageURLHTTPS: + goto handle_ProfileImageURLHTTPS + + case ffj_t_User_ProfileLinkColor: + goto handle_ProfileLinkColor + + case ffj_t_User_ProfileSidebarBorderColor: + goto handle_ProfileSidebarBorderColor + + case ffj_t_User_ProfileSidebarFillColor: + goto handle_ProfileSidebarFillColor + + case ffj_t_User_ProfileTextColor: + goto handle_ProfileTextColor + + case ffj_t_User_ProfileUseBackgroundImage: + goto handle_ProfileUseBackgroundImage + + case ffj_t_User_Protected: + goto handle_Protected + + case ffj_t_User_ScreenName: + goto handle_ScreenName + + case ffj_t_User_ShowAllInlineMedia: + goto handle_ShowAllInlineMedia + + case ffj_t_User_StatusesCount: + goto handle_StatusesCount + + case ffj_t_User_TimeZone: + goto handle_TimeZone + + case ffj_t_User_URL: + goto handle_URL + + case ffj_t_User_UtcOffset: + goto handle_UtcOffset + + case ffj_t_User_Verified: + goto handle_Verified + + case ffj_t_Userno_such_key: + err = fs.SkipField(tok) + if err != nil { + return fs.WrapErr(err) + } + state = fflib.FFParse_after_value + goto mainparse + } + } else { + goto wantedvalue + } + } + } + +handle_ContributorsEnabled: + + /* handler: uj.ContributorsEnabled type=bool kind=bool quoted=false*/ + + { + if tok != fflib.FFTok_bool && tok != fflib.FFTok_null { + return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for bool", tok)) + } + } + + { + if tok == fflib.FFTok_null { + + } else { + tmpb := fs.Output.Bytes() + + if bytes.Compare([]byte{'t', 'r', 'u', 'e'}, tmpb) == 0 { + + uj.ContributorsEnabled = true + + } else if bytes.Compare([]byte{'f', 'a', 'l', 's', 'e'}, tmpb) == 0 { + + uj.ContributorsEnabled = false + + } else { + err = errors.New("unexpected bytes for true/false value") + return fs.WrapErr(err) + } + + } + } + + state = fflib.FFParse_after_value + goto mainparse + +handle_CreatedAt: + + /* handler: uj.CreatedAt type=string kind=string quoted=false*/ + + { + + { + if tok != fflib.FFTok_string && tok != fflib.FFTok_null { + return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for string", tok)) + } + } + + if tok == fflib.FFTok_null { + + } else { + + outBuf := fs.Output.Bytes() + + uj.CreatedAt = string(string(outBuf)) + + } + } + + state = fflib.FFParse_after_value + goto mainparse + +handle_DefaultProfile: + + /* handler: uj.DefaultProfile type=bool kind=bool quoted=false*/ + + { + if tok != fflib.FFTok_bool && tok != fflib.FFTok_null { + return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for bool", tok)) + } + } + + { + if tok == fflib.FFTok_null { + + } else { + tmpb := fs.Output.Bytes() + + if bytes.Compare([]byte{'t', 'r', 'u', 'e'}, tmpb) == 0 { + + uj.DefaultProfile = true + + } else if bytes.Compare([]byte{'f', 'a', 'l', 's', 'e'}, tmpb) == 0 { + + uj.DefaultProfile = false + + } else { + err = errors.New("unexpected bytes for true/false value") + return fs.WrapErr(err) + } + + } + } + + state = fflib.FFParse_after_value + goto mainparse + +handle_DefaultProfileImage: + + /* handler: uj.DefaultProfileImage type=bool kind=bool quoted=false*/ + + { + if tok != fflib.FFTok_bool && tok != fflib.FFTok_null { + return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for bool", tok)) + } + } + + { + if tok == fflib.FFTok_null { + + } else { + tmpb := fs.Output.Bytes() + + if bytes.Compare([]byte{'t', 'r', 'u', 'e'}, tmpb) == 0 { + + uj.DefaultProfileImage = true + + } else if bytes.Compare([]byte{'f', 'a', 'l', 's', 'e'}, tmpb) == 0 { + + uj.DefaultProfileImage = false + + } else { + err = errors.New("unexpected bytes for true/false value") + return fs.WrapErr(err) + } + + } + } + + state = fflib.FFParse_after_value + goto mainparse + +handle_Description: + + /* handler: uj.Description type=string kind=string quoted=false*/ + + { + + { + if tok != fflib.FFTok_string && tok != fflib.FFTok_null { + return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for string", tok)) + } + } + + if tok == fflib.FFTok_null { + + } else { + + outBuf := fs.Output.Bytes() + + uj.Description = string(string(outBuf)) + + } + } + + state = fflib.FFParse_after_value + goto mainparse + +handle_Entities: + + /* handler: uj.Entities type=benchmark.UserEntities kind=struct quoted=false*/ + + { + if tok == fflib.FFTok_null { + + state = fflib.FFParse_after_value + goto mainparse + } + + err = uj.Entities.UnmarshalJSONFFLexer(fs, fflib.FFParse_want_key) + if err != nil { + return err + } + state = fflib.FFParse_after_value + } + + state = fflib.FFParse_after_value + goto mainparse + +handle_FavouritesCount: + + /* handler: uj.FavouritesCount type=int kind=int quoted=false*/ + + { + if tok != fflib.FFTok_integer && tok != fflib.FFTok_null { + return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for int", tok)) + } + } + + { + + if tok == fflib.FFTok_null { + + } else { + + tval, err := fflib.ParseInt(fs.Output.Bytes(), 10, 64) + + if err != nil { + return fs.WrapErr(err) + } + + uj.FavouritesCount = int(tval) + + } + } + + state = fflib.FFParse_after_value + goto mainparse + +handle_FollowRequestSent: + + /* handler: uj.FollowRequestSent type=string kind=string quoted=false*/ + + { + + { + if tok != fflib.FFTok_string && tok != fflib.FFTok_null { + return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for string", tok)) + } + } + + if tok == fflib.FFTok_null { + + uj.FollowRequestSent = nil + + } else { + + var tval string + outBuf := fs.Output.Bytes() + + tval = string(string(outBuf)) + uj.FollowRequestSent = &tval + + } + } + + state = fflib.FFParse_after_value + goto mainparse + +handle_FollowersCount: + + /* handler: uj.FollowersCount type=int kind=int quoted=false*/ + + { + if tok != fflib.FFTok_integer && tok != fflib.FFTok_null { + return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for int", tok)) + } + } + + { + + if tok == fflib.FFTok_null { + + } else { + + tval, err := fflib.ParseInt(fs.Output.Bytes(), 10, 64) + + if err != nil { + return fs.WrapErr(err) + } + + uj.FollowersCount = int(tval) + + } + } + + state = fflib.FFParse_after_value + goto mainparse + +handle_Following: + + /* handler: uj.Following type=string kind=string quoted=false*/ + + { + + { + if tok != fflib.FFTok_string && tok != fflib.FFTok_null { + return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for string", tok)) + } + } + + if tok == fflib.FFTok_null { + + uj.Following = nil + + } else { + + var tval string + outBuf := fs.Output.Bytes() + + tval = string(string(outBuf)) + uj.Following = &tval + + } + } + + state = fflib.FFParse_after_value + goto mainparse + +handle_FriendsCount: + + /* handler: uj.FriendsCount type=int kind=int quoted=false*/ + + { + if tok != fflib.FFTok_integer && tok != fflib.FFTok_null { + return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for int", tok)) + } + } + + { + + if tok == fflib.FFTok_null { + + } else { + + tval, err := fflib.ParseInt(fs.Output.Bytes(), 10, 64) + + if err != nil { + return fs.WrapErr(err) + } + + uj.FriendsCount = int(tval) + + } + } + + state = fflib.FFParse_after_value + goto mainparse + +handle_GeoEnabled: + + /* handler: uj.GeoEnabled type=bool kind=bool quoted=false*/ + + { + if tok != fflib.FFTok_bool && tok != fflib.FFTok_null { + return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for bool", tok)) + } + } + + { + if tok == fflib.FFTok_null { + + } else { + tmpb := fs.Output.Bytes() + + if bytes.Compare([]byte{'t', 'r', 'u', 'e'}, tmpb) == 0 { + + uj.GeoEnabled = true + + } else if bytes.Compare([]byte{'f', 'a', 'l', 's', 'e'}, tmpb) == 0 { + + uj.GeoEnabled = false + + } else { + err = errors.New("unexpected bytes for true/false value") + return fs.WrapErr(err) + } + + } + } + + state = fflib.FFParse_after_value + goto mainparse + +handle_ID: + + /* handler: uj.ID type=int kind=int quoted=false*/ + + { + if tok != fflib.FFTok_integer && tok != fflib.FFTok_null { + return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for int", tok)) + } + } + + { + + if tok == fflib.FFTok_null { + + } else { + + tval, err := fflib.ParseInt(fs.Output.Bytes(), 10, 64) + + if err != nil { + return fs.WrapErr(err) + } + + uj.ID = int(tval) + + } + } + + state = fflib.FFParse_after_value + goto mainparse + +handle_IDStr: + + /* handler: uj.IDStr type=string kind=string quoted=false*/ + + { + + { + if tok != fflib.FFTok_string && tok != fflib.FFTok_null { + return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for string", tok)) + } + } + + if tok == fflib.FFTok_null { + + } else { + + outBuf := fs.Output.Bytes() + + uj.IDStr = string(string(outBuf)) + + } + } + + state = fflib.FFParse_after_value + goto mainparse + +handle_IsTranslator: + + /* handler: uj.IsTranslator type=bool kind=bool quoted=false*/ + + { + if tok != fflib.FFTok_bool && tok != fflib.FFTok_null { + return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for bool", tok)) + } + } + + { + if tok == fflib.FFTok_null { + + } else { + tmpb := fs.Output.Bytes() + + if bytes.Compare([]byte{'t', 'r', 'u', 'e'}, tmpb) == 0 { + + uj.IsTranslator = true + + } else if bytes.Compare([]byte{'f', 'a', 'l', 's', 'e'}, tmpb) == 0 { + + uj.IsTranslator = false + + } else { + err = errors.New("unexpected bytes for true/false value") + return fs.WrapErr(err) + } + + } + } + + state = fflib.FFParse_after_value + goto mainparse + +handle_Lang: + + /* handler: uj.Lang type=string kind=string quoted=false*/ + + { + + { + if tok != fflib.FFTok_string && tok != fflib.FFTok_null { + return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for string", tok)) + } + } + + if tok == fflib.FFTok_null { + + } else { + + outBuf := fs.Output.Bytes() + + uj.Lang = string(string(outBuf)) + + } + } + + state = fflib.FFParse_after_value + goto mainparse + +handle_ListedCount: + + /* handler: uj.ListedCount type=int kind=int quoted=false*/ + + { + if tok != fflib.FFTok_integer && tok != fflib.FFTok_null { + return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for int", tok)) + } + } + + { + + if tok == fflib.FFTok_null { + + } else { + + tval, err := fflib.ParseInt(fs.Output.Bytes(), 10, 64) + + if err != nil { + return fs.WrapErr(err) + } + + uj.ListedCount = int(tval) + + } + } + + state = fflib.FFParse_after_value + goto mainparse + +handle_Location: + + /* handler: uj.Location type=string kind=string quoted=false*/ + + { + + { + if tok != fflib.FFTok_string && tok != fflib.FFTok_null { + return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for string", tok)) + } + } + + if tok == fflib.FFTok_null { + + } else { + + outBuf := fs.Output.Bytes() + + uj.Location = string(string(outBuf)) + + } + } + + state = fflib.FFParse_after_value + goto mainparse + +handle_Name: + + /* handler: uj.Name type=string kind=string quoted=false*/ + + { + + { + if tok != fflib.FFTok_string && tok != fflib.FFTok_null { + return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for string", tok)) + } + } + + if tok == fflib.FFTok_null { + + } else { + + outBuf := fs.Output.Bytes() + + uj.Name = string(string(outBuf)) + + } + } + + state = fflib.FFParse_after_value + goto mainparse + +handle_Notifications: + + /* handler: uj.Notifications type=string kind=string quoted=false*/ + + { + + { + if tok != fflib.FFTok_string && tok != fflib.FFTok_null { + return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for string", tok)) + } + } + + if tok == fflib.FFTok_null { + + uj.Notifications = nil + + } else { + + var tval string + outBuf := fs.Output.Bytes() + + tval = string(string(outBuf)) + uj.Notifications = &tval + + } + } + + state = fflib.FFParse_after_value + goto mainparse + +handle_ProfileBackgroundColor: + + /* handler: uj.ProfileBackgroundColor type=string kind=string quoted=false*/ + + { + + { + if tok != fflib.FFTok_string && tok != fflib.FFTok_null { + return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for string", tok)) + } + } + + if tok == fflib.FFTok_null { + + } else { + + outBuf := fs.Output.Bytes() + + uj.ProfileBackgroundColor = string(string(outBuf)) + + } + } + + state = fflib.FFParse_after_value + goto mainparse + +handle_ProfileBackgroundImageURL: + + /* handler: uj.ProfileBackgroundImageURL type=string kind=string quoted=false*/ + + { + + { + if tok != fflib.FFTok_string && tok != fflib.FFTok_null { + return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for string", tok)) + } + } + + if tok == fflib.FFTok_null { + + } else { + + outBuf := fs.Output.Bytes() + + uj.ProfileBackgroundImageURL = string(string(outBuf)) + + } + } + + state = fflib.FFParse_after_value + goto mainparse + +handle_ProfileBackgroundImageURLHTTPS: + + /* handler: uj.ProfileBackgroundImageURLHTTPS type=string kind=string quoted=false*/ + + { + + { + if tok != fflib.FFTok_string && tok != fflib.FFTok_null { + return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for string", tok)) + } + } + + if tok == fflib.FFTok_null { + + } else { + + outBuf := fs.Output.Bytes() + + uj.ProfileBackgroundImageURLHTTPS = string(string(outBuf)) + + } + } + + state = fflib.FFParse_after_value + goto mainparse + +handle_ProfileBackgroundTile: + + /* handler: uj.ProfileBackgroundTile type=bool kind=bool quoted=false*/ + + { + if tok != fflib.FFTok_bool && tok != fflib.FFTok_null { + return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for bool", tok)) + } + } + + { + if tok == fflib.FFTok_null { + + } else { + tmpb := fs.Output.Bytes() + + if bytes.Compare([]byte{'t', 'r', 'u', 'e'}, tmpb) == 0 { + + uj.ProfileBackgroundTile = true + + } else if bytes.Compare([]byte{'f', 'a', 'l', 's', 'e'}, tmpb) == 0 { + + uj.ProfileBackgroundTile = false + + } else { + err = errors.New("unexpected bytes for true/false value") + return fs.WrapErr(err) + } + + } + } + + state = fflib.FFParse_after_value + goto mainparse + +handle_ProfileImageURL: + + /* handler: uj.ProfileImageURL type=string kind=string quoted=false*/ + + { + + { + if tok != fflib.FFTok_string && tok != fflib.FFTok_null { + return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for string", tok)) + } + } + + if tok == fflib.FFTok_null { + + } else { + + outBuf := fs.Output.Bytes() + + uj.ProfileImageURL = string(string(outBuf)) + + } + } + + state = fflib.FFParse_after_value + goto mainparse + +handle_ProfileImageURLHTTPS: + + /* handler: uj.ProfileImageURLHTTPS type=string kind=string quoted=false*/ + + { + + { + if tok != fflib.FFTok_string && tok != fflib.FFTok_null { + return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for string", tok)) + } + } + + if tok == fflib.FFTok_null { + + } else { + + outBuf := fs.Output.Bytes() + + uj.ProfileImageURLHTTPS = string(string(outBuf)) + + } + } + + state = fflib.FFParse_after_value + goto mainparse + +handle_ProfileLinkColor: + + /* handler: uj.ProfileLinkColor type=string kind=string quoted=false*/ + + { + + { + if tok != fflib.FFTok_string && tok != fflib.FFTok_null { + return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for string", tok)) + } + } + + if tok == fflib.FFTok_null { + + } else { + + outBuf := fs.Output.Bytes() + + uj.ProfileLinkColor = string(string(outBuf)) + + } + } + + state = fflib.FFParse_after_value + goto mainparse + +handle_ProfileSidebarBorderColor: + + /* handler: uj.ProfileSidebarBorderColor type=string kind=string quoted=false*/ + + { + + { + if tok != fflib.FFTok_string && tok != fflib.FFTok_null { + return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for string", tok)) + } + } + + if tok == fflib.FFTok_null { + + } else { + + outBuf := fs.Output.Bytes() + + uj.ProfileSidebarBorderColor = string(string(outBuf)) + + } + } + + state = fflib.FFParse_after_value + goto mainparse + +handle_ProfileSidebarFillColor: + + /* handler: uj.ProfileSidebarFillColor type=string kind=string quoted=false*/ + + { + + { + if tok != fflib.FFTok_string && tok != fflib.FFTok_null { + return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for string", tok)) + } + } + + if tok == fflib.FFTok_null { + + } else { + + outBuf := fs.Output.Bytes() + + uj.ProfileSidebarFillColor = string(string(outBuf)) + + } + } + + state = fflib.FFParse_after_value + goto mainparse + +handle_ProfileTextColor: + + /* handler: uj.ProfileTextColor type=string kind=string quoted=false*/ + + { + + { + if tok != fflib.FFTok_string && tok != fflib.FFTok_null { + return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for string", tok)) + } + } + + if tok == fflib.FFTok_null { + + } else { + + outBuf := fs.Output.Bytes() + + uj.ProfileTextColor = string(string(outBuf)) + + } + } + + state = fflib.FFParse_after_value + goto mainparse + +handle_ProfileUseBackgroundImage: + + /* handler: uj.ProfileUseBackgroundImage type=bool kind=bool quoted=false*/ + + { + if tok != fflib.FFTok_bool && tok != fflib.FFTok_null { + return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for bool", tok)) + } + } + + { + if tok == fflib.FFTok_null { + + } else { + tmpb := fs.Output.Bytes() + + if bytes.Compare([]byte{'t', 'r', 'u', 'e'}, tmpb) == 0 { + + uj.ProfileUseBackgroundImage = true + + } else if bytes.Compare([]byte{'f', 'a', 'l', 's', 'e'}, tmpb) == 0 { + + uj.ProfileUseBackgroundImage = false + + } else { + err = errors.New("unexpected bytes for true/false value") + return fs.WrapErr(err) + } + + } + } + + state = fflib.FFParse_after_value + goto mainparse + +handle_Protected: + + /* handler: uj.Protected type=bool kind=bool quoted=false*/ + + { + if tok != fflib.FFTok_bool && tok != fflib.FFTok_null { + return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for bool", tok)) + } + } + + { + if tok == fflib.FFTok_null { + + } else { + tmpb := fs.Output.Bytes() + + if bytes.Compare([]byte{'t', 'r', 'u', 'e'}, tmpb) == 0 { + + uj.Protected = true + + } else if bytes.Compare([]byte{'f', 'a', 'l', 's', 'e'}, tmpb) == 0 { + + uj.Protected = false + + } else { + err = errors.New("unexpected bytes for true/false value") + return fs.WrapErr(err) + } + + } + } + + state = fflib.FFParse_after_value + goto mainparse + +handle_ScreenName: + + /* handler: uj.ScreenName type=string kind=string quoted=false*/ + + { + + { + if tok != fflib.FFTok_string && tok != fflib.FFTok_null { + return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for string", tok)) + } + } + + if tok == fflib.FFTok_null { + + } else { + + outBuf := fs.Output.Bytes() + + uj.ScreenName = string(string(outBuf)) + + } + } + + state = fflib.FFParse_after_value + goto mainparse + +handle_ShowAllInlineMedia: + + /* handler: uj.ShowAllInlineMedia type=bool kind=bool quoted=false*/ + + { + if tok != fflib.FFTok_bool && tok != fflib.FFTok_null { + return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for bool", tok)) + } + } + + { + if tok == fflib.FFTok_null { + + } else { + tmpb := fs.Output.Bytes() + + if bytes.Compare([]byte{'t', 'r', 'u', 'e'}, tmpb) == 0 { + + uj.ShowAllInlineMedia = true + + } else if bytes.Compare([]byte{'f', 'a', 'l', 's', 'e'}, tmpb) == 0 { + + uj.ShowAllInlineMedia = false + + } else { + err = errors.New("unexpected bytes for true/false value") + return fs.WrapErr(err) + } + + } + } + + state = fflib.FFParse_after_value + goto mainparse + +handle_StatusesCount: + + /* handler: uj.StatusesCount type=int kind=int quoted=false*/ + + { + if tok != fflib.FFTok_integer && tok != fflib.FFTok_null { + return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for int", tok)) + } + } + + { + + if tok == fflib.FFTok_null { + + } else { + + tval, err := fflib.ParseInt(fs.Output.Bytes(), 10, 64) + + if err != nil { + return fs.WrapErr(err) + } + + uj.StatusesCount = int(tval) + + } + } + + state = fflib.FFParse_after_value + goto mainparse + +handle_TimeZone: + + /* handler: uj.TimeZone type=string kind=string quoted=false*/ + + { + + { + if tok != fflib.FFTok_string && tok != fflib.FFTok_null { + return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for string", tok)) + } + } + + if tok == fflib.FFTok_null { + + } else { + + outBuf := fs.Output.Bytes() + + uj.TimeZone = string(string(outBuf)) + + } + } + + state = fflib.FFParse_after_value + goto mainparse + +handle_URL: + + /* handler: uj.URL type=string kind=string quoted=false*/ + + { + + { + if tok != fflib.FFTok_string && tok != fflib.FFTok_null { + return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for string", tok)) + } + } + + if tok == fflib.FFTok_null { + + uj.URL = nil + + } else { + + var tval string + outBuf := fs.Output.Bytes() + + tval = string(string(outBuf)) + uj.URL = &tval + + } + } + + state = fflib.FFParse_after_value + goto mainparse + +handle_UtcOffset: + + /* handler: uj.UtcOffset type=int kind=int quoted=false*/ + + { + if tok != fflib.FFTok_integer && tok != fflib.FFTok_null { + return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for int", tok)) + } + } + + { + + if tok == fflib.FFTok_null { + + } else { + + tval, err := fflib.ParseInt(fs.Output.Bytes(), 10, 64) + + if err != nil { + return fs.WrapErr(err) + } + + uj.UtcOffset = int(tval) + + } + } + + state = fflib.FFParse_after_value + goto mainparse + +handle_Verified: + + /* handler: uj.Verified type=bool kind=bool quoted=false*/ + + { + if tok != fflib.FFTok_bool && tok != fflib.FFTok_null { + return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for bool", tok)) + } + } + + { + if tok == fflib.FFTok_null { + + } else { + tmpb := fs.Output.Bytes() + + if bytes.Compare([]byte{'t', 'r', 'u', 'e'}, tmpb) == 0 { + + uj.Verified = true + + } else if bytes.Compare([]byte{'f', 'a', 'l', 's', 'e'}, tmpb) == 0 { + + uj.Verified = false + + } else { + err = errors.New("unexpected bytes for true/false value") + return fs.WrapErr(err) + } + + } + } + + state = fflib.FFParse_after_value + goto mainparse + +wantedvalue: + return fs.WrapErr(fmt.Errorf("wanted value token, but got token: %v", tok)) +wrongtokenerror: + return fs.WrapErr(fmt.Errorf("ffjson: wanted token: %v, but got token: %v output=%s", wantedTok, tok, fs.Output.String())) +tokerror: + if fs.BigError != nil { + return fs.WrapErr(fs.BigError) + } + err = fs.Error.ToError() + if err != nil { + return fs.WrapErr(err) + } + panic("ffjson-generated: unreachable, please report bug.") +done: + return nil +} + +func (mj *UserEntities) MarshalJSON() ([]byte, error) { + var buf fflib.Buffer + if mj == nil { + buf.WriteString("null") + return buf.Bytes(), nil + } + err := mj.MarshalJSONBuf(&buf) + if err != nil { + return nil, err + } + return buf.Bytes(), nil +} +func (mj *UserEntities) MarshalJSONBuf(buf fflib.EncodingBuffer) error { + if mj == nil { + buf.WriteString("null") + return nil + } + var err error + var obj []byte + _ = obj + _ = err + buf.WriteString(`{"description":`) + + { + + err = mj.Description.MarshalJSONBuf(buf) + if err != nil { + return err + } + + } + buf.WriteString(`,"url":`) + + { + + err = mj.URL.MarshalJSONBuf(buf) + if err != nil { + return err + } + + } + buf.WriteByte('}') + return nil +} + +const ( + ffj_t_UserEntitiesbase = iota + ffj_t_UserEntitiesno_such_key + + ffj_t_UserEntities_Description + + ffj_t_UserEntities_URL +) + +var ffj_key_UserEntities_Description = []byte("description") + +var ffj_key_UserEntities_URL = []byte("url") + +func (uj *UserEntities) UnmarshalJSON(input []byte) error { + fs := fflib.NewFFLexer(input) + return uj.UnmarshalJSONFFLexer(fs, fflib.FFParse_map_start) +} + +func (uj *UserEntities) UnmarshalJSONFFLexer(fs *fflib.FFLexer, state fflib.FFParseState) error { + var err error = nil + currentKey := ffj_t_UserEntitiesbase + _ = currentKey + tok := fflib.FFTok_init + wantedTok := fflib.FFTok_init + +mainparse: + for { + tok = fs.Scan() + // println(fmt.Sprintf("debug: tok: %v state: %v", tok, state)) + if tok == fflib.FFTok_error { + goto tokerror + } + + switch state { + + case fflib.FFParse_map_start: + if tok != fflib.FFTok_left_bracket { + wantedTok = fflib.FFTok_left_bracket + goto wrongtokenerror + } + state = fflib.FFParse_want_key + continue + + case fflib.FFParse_after_value: + if tok == fflib.FFTok_comma { + state = fflib.FFParse_want_key + } else if tok == fflib.FFTok_right_bracket { + goto done + } else { + wantedTok = fflib.FFTok_comma + goto wrongtokenerror + } + + case fflib.FFParse_want_key: + // json {} ended. goto exit. woo. + if tok == fflib.FFTok_right_bracket { + goto done + } + if tok != fflib.FFTok_string { + wantedTok = fflib.FFTok_string + goto wrongtokenerror + } + + kn := fs.Output.Bytes() + if len(kn) <= 0 { + // "" case. hrm. + currentKey = ffj_t_UserEntitiesno_such_key + state = fflib.FFParse_want_colon + goto mainparse + } else { + switch kn[0] { + + case 'd': + + if bytes.Equal(ffj_key_UserEntities_Description, kn) { + currentKey = ffj_t_UserEntities_Description + state = fflib.FFParse_want_colon + goto mainparse + } + + case 'u': + + if bytes.Equal(ffj_key_UserEntities_URL, kn) { + currentKey = ffj_t_UserEntities_URL + state = fflib.FFParse_want_colon + goto mainparse + } + + } + + if fflib.SimpleLetterEqualFold(ffj_key_UserEntities_URL, kn) { + currentKey = ffj_t_UserEntities_URL + state = fflib.FFParse_want_colon + goto mainparse + } + + if fflib.EqualFoldRight(ffj_key_UserEntities_Description, kn) { + currentKey = ffj_t_UserEntities_Description + state = fflib.FFParse_want_colon + goto mainparse + } + + currentKey = ffj_t_UserEntitiesno_such_key + state = fflib.FFParse_want_colon + goto mainparse + } + + case fflib.FFParse_want_colon: + if tok != fflib.FFTok_colon { + wantedTok = fflib.FFTok_colon + goto wrongtokenerror + } + state = fflib.FFParse_want_value + continue + case fflib.FFParse_want_value: + + if tok == fflib.FFTok_left_brace || tok == fflib.FFTok_left_bracket || tok == fflib.FFTok_integer || tok == fflib.FFTok_double || tok == fflib.FFTok_string || tok == fflib.FFTok_bool || tok == fflib.FFTok_null { + switch currentKey { + + case ffj_t_UserEntities_Description: + goto handle_Description + + case ffj_t_UserEntities_URL: + goto handle_URL + + case ffj_t_UserEntitiesno_such_key: + err = fs.SkipField(tok) + if err != nil { + return fs.WrapErr(err) + } + state = fflib.FFParse_after_value + goto mainparse + } + } else { + goto wantedvalue + } + } + } + +handle_Description: + + /* handler: uj.Description type=benchmark.UserEntityDescription kind=struct quoted=false*/ + + { + if tok == fflib.FFTok_null { + + state = fflib.FFParse_after_value + goto mainparse + } + + err = uj.Description.UnmarshalJSONFFLexer(fs, fflib.FFParse_want_key) + if err != nil { + return err + } + state = fflib.FFParse_after_value + } + + state = fflib.FFParse_after_value + goto mainparse + +handle_URL: + + /* handler: uj.URL type=benchmark.UserEntityURL kind=struct quoted=false*/ + + { + if tok == fflib.FFTok_null { + + state = fflib.FFParse_after_value + goto mainparse + } + + err = uj.URL.UnmarshalJSONFFLexer(fs, fflib.FFParse_want_key) + if err != nil { + return err + } + state = fflib.FFParse_after_value + } + + state = fflib.FFParse_after_value + goto mainparse + +wantedvalue: + return fs.WrapErr(fmt.Errorf("wanted value token, but got token: %v", tok)) +wrongtokenerror: + return fs.WrapErr(fmt.Errorf("ffjson: wanted token: %v, but got token: %v output=%s", wantedTok, tok, fs.Output.String())) +tokerror: + if fs.BigError != nil { + return fs.WrapErr(fs.BigError) + } + err = fs.Error.ToError() + if err != nil { + return fs.WrapErr(err) + } + panic("ffjson-generated: unreachable, please report bug.") +done: + return nil +} + +func (mj *UserEntityDescription) MarshalJSON() ([]byte, error) { + var buf fflib.Buffer + if mj == nil { + buf.WriteString("null") + return buf.Bytes(), nil + } + err := mj.MarshalJSONBuf(&buf) + if err != nil { + return nil, err + } + return buf.Bytes(), nil +} +func (mj *UserEntityDescription) MarshalJSONBuf(buf fflib.EncodingBuffer) error { + if mj == nil { + buf.WriteString("null") + return nil + } + var err error + var obj []byte + _ = obj + _ = err + buf.WriteString(`{"urls":`) + if mj.Urls != nil { + buf.WriteString(`[`) + for i, v := range mj.Urls { + if i != 0 { + buf.WriteString(`,`) + } + if v != nil { + fflib.WriteJsonString(buf, string(*v)) + } else { + buf.WriteString(`null`) + } + } + buf.WriteString(`]`) + } else { + buf.WriteString(`null`) + } + buf.WriteByte('}') + return nil +} + +const ( + ffj_t_UserEntityDescriptionbase = iota + ffj_t_UserEntityDescriptionno_such_key + + ffj_t_UserEntityDescription_Urls +) + +var ffj_key_UserEntityDescription_Urls = []byte("urls") + +func (uj *UserEntityDescription) UnmarshalJSON(input []byte) error { + fs := fflib.NewFFLexer(input) + return uj.UnmarshalJSONFFLexer(fs, fflib.FFParse_map_start) +} + +func (uj *UserEntityDescription) UnmarshalJSONFFLexer(fs *fflib.FFLexer, state fflib.FFParseState) error { + var err error = nil + currentKey := ffj_t_UserEntityDescriptionbase + _ = currentKey + tok := fflib.FFTok_init + wantedTok := fflib.FFTok_init + +mainparse: + for { + tok = fs.Scan() + // println(fmt.Sprintf("debug: tok: %v state: %v", tok, state)) + if tok == fflib.FFTok_error { + goto tokerror + } + + switch state { + + case fflib.FFParse_map_start: + if tok != fflib.FFTok_left_bracket { + wantedTok = fflib.FFTok_left_bracket + goto wrongtokenerror + } + state = fflib.FFParse_want_key + continue + + case fflib.FFParse_after_value: + if tok == fflib.FFTok_comma { + state = fflib.FFParse_want_key + } else if tok == fflib.FFTok_right_bracket { + goto done + } else { + wantedTok = fflib.FFTok_comma + goto wrongtokenerror + } + + case fflib.FFParse_want_key: + // json {} ended. goto exit. woo. + if tok == fflib.FFTok_right_bracket { + goto done + } + if tok != fflib.FFTok_string { + wantedTok = fflib.FFTok_string + goto wrongtokenerror + } + + kn := fs.Output.Bytes() + if len(kn) <= 0 { + // "" case. hrm. + currentKey = ffj_t_UserEntityDescriptionno_such_key + state = fflib.FFParse_want_colon + goto mainparse + } else { + switch kn[0] { + + case 'u': + + if bytes.Equal(ffj_key_UserEntityDescription_Urls, kn) { + currentKey = ffj_t_UserEntityDescription_Urls + state = fflib.FFParse_want_colon + goto mainparse + } + + } + + if fflib.EqualFoldRight(ffj_key_UserEntityDescription_Urls, kn) { + currentKey = ffj_t_UserEntityDescription_Urls + state = fflib.FFParse_want_colon + goto mainparse + } + + currentKey = ffj_t_UserEntityDescriptionno_such_key + state = fflib.FFParse_want_colon + goto mainparse + } + + case fflib.FFParse_want_colon: + if tok != fflib.FFTok_colon { + wantedTok = fflib.FFTok_colon + goto wrongtokenerror + } + state = fflib.FFParse_want_value + continue + case fflib.FFParse_want_value: + + if tok == fflib.FFTok_left_brace || tok == fflib.FFTok_left_bracket || tok == fflib.FFTok_integer || tok == fflib.FFTok_double || tok == fflib.FFTok_string || tok == fflib.FFTok_bool || tok == fflib.FFTok_null { + switch currentKey { + + case ffj_t_UserEntityDescription_Urls: + goto handle_Urls + + case ffj_t_UserEntityDescriptionno_such_key: + err = fs.SkipField(tok) + if err != nil { + return fs.WrapErr(err) + } + state = fflib.FFParse_after_value + goto mainparse + } + } else { + goto wantedvalue + } + } + } + +handle_Urls: + + /* handler: uj.Urls type=[]*string kind=slice quoted=false*/ + + { + + { + if tok != fflib.FFTok_left_brace && tok != fflib.FFTok_null { + return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for ", tok)) + } + } + + if tok == fflib.FFTok_null { + uj.Urls = nil + } else { + + uj.Urls = make([]*string, 0) + + wantVal := true + + for { + + var tmp_uj__Urls *string + + tok = fs.Scan() + if tok == fflib.FFTok_error { + goto tokerror + } + if tok == fflib.FFTok_right_brace { + break + } + + if tok == fflib.FFTok_comma { + if wantVal == true { + // TODO(pquerna): this isn't an ideal error message, this handles + // things like [,,,] as an array value. + return fs.WrapErr(fmt.Errorf("wanted value token, but got token: %v", tok)) + } + continue + } else { + wantVal = true + } + + /* handler: tmp_uj__Urls type=*string kind=ptr quoted=false*/ + + { + + if tok == fflib.FFTok_null { + tmp_uj__Urls = nil + } else { + if tmp_uj__Urls == nil { + tmp_uj__Urls = new(string) + } + + /* handler: tmp_uj__Urls type=string kind=string quoted=false*/ + + { + + { + if tok != fflib.FFTok_string && tok != fflib.FFTok_null { + return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for string", tok)) + } + } + + if tok == fflib.FFTok_null { + + tmp_uj__Urls = nil + + } else { + + var tval string + outBuf := fs.Output.Bytes() + + tval = string(string(outBuf)) + tmp_uj__Urls = &tval + + } + } + + } + } + + uj.Urls = append(uj.Urls, tmp_uj__Urls) + wantVal = false + } + } + } + + state = fflib.FFParse_after_value + goto mainparse + +wantedvalue: + return fs.WrapErr(fmt.Errorf("wanted value token, but got token: %v", tok)) +wrongtokenerror: + return fs.WrapErr(fmt.Errorf("ffjson: wanted token: %v, but got token: %v output=%s", wantedTok, tok, fs.Output.String())) +tokerror: + if fs.BigError != nil { + return fs.WrapErr(fs.BigError) + } + err = fs.Error.ToError() + if err != nil { + return fs.WrapErr(err) + } + panic("ffjson-generated: unreachable, please report bug.") +done: + return nil +} + +func (mj *UserEntityURL) MarshalJSON() ([]byte, error) { + var buf fflib.Buffer + if mj == nil { + buf.WriteString("null") + return buf.Bytes(), nil + } + err := mj.MarshalJSONBuf(&buf) + if err != nil { + return nil, err + } + return buf.Bytes(), nil +} +func (mj *UserEntityURL) MarshalJSONBuf(buf fflib.EncodingBuffer) error { + if mj == nil { + buf.WriteString("null") + return nil + } + var err error + var obj []byte + _ = obj + _ = err + buf.WriteString(`{"urls":`) + if mj.Urls != nil { + buf.WriteString(`[`) + for i, v := range mj.Urls { + if i != 0 { + buf.WriteString(`,`) + } + + { + + err = v.MarshalJSONBuf(buf) + if err != nil { + return err + } + + } + } + buf.WriteString(`]`) + } else { + buf.WriteString(`null`) + } + buf.WriteByte('}') + return nil +} + +const ( + ffj_t_UserEntityURLbase = iota + ffj_t_UserEntityURLno_such_key + + ffj_t_UserEntityURL_Urls +) + +var ffj_key_UserEntityURL_Urls = []byte("urls") + +func (uj *UserEntityURL) UnmarshalJSON(input []byte) error { + fs := fflib.NewFFLexer(input) + return uj.UnmarshalJSONFFLexer(fs, fflib.FFParse_map_start) +} + +func (uj *UserEntityURL) UnmarshalJSONFFLexer(fs *fflib.FFLexer, state fflib.FFParseState) error { + var err error = nil + currentKey := ffj_t_UserEntityURLbase + _ = currentKey + tok := fflib.FFTok_init + wantedTok := fflib.FFTok_init + +mainparse: + for { + tok = fs.Scan() + // println(fmt.Sprintf("debug: tok: %v state: %v", tok, state)) + if tok == fflib.FFTok_error { + goto tokerror + } + + switch state { + + case fflib.FFParse_map_start: + if tok != fflib.FFTok_left_bracket { + wantedTok = fflib.FFTok_left_bracket + goto wrongtokenerror + } + state = fflib.FFParse_want_key + continue + + case fflib.FFParse_after_value: + if tok == fflib.FFTok_comma { + state = fflib.FFParse_want_key + } else if tok == fflib.FFTok_right_bracket { + goto done + } else { + wantedTok = fflib.FFTok_comma + goto wrongtokenerror + } + + case fflib.FFParse_want_key: + // json {} ended. goto exit. woo. + if tok == fflib.FFTok_right_bracket { + goto done + } + if tok != fflib.FFTok_string { + wantedTok = fflib.FFTok_string + goto wrongtokenerror + } + + kn := fs.Output.Bytes() + if len(kn) <= 0 { + // "" case. hrm. + currentKey = ffj_t_UserEntityURLno_such_key + state = fflib.FFParse_want_colon + goto mainparse + } else { + switch kn[0] { + + case 'u': + + if bytes.Equal(ffj_key_UserEntityURL_Urls, kn) { + currentKey = ffj_t_UserEntityURL_Urls + state = fflib.FFParse_want_colon + goto mainparse + } + + } + + if fflib.EqualFoldRight(ffj_key_UserEntityURL_Urls, kn) { + currentKey = ffj_t_UserEntityURL_Urls + state = fflib.FFParse_want_colon + goto mainparse + } + + currentKey = ffj_t_UserEntityURLno_such_key + state = fflib.FFParse_want_colon + goto mainparse + } + + case fflib.FFParse_want_colon: + if tok != fflib.FFTok_colon { + wantedTok = fflib.FFTok_colon + goto wrongtokenerror + } + state = fflib.FFParse_want_value + continue + case fflib.FFParse_want_value: + + if tok == fflib.FFTok_left_brace || tok == fflib.FFTok_left_bracket || tok == fflib.FFTok_integer || tok == fflib.FFTok_double || tok == fflib.FFTok_string || tok == fflib.FFTok_bool || tok == fflib.FFTok_null { + switch currentKey { + + case ffj_t_UserEntityURL_Urls: + goto handle_Urls + + case ffj_t_UserEntityURLno_such_key: + err = fs.SkipField(tok) + if err != nil { + return fs.WrapErr(err) + } + state = fflib.FFParse_after_value + goto mainparse + } + } else { + goto wantedvalue + } + } + } + +handle_Urls: + + /* handler: uj.Urls type=[]benchmark.URL kind=slice quoted=false*/ + + { + + { + if tok != fflib.FFTok_left_brace && tok != fflib.FFTok_null { + return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for ", tok)) + } + } + + if tok == fflib.FFTok_null { + uj.Urls = nil + } else { + + uj.Urls = make([]URL, 0) + + wantVal := true + + for { + + var tmp_uj__Urls URL + + tok = fs.Scan() + if tok == fflib.FFTok_error { + goto tokerror + } + if tok == fflib.FFTok_right_brace { + break + } + + if tok == fflib.FFTok_comma { + if wantVal == true { + // TODO(pquerna): this isn't an ideal error message, this handles + // things like [,,,] as an array value. + return fs.WrapErr(fmt.Errorf("wanted value token, but got token: %v", tok)) + } + continue + } else { + wantVal = true + } + + /* handler: tmp_uj__Urls type=benchmark.URL kind=struct quoted=false*/ + + { + if tok == fflib.FFTok_null { + + state = fflib.FFParse_after_value + goto mainparse + } + + err = tmp_uj__Urls.UnmarshalJSONFFLexer(fs, fflib.FFParse_want_key) + if err != nil { + return err + } + state = fflib.FFParse_after_value + } + + uj.Urls = append(uj.Urls, tmp_uj__Urls) + wantVal = false + } + } + } + + state = fflib.FFParse_after_value + goto mainparse + +wantedvalue: + return fs.WrapErr(fmt.Errorf("wanted value token, but got token: %v", tok)) +wrongtokenerror: + return fs.WrapErr(fmt.Errorf("ffjson: wanted token: %v, but got token: %v output=%s", wantedTok, tok, fs.Output.String())) +tokerror: + if fs.BigError != nil { + return fs.WrapErr(fs.BigError) + } + err = fs.Error.ToError() + if err != nil { + return fs.WrapErr(err) + } + panic("ffjson-generated: unreachable, please report bug.") +done: + return nil +} + +func (mj *XLStruct) MarshalJSON() ([]byte, error) { + var buf fflib.Buffer + if mj == nil { + buf.WriteString("null") + return buf.Bytes(), nil + } + err := mj.MarshalJSONBuf(&buf) + if err != nil { + return nil, err + } + return buf.Bytes(), nil +} +func (mj *XLStruct) MarshalJSONBuf(buf fflib.EncodingBuffer) error { + if mj == nil { + buf.WriteString("null") + return nil + } + var err error + var obj []byte + _ = obj + _ = err + buf.WriteString(`{"Data":`) + if mj.Data != nil { + buf.WriteString(`[`) + for i, v := range mj.Data { + if i != 0 { + buf.WriteString(`,`) + } + + { + + err = v.MarshalJSONBuf(buf) + if err != nil { + return err + } + + } + } + buf.WriteString(`]`) + } else { + buf.WriteString(`null`) + } + buf.WriteByte('}') + return nil +} + +const ( + ffj_t_XLStructbase = iota + ffj_t_XLStructno_such_key + + ffj_t_XLStruct_Data +) + +var ffj_key_XLStruct_Data = []byte("Data") + +func (uj *XLStruct) UnmarshalJSON(input []byte) error { + fs := fflib.NewFFLexer(input) + return uj.UnmarshalJSONFFLexer(fs, fflib.FFParse_map_start) +} + +func (uj *XLStruct) UnmarshalJSONFFLexer(fs *fflib.FFLexer, state fflib.FFParseState) error { + var err error = nil + currentKey := ffj_t_XLStructbase + _ = currentKey + tok := fflib.FFTok_init + wantedTok := fflib.FFTok_init + +mainparse: + for { + tok = fs.Scan() + // println(fmt.Sprintf("debug: tok: %v state: %v", tok, state)) + if tok == fflib.FFTok_error { + goto tokerror + } + + switch state { + + case fflib.FFParse_map_start: + if tok != fflib.FFTok_left_bracket { + wantedTok = fflib.FFTok_left_bracket + goto wrongtokenerror + } + state = fflib.FFParse_want_key + continue + + case fflib.FFParse_after_value: + if tok == fflib.FFTok_comma { + state = fflib.FFParse_want_key + } else if tok == fflib.FFTok_right_bracket { + goto done + } else { + wantedTok = fflib.FFTok_comma + goto wrongtokenerror + } + + case fflib.FFParse_want_key: + // json {} ended. goto exit. woo. + if tok == fflib.FFTok_right_bracket { + goto done + } + if tok != fflib.FFTok_string { + wantedTok = fflib.FFTok_string + goto wrongtokenerror + } + + kn := fs.Output.Bytes() + if len(kn) <= 0 { + // "" case. hrm. + currentKey = ffj_t_XLStructno_such_key + state = fflib.FFParse_want_colon + goto mainparse + } else { + switch kn[0] { + + case 'D': + + if bytes.Equal(ffj_key_XLStruct_Data, kn) { + currentKey = ffj_t_XLStruct_Data + state = fflib.FFParse_want_colon + goto mainparse + } + + } + + if fflib.SimpleLetterEqualFold(ffj_key_XLStruct_Data, kn) { + currentKey = ffj_t_XLStruct_Data + state = fflib.FFParse_want_colon + goto mainparse + } + + currentKey = ffj_t_XLStructno_such_key + state = fflib.FFParse_want_colon + goto mainparse + } + + case fflib.FFParse_want_colon: + if tok != fflib.FFTok_colon { + wantedTok = fflib.FFTok_colon + goto wrongtokenerror + } + state = fflib.FFParse_want_value + continue + case fflib.FFParse_want_value: + + if tok == fflib.FFTok_left_brace || tok == fflib.FFTok_left_bracket || tok == fflib.FFTok_integer || tok == fflib.FFTok_double || tok == fflib.FFTok_string || tok == fflib.FFTok_bool || tok == fflib.FFTok_null { + switch currentKey { + + case ffj_t_XLStruct_Data: + goto handle_Data + + case ffj_t_XLStructno_such_key: + err = fs.SkipField(tok) + if err != nil { + return fs.WrapErr(err) + } + state = fflib.FFParse_after_value + goto mainparse + } + } else { + goto wantedvalue + } + } + } + +handle_Data: + + /* handler: uj.Data type=[]benchmark.LargeStruct kind=slice quoted=false*/ + + { + + { + if tok != fflib.FFTok_left_brace && tok != fflib.FFTok_null { + return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for ", tok)) + } + } + + if tok == fflib.FFTok_null { + uj.Data = nil + } else { + + uj.Data = make([]LargeStruct, 0) + + wantVal := true + + for { + + var tmp_uj__Data LargeStruct + + tok = fs.Scan() + if tok == fflib.FFTok_error { + goto tokerror + } + if tok == fflib.FFTok_right_brace { + break + } + + if tok == fflib.FFTok_comma { + if wantVal == true { + // TODO(pquerna): this isn't an ideal error message, this handles + // things like [,,,] as an array value. + return fs.WrapErr(fmt.Errorf("wanted value token, but got token: %v", tok)) + } + continue + } else { + wantVal = true + } + + /* handler: tmp_uj__Data type=benchmark.LargeStruct kind=struct quoted=false*/ + + { + if tok == fflib.FFTok_null { + + state = fflib.FFParse_after_value + goto mainparse + } + + err = tmp_uj__Data.UnmarshalJSONFFLexer(fs, fflib.FFParse_want_key) + if err != nil { + return err + } + state = fflib.FFParse_after_value + } + + uj.Data = append(uj.Data, tmp_uj__Data) + wantVal = false + } + } + } + + state = fflib.FFParse_after_value + goto mainparse + +wantedvalue: + return fs.WrapErr(fmt.Errorf("wanted value token, but got token: %v", tok)) +wrongtokenerror: + return fs.WrapErr(fmt.Errorf("ffjson: wanted token: %v, but got token: %v output=%s", wantedTok, tok, fs.Output.String())) +tokerror: + if fs.BigError != nil { + return fs.WrapErr(fs.BigError) + } + err = fs.Error.ToError() + if err != nil { + return fs.WrapErr(err) + } + panic("ffjson-generated: unreachable, please report bug.") +done: + return nil +} diff --git a/vendor/github.com/mailru/easyjson/benchmark/data_var.go b/vendor/github.com/mailru/easyjson/benchmark/data_var.go new file mode 100644 index 000000000..ea4202dbe --- /dev/null +++ b/vendor/github.com/mailru/easyjson/benchmark/data_var.go @@ -0,0 +1,350 @@ +package benchmark + +var largeStructData = LargeStruct{ + SearchMetadata: SearchMetadata{ + CompletedIn: 0.035, + Count: 4, + MaxID: 250126199840518145, + MaxIDStr: "250126199840518145", + NextResults: "?max_id=249279667666817023&q=%23freebandnames&count=4&include_entities=1&result_type=mixed", + Query: "%23freebandnames", + RefreshURL: "?since_id=250126199840518145&q=%23freebandnames&result_type=mixed&include_entities=1", + SinceID: 24012619984051000, + SinceIDStr: "24012619984051000", + }, + Statuses: []Status{ + { + Contributors: nil, + Coordinates: nil, + CreatedAt: "Mon Sep 24 03:35:21 +0000 2012", + Entities: Entities{ + Hashtags: []Hashtag{{ + Indices: []int{20, 34}, + Text: "freebandnames"}, + }, + Urls: []*string{}, + UserMentions: []*string{}, + }, + Favorited: false, + Geo: nil, + ID: 250075927172759552, + IDStr: "250075927172759552", + InReplyToScreenName: nil, + InReplyToStatusID: nil, + InReplyToStatusIDStr: nil, + InReplyToUserID: nil, + InReplyToUserIDStr: nil, + Metadata: StatusMetadata{ + IsoLanguageCode: "en", + ResultType: "recent", + }, + Place: nil, + RetweetCount: 0, + Retweeted: false, + Source: "<a href=\"//itunes.apple.com/us/app/twitter/id409789998?mt=12%5C%22\" rel=\"\\\"nofollow\\\"\">Twitter for Mac</a>", + Text: "Aggressive Ponytail #freebandnames", + Truncated: false, + User: User{ + ContributorsEnabled: false, + CreatedAt: "Mon Apr 26 06:01:55 +0000 2010", + DefaultProfile: true, + DefaultProfileImage: false, + Description: "Born 330 Live 310", + Entities: UserEntities{ + Description: UserEntityDescription{ + Urls: []*string{}, + }, + URL: UserEntityURL{ + Urls: []URL{{ + ExpandedURL: nil, + Indices: []int{0, 0}, + URL: "", + }}, + }, + }, + FavouritesCount: 0, + FollowRequestSent: nil, + FollowersCount: 70, + Following: nil, + FriendsCount: 110, + GeoEnabled: true, + ID: 137238150, + IDStr: "137238150", + IsTranslator: false, + Lang: "en", + ListedCount: 2, + Location: "LA, CA", + Name: "Sean Cummings", + Notifications: nil, + ProfileBackgroundColor: "C0DEED", + ProfileBackgroundImageURL: "http://a0.twimg.com/images/themes/theme1/bg.png", + ProfileBackgroundImageURLHTTPS: "https://si0.twimg.com/images/themes/theme1/bg.png", + ProfileBackgroundTile: false, + ProfileImageURL: "http://a0.twimg.com/profile_images/2359746665/1v6zfgqo8g0d3mk7ii5s_normal.jpeg", + ProfileImageURLHTTPS: "https://si0.twimg.com/profile_images/2359746665/1v6zfgqo8g0d3mk7ii5s_normal.jpeg", + ProfileLinkColor: "0084B4", + ProfileSidebarBorderColor: "C0DEED", + ProfileSidebarFillColor: "DDEEF6", + ProfileTextColor: "333333", + ProfileUseBackgroundImage: true, + Protected: false, + ScreenName: "sean_cummings", + ShowAllInlineMedia: false, + StatusesCount: 579, + TimeZone: "Pacific Time (US & Canada)", + URL: nil, + UtcOffset: -28800, + Verified: false, + }, + }, + { + Contributors: nil, + Coordinates: nil, + CreatedAt: "Fri Sep 21 23:40:54 +0000 2012", + Entities: Entities{ + Hashtags: []Hashtag{{ + Indices: []int{20, 34}, + Text: "FreeBandNames", + }}, + Urls: []*string{}, + UserMentions: []*string{}, + }, + Favorited: false, + Geo: nil, + ID: 249292149810667520, + IDStr: "249292149810667520", + InReplyToScreenName: nil, + InReplyToStatusID: nil, + InReplyToStatusIDStr: nil, + InReplyToUserID: nil, + InReplyToUserIDStr: nil, + Metadata: StatusMetadata{ + IsoLanguageCode: "pl", + ResultType: "recent", + }, + Place: nil, + RetweetCount: 0, + Retweeted: false, + Source: "web", + Text: "Thee Namaste Nerdz. #FreeBandNames", + Truncated: false, + User: User{ + ContributorsEnabled: false, + CreatedAt: "Tue Apr 07 19:05:07 +0000 2009", + DefaultProfile: false, + DefaultProfileImage: false, + Description: "You will come to Durham, North Carolina. I will sell you some records then, here in Durham, North Carolina. Fun will happen.", + Entities: UserEntities{ + Description: UserEntityDescription{Urls: []*string{}}, + URL: UserEntityURL{ + Urls: []URL{{ + ExpandedURL: nil, + Indices: []int{0, 32}, + URL: "http://bullcityrecords.com/wnng/"}}, + }, + }, + FavouritesCount: 8, + FollowRequestSent: nil, + FollowersCount: 2052, + Following: nil, + FriendsCount: 348, + GeoEnabled: false, + ID: 29516238, + IDStr: "29516238", + IsTranslator: false, + Lang: "en", + ListedCount: 118, + Location: "Durham, NC", + Name: "Chaz Martenstein", + Notifications: nil, + ProfileBackgroundColor: "9AE4E8", + ProfileBackgroundImageURL: "http://a0.twimg.com/profile_background_images/9423277/background_tile.bmp", + ProfileBackgroundImageURLHTTPS: "https://si0.twimg.com/profile_background_images/9423277/background_tile.bmp", + ProfileBackgroundTile: true, + ProfileImageURL: "http://a0.twimg.com/profile_images/447958234/Lichtenstein_normal.jpg", + ProfileImageURLHTTPS: "https://si0.twimg.com/profile_images/447958234/Lichtenstein_normal.jpg", + ProfileLinkColor: "0084B4", + ProfileSidebarBorderColor: "BDDCAD", + ProfileSidebarFillColor: "DDFFCC", + ProfileTextColor: "333333", + ProfileUseBackgroundImage: true, + Protected: false, + ScreenName: "bullcityrecords", + ShowAllInlineMedia: true, + StatusesCount: 7579, + TimeZone: "Eastern Time (US & Canada)", + URL: nil, + UtcOffset: -18000, + Verified: false, + }, + }, + Status{ + Contributors: nil, + Coordinates: nil, + CreatedAt: "Fri Sep 21 23:30:20 +0000 2012", + Entities: Entities{ + Hashtags: []Hashtag{{ + Indices: []int{29, 43}, + Text: "freebandnames", + }}, + Urls: []*string{}, + UserMentions: []*string{}, + }, + Favorited: false, + Geo: nil, + ID: 249289491129438208, + IDStr: "249289491129438208", + InReplyToScreenName: nil, + InReplyToStatusID: nil, + InReplyToStatusIDStr: nil, + InReplyToUserID: nil, + InReplyToUserIDStr: nil, + Metadata: StatusMetadata{ + IsoLanguageCode: "en", + ResultType: "recent", + }, + Place: nil, + RetweetCount: 0, + Retweeted: false, + Source: "web", + Text: "Mexican Heaven, Mexican Hell #freebandnames", + Truncated: false, + User: User{ + ContributorsEnabled: false, + CreatedAt: "Tue Sep 01 21:21:35 +0000 2009", + DefaultProfile: false, + DefaultProfileImage: false, + Description: "Science Fiction Writer, sort of. Likes Superheroes, Mole People, Alt. Timelines.", + Entities: UserEntities{ + Description: UserEntityDescription{ + Urls: nil, + }, + URL: UserEntityURL{ + Urls: []URL{{ + ExpandedURL: nil, + Indices: []int{0, 0}, + URL: "", + }}, + }, + }, + FavouritesCount: 19, + FollowRequestSent: nil, + FollowersCount: 63, + Following: nil, + FriendsCount: 63, + GeoEnabled: false, + ID: 70789458, + IDStr: "70789458", + IsTranslator: false, + Lang: "en", + ListedCount: 1, + Location: "Kingston New York", + Name: "Thomas John Wakeman", + Notifications: nil, + ProfileBackgroundColor: "352726", + ProfileBackgroundImageURL: "http://a0.twimg.com/images/themes/theme5/bg.gif", + ProfileBackgroundImageURLHTTPS: "https://si0.twimg.com/images/themes/theme5/bg.gif", + ProfileBackgroundTile: false, + ProfileImageURL: "http://a0.twimg.com/profile_images/2219333930/Froggystyle_normal.png", + ProfileImageURLHTTPS: "https://si0.twimg.com/profile_images/2219333930/Froggystyle_normal.png", + ProfileLinkColor: "D02B55", + ProfileSidebarBorderColor: "829D5E", + ProfileSidebarFillColor: "99CC33", + ProfileTextColor: "3E4415", + ProfileUseBackgroundImage: true, + Protected: false, + ScreenName: "MonkiesFist", + ShowAllInlineMedia: false, + StatusesCount: 1048, + TimeZone: "Eastern Time (US & Canada)", + URL: nil, + UtcOffset: -18000, + Verified: false, + }, + }, + Status{ + Contributors: nil, + Coordinates: nil, + CreatedAt: "Fri Sep 21 22:51:18 +0000 2012", + Entities: Entities{ + Hashtags: []Hashtag{{ + Indices: []int{20, 34}, + Text: "freebandnames", + }}, + Urls: []*string{}, + UserMentions: []*string{}, + }, + Favorited: false, + Geo: nil, + ID: 249279667666817024, + IDStr: "249279667666817024", + InReplyToScreenName: nil, + InReplyToStatusID: nil, + InReplyToStatusIDStr: nil, + InReplyToUserID: nil, + InReplyToUserIDStr: nil, + Metadata: StatusMetadata{ + IsoLanguageCode: "en", + ResultType: "recent", + }, + Place: nil, + RetweetCount: 0, + Retweeted: false, + Source: "<a href=\"//twitter.com/download/iphone%5C%22\" rel=\"\\\"nofollow\\\"\">Twitter for iPhone</a>", + Text: "The Foolish Mortals #freebandnames", + Truncated: false, + User: User{ + ContributorsEnabled: false, + CreatedAt: "Mon May 04 00:05:00 +0000 2009", + DefaultProfile: false, + DefaultProfileImage: false, + Description: "Cartoonist, Illustrator, and T-Shirt connoisseur", + Entities: UserEntities{ + Description: UserEntityDescription{ + Urls: []*string{}, + }, + URL: UserEntityURL{ + Urls: []URL{{ + ExpandedURL: nil, + Indices: []int{0, 24}, + URL: "http://www.omnitarian.me", + }}, + }, + }, + FavouritesCount: 647, + FollowRequestSent: nil, + FollowersCount: 608, + Following: nil, + FriendsCount: 249, + GeoEnabled: false, + ID: 37539828, + IDStr: "37539828", + IsTranslator: false, + Lang: "en", + ListedCount: 52, + Location: "Wisconsin, USA", + Name: "Marty Elmer", + Notifications: nil, + ProfileBackgroundColor: "EEE3C4", + ProfileBackgroundImageURL: "http://a0.twimg.com/profile_background_images/106455659/rect6056-9.png", + ProfileBackgroundImageURLHTTPS: "https://si0.twimg.com/profile_background_images/106455659/rect6056-9.png", + ProfileBackgroundTile: true, + ProfileImageURL: "http://a0.twimg.com/profile_images/1629790393/shrinker_2000_trans_normal.png", + ProfileImageURLHTTPS: "https://si0.twimg.com/profile_images/1629790393/shrinker_2000_trans_normal.png", + ProfileLinkColor: "3B2A26", + ProfileSidebarBorderColor: "615A44", + ProfileSidebarFillColor: "BFAC83", + ProfileTextColor: "000000", + ProfileUseBackgroundImage: true, + Protected: false, + ScreenName: "Omnitarian", + ShowAllInlineMedia: true, + StatusesCount: 3575, + TimeZone: "Central Time (US & Canada)", + URL: nil, + UtcOffset: -21600, + Verified: false, + }, + }, + }, +} diff --git a/vendor/github.com/mailru/easyjson/benchmark/default_test.go b/vendor/github.com/mailru/easyjson/benchmark/default_test.go new file mode 100644 index 000000000..68b37910d --- /dev/null +++ b/vendor/github.com/mailru/easyjson/benchmark/default_test.go @@ -0,0 +1,118 @@ +// +build !use_easyjson,!use_ffjson,!use_codec,!use_jsoniter + +package benchmark + +import ( + "encoding/json" + "testing" +) + +func BenchmarkStd_Unmarshal_M(b *testing.B) { + b.SetBytes(int64(len(largeStructText))) + for i := 0; i < b.N; i++ { + var s LargeStruct + err := json.Unmarshal(largeStructText, &s) + if err != nil { + b.Error(err) + } + } +} + +func BenchmarkStd_Unmarshal_S(b *testing.B) { + for i := 0; i < b.N; i++ { + var s Entities + err := json.Unmarshal(smallStructText, &s) + if err != nil { + b.Error(err) + } + } + b.SetBytes(int64(len(smallStructText))) +} + +func BenchmarkStd_Marshal_M(b *testing.B) { + var l int64 + for i := 0; i < b.N; i++ { + data, err := json.Marshal(&largeStructData) + if err != nil { + b.Error(err) + } + l = int64(len(data)) + } + b.SetBytes(l) +} + +func BenchmarkStd_Marshal_L(b *testing.B) { + var l int64 + for i := 0; i < b.N; i++ { + data, err := json.Marshal(&xlStructData) + if err != nil { + b.Error(err) + } + l = int64(len(data)) + } + b.SetBytes(l) +} + +func BenchmarkStd_Marshal_M_Parallel(b *testing.B) { + var l int64 + b.RunParallel(func(pb *testing.PB) { + for pb.Next() { + data, err := json.Marshal(&largeStructData) + if err != nil { + b.Error(err) + } + l = int64(len(data)) + } + }) + b.SetBytes(l) +} + +func BenchmarkStd_Marshal_L_Parallel(b *testing.B) { + var l int64 + b.RunParallel(func(pb *testing.PB) { + for pb.Next() { + data, err := json.Marshal(&xlStructData) + if err != nil { + b.Error(err) + } + l = int64(len(data)) + } + }) + b.SetBytes(l) +} + +func BenchmarkStd_Marshal_S(b *testing.B) { + var l int64 + for i := 0; i < b.N; i++ { + data, err := json.Marshal(&smallStructData) + if err != nil { + b.Error(err) + } + l = int64(len(data)) + } + b.SetBytes(l) +} + +func BenchmarkStd_Marshal_S_Parallel(b *testing.B) { + var l int64 + b.RunParallel(func(pb *testing.PB) { + for pb.Next() { + data, err := json.Marshal(&smallStructData) + if err != nil { + b.Error(err) + } + l = int64(len(data)) + } + }) + b.SetBytes(l) +} + +func BenchmarkStd_Marshal_M_ToWriter(b *testing.B) { + enc := json.NewEncoder(&DummyWriter{}) + for i := 0; i < b.N; i++ { + err := enc.Encode(&largeStructData) + if err != nil { + b.Error(err) + } + } +} diff --git a/vendor/github.com/mailru/easyjson/benchmark/dummy_test.go b/vendor/github.com/mailru/easyjson/benchmark/dummy_test.go new file mode 100644 index 000000000..3d928ca7c --- /dev/null +++ b/vendor/github.com/mailru/easyjson/benchmark/dummy_test.go @@ -0,0 +1,11 @@ +package benchmark + +import ( + "testing" +) + +type DummyWriter struct{} + +func (w DummyWriter) Write(data []byte) (int, error) { return len(data), nil } + +func TestToSuppressNoTestsWarning(t *testing.T) {} diff --git a/vendor/github.com/mailru/easyjson/benchmark/easyjson_test.go b/vendor/github.com/mailru/easyjson/benchmark/easyjson_test.go new file mode 100644 index 000000000..16b670b27 --- /dev/null +++ b/vendor/github.com/mailru/easyjson/benchmark/easyjson_test.go @@ -0,0 +1,184 @@ +// +build use_easyjson + +package benchmark + +import ( + "testing" + + "github.com/mailru/easyjson" + "github.com/mailru/easyjson/jwriter" +) + +func BenchmarkEJ_Unmarshal_M(b *testing.B) { + b.SetBytes(int64(len(largeStructText))) + for i := 0; i < b.N; i++ { + var s LargeStruct + err := s.UnmarshalJSON(largeStructText) + if err != nil { + b.Error(err) + } + } +} + +func BenchmarkEJ_Unmarshal_S(b *testing.B) { + b.SetBytes(int64(len(smallStructText))) + + for i := 0; i < b.N; i++ { + var s Entities + err := s.UnmarshalJSON(smallStructText) + if err != nil { + b.Error(err) + } + } +} + +func BenchmarkEJ_Marshal_M(b *testing.B) { + var l int64 + for i := 0; i < b.N; i++ { + data, err := easyjson.Marshal(&largeStructData) + if err != nil { + b.Error(err) + } + l = int64(len(data)) + } + b.SetBytes(l) +} + +func BenchmarkEJ_Marshal_L(b *testing.B) { + var l int64 + for i := 0; i < b.N; i++ { + data, err := easyjson.Marshal(&xlStructData) + if err != nil { + b.Error(err) + } + l = int64(len(data)) + } + b.SetBytes(l) +} + +func BenchmarkEJ_Marshal_L_ToWriter(b *testing.B) { + var l int64 + out := &DummyWriter{} + for i := 0; i < b.N; i++ { + w := jwriter.Writer{} + xlStructData.MarshalEasyJSON(&w) + if w.Error != nil { + b.Error(w.Error) + } + + l = int64(w.Size()) + w.DumpTo(out) + } + b.SetBytes(l) + +} +func BenchmarkEJ_Marshal_M_Parallel(b *testing.B) { + b.SetBytes(int64(len(largeStructText))) + + b.RunParallel(func(pb *testing.PB) { + for pb.Next() { + _, err := largeStructData.MarshalJSON() + if err != nil { + b.Error(err) + } + } + }) +} + +func BenchmarkEJ_Marshal_M_ToWriter(b *testing.B) { + var l int64 + out := &DummyWriter{} + for i := 0; i < b.N; i++ { + w := jwriter.Writer{} + largeStructData.MarshalEasyJSON(&w) + if w.Error != nil { + b.Error(w.Error) + } + + l = int64(w.Size()) + w.DumpTo(out) + } + b.SetBytes(l) + +} +func BenchmarkEJ_Marshal_M_ToWriter_Parallel(b *testing.B) { + out := &DummyWriter{} + + b.RunParallel(func(pb *testing.PB) { + var l int64 + for pb.Next() { + w := jwriter.Writer{} + largeStructData.MarshalEasyJSON(&w) + if w.Error != nil { + b.Error(w.Error) + } + + l = int64(w.Size()) + w.DumpTo(out) + } + if l > 0 { + b.SetBytes(l) + } + }) + +} + +func BenchmarkEJ_Marshal_L_Parallel(b *testing.B) { + var l int64 + b.RunParallel(func(pb *testing.PB) { + for pb.Next() { + data, err := xlStructData.MarshalJSON() + if err != nil { + b.Error(err) + } + l = int64(len(data)) + } + }) + b.SetBytes(l) +} + +func BenchmarkEJ_Marshal_L_ToWriter_Parallel(b *testing.B) { + out := &DummyWriter{} + b.RunParallel(func(pb *testing.PB) { + var l int64 + for pb.Next() { + w := jwriter.Writer{} + + xlStructData.MarshalEasyJSON(&w) + if w.Error != nil { + b.Error(w.Error) + } + l = int64(w.Size()) + w.DumpTo(out) + } + if l > 0 { + b.SetBytes(l) + } + }) +} + +func BenchmarkEJ_Marshal_S(b *testing.B) { + var l int64 + for i := 0; i < b.N; i++ { + data, err := smallStructData.MarshalJSON() + if err != nil { + b.Error(err) + } + l = int64(len(data)) + } + b.SetBytes(l) +} + +func BenchmarkEJ_Marshal_S_Parallel(b *testing.B) { + var l int64 + b.RunParallel(func(pb *testing.PB) { + for pb.Next() { + data, err := smallStructData.MarshalJSON() + if err != nil { + b.Error(err) + } + l = int64(len(data)) + } + }) + b.SetBytes(l) +} diff --git a/vendor/github.com/mailru/easyjson/benchmark/example.json b/vendor/github.com/mailru/easyjson/benchmark/example.json new file mode 100644 index 000000000..2405022cf --- /dev/null +++ b/vendor/github.com/mailru/easyjson/benchmark/example.json @@ -0,0 +1,415 @@ +{ + "statuses": [ + { + "coordinates": null, + "favorited": false, + "truncated": false, + "created_at": "Mon Sep 24 03:35:21 +0000 2012", + "id_str": "250075927172759552", + "entities": { + "urls": [ + + ], + "hashtags": [ + { + "text": "freebandnames", + "indices": [ + 20, + 34 + ] + } + ], + "user_mentions": [ + + ] + }, + "in_reply_to_user_id_str": null, + "contributors": null, + "text": "Aggressive Ponytail #freebandnames", + "metadata": { + "iso_language_code": "en", + "result_type": "recent" + }, + "retweet_count": 0, + "in_reply_to_status_id_str": null, + "id": 250075927172759552, + "geo": null, + "retweeted": false, + "in_reply_to_user_id": null, + "place": null, + "user": { + "profile_sidebar_fill_color": "DDEEF6", + "profile_sidebar_border_color": "C0DEED", + "profile_background_tile": false, + "name": "Sean Cummings", + "profile_image_url": "http://a0.twimg.com/profile_images/2359746665/1v6zfgqo8g0d3mk7ii5s_normal.jpeg", + "created_at": "Mon Apr 26 06:01:55 +0000 2010", + "location": "LA, CA", + "follow_request_sent": null, + "profile_link_color": "0084B4", + "is_translator": false, + "id_str": "137238150", + "entities": { + "url": { + "urls": [ + { + "expanded_url": null, + "url": "", + "indices": [ + 0, + 0 + ] + } + ] + }, + "description": { + "urls": [ + + ] + } + }, + "default_profile": true, + "contributors_enabled": false, + "favourites_count": 0, + "url": null, + "profile_image_url_https": "https://si0.twimg.com/profile_images/2359746665/1v6zfgqo8g0d3mk7ii5s_normal.jpeg", + "utc_offset": -28800, + "id": 137238150, + "profile_use_background_image": true, + "listed_count": 2, + "profile_text_color": "333333", + "lang": "en", + "followers_count": 70, + "protected": false, + "notifications": null, + "profile_background_image_url_https": "https://si0.twimg.com/images/themes/theme1/bg.png", + "profile_background_color": "C0DEED", + "verified": false, + "geo_enabled": true, + "time_zone": "Pacific Time (US & Canada)", + "description": "Born 330 Live 310", + "default_profile_image": false, + "profile_background_image_url": "http://a0.twimg.com/images/themes/theme1/bg.png", + "statuses_count": 579, + "friends_count": 110, + "following": null, + "show_all_inline_media": false, + "screen_name": "sean_cummings" + }, + "in_reply_to_screen_name": null, + "source": "<a href=\"//itunes.apple.com/us/app/twitter/id409789998?mt=12%5C%22\" rel=\"\\\"nofollow\\\"\">Twitter for Mac</a>", + "in_reply_to_status_id": null + }, + { + "coordinates": null, + "favorited": false, + "truncated": false, + "created_at": "Fri Sep 21 23:40:54 +0000 2012", + "id_str": "249292149810667520", + "entities": { + "urls": [ + + ], + "hashtags": [ + { + "text": "FreeBandNames", + "indices": [ + 20, + 34 + ] + } + ], + "user_mentions": [ + + ] + }, + "in_reply_to_user_id_str": null, + "contributors": null, + "text": "Thee Namaste Nerdz. #FreeBandNames", + "metadata": { + "iso_language_code": "pl", + "result_type": "recent" + }, + "retweet_count": 0, + "in_reply_to_status_id_str": null, + "id": 249292149810667520, + "geo": null, + "retweeted": false, + "in_reply_to_user_id": null, + "place": null, + "user": { + "profile_sidebar_fill_color": "DDFFCC", + "profile_sidebar_border_color": "BDDCAD", + "profile_background_tile": true, + "name": "Chaz Martenstein", + "profile_image_url": "http://a0.twimg.com/profile_images/447958234/Lichtenstein_normal.jpg", + "created_at": "Tue Apr 07 19:05:07 +0000 2009", + "location": "Durham, NC", + "follow_request_sent": null, + "profile_link_color": "0084B4", + "is_translator": false, + "id_str": "29516238", + "entities": { + "url": { + "urls": [ + { + "expanded_url": null, + "url": "http://bullcityrecords.com/wnng/", + "indices": [ + 0, + 32 + ] + } + ] + }, + "description": { + "urls": [ + + ] + } + }, + "default_profile": false, + "contributors_enabled": false, + "favourites_count": 8, + "url": "http://bullcityrecords.com/wnng/", + "profile_image_url_https": "https://si0.twimg.com/profile_images/447958234/Lichtenstein_normal.jpg", + "utc_offset": -18000, + "id": 29516238, + "profile_use_background_image": true, + "listed_count": 118, + "profile_text_color": "333333", + "lang": "en", + "followers_count": 2052, + "protected": false, + "notifications": null, + "profile_background_image_url_https": "https://si0.twimg.com/profile_background_images/9423277/background_tile.bmp", + "profile_background_color": "9AE4E8", + "verified": false, + "geo_enabled": false, + "time_zone": "Eastern Time (US & Canada)", + "description": "You will come to Durham, North Carolina. I will sell you some records then, here in Durham, North Carolina. Fun will happen.", + "default_profile_image": false, + "profile_background_image_url": "http://a0.twimg.com/profile_background_images/9423277/background_tile.bmp", + "statuses_count": 7579, + "friends_count": 348, + "following": null, + "show_all_inline_media": true, + "screen_name": "bullcityrecords" + }, + "in_reply_to_screen_name": null, + "source": "web", + "in_reply_to_status_id": null + }, + { + "coordinates": null, + "favorited": false, + "truncated": false, + "created_at": "Fri Sep 21 23:30:20 +0000 2012", + "id_str": "249289491129438208", + "entities": { + "urls": [ + + ], + "hashtags": [ + { + "text": "freebandnames", + "indices": [ + 29, + 43 + ] + } + ], + "user_mentions": [ + + ] + }, + "in_reply_to_user_id_str": null, + "contributors": null, + "text": "Mexican Heaven, Mexican Hell #freebandnames", + "metadata": { + "iso_language_code": "en", + "result_type": "recent" + }, + "retweet_count": 0, + "in_reply_to_status_id_str": null, + "id": 249289491129438208, + "geo": null, + "retweeted": false, + "in_reply_to_user_id": null, + "place": null, + "user": { + "profile_sidebar_fill_color": "99CC33", + "profile_sidebar_border_color": "829D5E", + "profile_background_tile": false, + "name": "Thomas John Wakeman", + "profile_image_url": "http://a0.twimg.com/profile_images/2219333930/Froggystyle_normal.png", + "created_at": "Tue Sep 01 21:21:35 +0000 2009", + "location": "Kingston New York", + "follow_request_sent": null, + "profile_link_color": "D02B55", + "is_translator": false, + "id_str": "70789458", + "entities": { + "url": { + "urls": [ + { + "expanded_url": null, + "url": "", + "indices": [ + 0, + 0 + ] + } + ] + }, + "description": { + "urls": [ + + ] + } + }, + "default_profile": false, + "contributors_enabled": false, + "favourites_count": 19, + "url": null, + "profile_image_url_https": "https://si0.twimg.com/profile_images/2219333930/Froggystyle_normal.png", + "utc_offset": -18000, + "id": 70789458, + "profile_use_background_image": true, + "listed_count": 1, + "profile_text_color": "3E4415", + "lang": "en", + "followers_count": 63, + "protected": false, + "notifications": null, + "profile_background_image_url_https": "https://si0.twimg.com/images/themes/theme5/bg.gif", + "profile_background_color": "352726", + "verified": false, + "geo_enabled": false, + "time_zone": "Eastern Time (US & Canada)", + "description": "Science Fiction Writer, sort of. Likes Superheroes, Mole People, Alt. Timelines.", + "default_profile_image": false, + "profile_background_image_url": "http://a0.twimg.com/images/themes/theme5/bg.gif", + "statuses_count": 1048, + "friends_count": 63, + "following": null, + "show_all_inline_media": false, + "screen_name": "MonkiesFist" + }, + "in_reply_to_screen_name": null, + "source": "web", + "in_reply_to_status_id": null + }, + { + "coordinates": null, + "favorited": false, + "truncated": false, + "created_at": "Fri Sep 21 22:51:18 +0000 2012", + "id_str": "249279667666817024", + "entities": { + "urls": [ + + ], + "hashtags": [ + { + "text": "freebandnames", + "indices": [ + 20, + 34 + ] + } + ], + "user_mentions": [ + + ] + }, + "in_reply_to_user_id_str": null, + "contributors": null, + "text": "The Foolish Mortals #freebandnames", + "metadata": { + "iso_language_code": "en", + "result_type": "recent" + }, + "retweet_count": 0, + "in_reply_to_status_id_str": null, + "id": 249279667666817024, + "geo": null, + "retweeted": false, + "in_reply_to_user_id": null, + "place": null, + "user": { + "profile_sidebar_fill_color": "BFAC83", + "profile_sidebar_border_color": "615A44", + "profile_background_tile": true, + "name": "Marty Elmer", + "profile_image_url": "http://a0.twimg.com/profile_images/1629790393/shrinker_2000_trans_normal.png", + "created_at": "Mon May 04 00:05:00 +0000 2009", + "location": "Wisconsin, USA", + "follow_request_sent": null, + "profile_link_color": "3B2A26", + "is_translator": false, + "id_str": "37539828", + "entities": { + "url": { + "urls": [ + { + "expanded_url": null, + "url": "http://www.omnitarian.me", + "indices": [ + 0, + 24 + ] + } + ] + }, + "description": { + "urls": [ + + ] + } + }, + "default_profile": false, + "contributors_enabled": false, + "favourites_count": 647, + "url": "http://www.omnitarian.me", + "profile_image_url_https": "https://si0.twimg.com/profile_images/1629790393/shrinker_2000_trans_normal.png", + "utc_offset": -21600, + "id": 37539828, + "profile_use_background_image": true, + "listed_count": 52, + "profile_text_color": "000000", + "lang": "en", + "followers_count": 608, + "protected": false, + "notifications": null, + "profile_background_image_url_https": "https://si0.twimg.com/profile_background_images/106455659/rect6056-9.png", + "profile_background_color": "EEE3C4", + "verified": false, + "geo_enabled": false, + "time_zone": "Central Time (US & Canada)", + "description": "Cartoonist, Illustrator, and T-Shirt connoisseur", + "default_profile_image": false, + "profile_background_image_url": "http://a0.twimg.com/profile_background_images/106455659/rect6056-9.png", + "statuses_count": 3575, + "friends_count": 249, + "following": null, + "show_all_inline_media": true, + "screen_name": "Omnitarian" + }, + "in_reply_to_screen_name": null, + "source": "<a href=\"//twitter.com/download/iphone%5C%22\" rel=\"\\\"nofollow\\\"\">Twitter for iPhone</a>", + "in_reply_to_status_id": null + } + ], + "search_metadata": { + "max_id": 250126199840518145, + "since_id": 24012619984051000, + "refresh_url": "?since_id=250126199840518145&q=%23freebandnames&result_type=mixed&include_entities=1", + "next_results": "?max_id=249279667666817023&q=%23freebandnames&count=4&include_entities=1&result_type=mixed", + "count": 4, + "completed_in": 0.035, + "since_id_str": "24012619984051000", + "query": "%23freebandnames", + "max_id_str": "250126199840518145" + } +} diff --git a/vendor/github.com/mailru/easyjson/benchmark/ffjson_test.go b/vendor/github.com/mailru/easyjson/benchmark/ffjson_test.go new file mode 100644 index 000000000..03671827c --- /dev/null +++ b/vendor/github.com/mailru/easyjson/benchmark/ffjson_test.go @@ -0,0 +1,190 @@ +// +build use_ffjson + +package benchmark + +import ( + "testing" + + "github.com/pquerna/ffjson/ffjson" +) + +func BenchmarkFF_Unmarshal_M(b *testing.B) { + b.SetBytes(int64(len(largeStructText))) + for i := 0; i < b.N; i++ { + var s LargeStruct + err := ffjson.UnmarshalFast(largeStructText, &s) + if err != nil { + b.Error(err) + } + } +} + +func BenchmarkFF_Unmarshal_S(b *testing.B) { + for i := 0; i < b.N; i++ { + var s Entities + err := ffjson.UnmarshalFast(smallStructText, &s) + if err != nil { + b.Error(err) + } + } + b.SetBytes(int64(len(smallStructText))) +} + +func BenchmarkFF_Marshal_M(b *testing.B) { + var l int64 + for i := 0; i < b.N; i++ { + data, err := ffjson.MarshalFast(&largeStructData) + if err != nil { + b.Error(err) + } + l = int64(len(data)) + } + b.SetBytes(l) +} + +func BenchmarkFF_Marshal_S(b *testing.B) { + var l int64 + for i := 0; i < b.N; i++ { + data, err := ffjson.MarshalFast(&smallStructData) + if err != nil { + b.Error(err) + } + l = int64(len(data)) + } + b.SetBytes(l) +} + +func BenchmarkFF_Marshal_M_Pool(b *testing.B) { + var l int64 + for i := 0; i < b.N; i++ { + data, err := ffjson.MarshalFast(&largeStructData) + if err != nil { + b.Error(err) + } + l = int64(len(data)) + ffjson.Pool(data) + } + b.SetBytes(l) +} + +func BenchmarkFF_Marshal_L(b *testing.B) { + var l int64 + for i := 0; i < b.N; i++ { + data, err := ffjson.MarshalFast(&xlStructData) + if err != nil { + b.Error(err) + } + l = int64(len(data)) + } + b.SetBytes(l) +} + +func BenchmarkFF_Marshal_L_Pool(b *testing.B) { + var l int64 + for i := 0; i < b.N; i++ { + data, err := ffjson.MarshalFast(&xlStructData) + if err != nil { + b.Error(err) + } + l = int64(len(data)) + ffjson.Pool(data) + } + b.SetBytes(l) +} + +func BenchmarkFF_Marshal_L_Pool_Parallel(b *testing.B) { + var l int64 + for i := 0; i < b.N; i++ { + data, err := ffjson.MarshalFast(&xlStructData) + if err != nil { + b.Error(err) + } + l = int64(len(data)) + ffjson.Pool(data) + } + b.SetBytes(l) +} +func BenchmarkFF_Marshal_M_Pool_Parallel(b *testing.B) { + var l int64 + b.RunParallel(func(pb *testing.PB) { + for pb.Next() { + data, err := ffjson.MarshalFast(&largeStructData) + if err != nil { + b.Error(err) + } + l = int64(len(data)) + ffjson.Pool(data) + } + }) + b.SetBytes(l) +} + +func BenchmarkFF_Marshal_S_Pool(b *testing.B) { + var l int64 + for i := 0; i < b.N; i++ { + data, err := ffjson.MarshalFast(&smallStructData) + if err != nil { + b.Error(err) + } + l = int64(len(data)) + ffjson.Pool(data) + } + b.SetBytes(l) +} + +func BenchmarkFF_Marshal_S_Pool_Parallel(b *testing.B) { + var l int64 + b.RunParallel(func(pb *testing.PB) { + for pb.Next() { + data, err := ffjson.MarshalFast(&smallStructData) + if err != nil { + b.Error(err) + } + l = int64(len(data)) + ffjson.Pool(data) + } + }) + b.SetBytes(l) +} + +func BenchmarkFF_Marshal_S_Parallel(b *testing.B) { + var l int64 + b.RunParallel(func(pb *testing.PB) { + for pb.Next() { + data, err := ffjson.MarshalFast(&smallStructData) + if err != nil { + b.Error(err) + } + l = int64(len(data)) + } + }) + b.SetBytes(l) +} + +func BenchmarkFF_Marshal_M_Parallel(b *testing.B) { + var l int64 + b.RunParallel(func(pb *testing.PB) { + for pb.Next() { + data, err := ffjson.MarshalFast(&largeStructData) + if err != nil { + b.Error(err) + } + l = int64(len(data)) + } + }) + b.SetBytes(l) +} + +func BenchmarkFF_Marshal_L_Parallel(b *testing.B) { + var l int64 + b.RunParallel(func(pb *testing.PB) { + for pb.Next() { + data, err := ffjson.MarshalFast(&xlStructData) + if err != nil { + b.Error(err) + } + l = int64(len(data)) + } + }) + b.SetBytes(l) +} diff --git a/vendor/github.com/mailru/easyjson/benchmark/jsoniter_test.go b/vendor/github.com/mailru/easyjson/benchmark/jsoniter_test.go new file mode 100644 index 000000000..004f891da --- /dev/null +++ b/vendor/github.com/mailru/easyjson/benchmark/jsoniter_test.go @@ -0,0 +1,119 @@ +// +build use_jsoniter + +package benchmark + +import ( + "testing" + + jsoniter "github.com/json-iterator/go" +) + +func BenchmarkJI_Unmarshal_M(b *testing.B) { + b.SetBytes(int64(len(largeStructText))) + for i := 0; i < b.N; i++ { + var s LargeStruct + err := jsoniter.Unmarshal(largeStructText, &s) + if err != nil { + b.Error(err) + } + } +} + +func BenchmarkJI_Unmarshal_S(b *testing.B) { + for i := 0; i < b.N; i++ { + var s Entities + err := jsoniter.Unmarshal(smallStructText, &s) + if err != nil { + b.Error(err) + } + } + b.SetBytes(int64(len(smallStructText))) +} + +func BenchmarkJI_Marshal_M(b *testing.B) { + var l int64 + for i := 0; i < b.N; i++ { + data, err := jsoniter.Marshal(&largeStructData) + if err != nil { + b.Error(err) + } + l = int64(len(data)) + } + b.SetBytes(l) +} + +func BenchmarkJI_Marshal_L(b *testing.B) { + var l int64 + for i := 0; i < b.N; i++ { + data, err := jsoniter.Marshal(&xlStructData) + if err != nil { + b.Error(err) + } + l = int64(len(data)) + } + b.SetBytes(l) +} + +func BenchmarkJI_Marshal_M_Parallel(b *testing.B) { + var l int64 + b.RunParallel(func(pb *testing.PB) { + for pb.Next() { + data, err := jsoniter.Marshal(&largeStructData) + if err != nil { + b.Error(err) + } + l = int64(len(data)) + } + }) + b.SetBytes(l) +} + +func BenchmarkJI_Marshal_L_Parallel(b *testing.B) { + var l int64 + b.RunParallel(func(pb *testing.PB) { + for pb.Next() { + data, err := jsoniter.Marshal(&xlStructData) + if err != nil { + b.Error(err) + } + l = int64(len(data)) + } + }) + b.SetBytes(l) +} + +func BenchmarkJI_Marshal_S(b *testing.B) { + var l int64 + for i := 0; i < b.N; i++ { + data, err := jsoniter.Marshal(&smallStructData) + if err != nil { + b.Error(err) + } + l = int64(len(data)) + } + b.SetBytes(l) +} + +func BenchmarkJI_Marshal_S_Parallel(b *testing.B) { + var l int64 + b.RunParallel(func(pb *testing.PB) { + for pb.Next() { + data, err := jsoniter.Marshal(&smallStructData) + if err != nil { + b.Error(err) + } + l = int64(len(data)) + } + }) + b.SetBytes(l) +} + +func BenchmarkJI_Marshal_M_ToWriter(b *testing.B) { + enc := jsoniter.NewEncoder(&DummyWriter{}) + for i := 0; i < b.N; i++ { + err := enc.Encode(&largeStructData) + if err != nil { + b.Error(err) + } + } +} diff --git a/vendor/github.com/mailru/easyjson/benchmark/ujson.sh b/vendor/github.com/mailru/easyjson/benchmark/ujson.sh new file mode 100755 index 000000000..378e7df46 --- /dev/null +++ b/vendor/github.com/mailru/easyjson/benchmark/ujson.sh @@ -0,0 +1,7 @@ +#/bin/bash + +echo -n "Python ujson module, DECODE: " +python -m timeit -s "import ujson; data = open('`dirname $0`/example.json', 'r').read()" 'ujson.loads(data)' + +echo -n "Python ujson module, ENCODE: " +python -m timeit -s "import ujson; data = open('`dirname $0`/example.json', 'r').read(); obj = ujson.loads(data)" 'ujson.dumps(obj)' diff --git a/vendor/github.com/mailru/easyjson/bootstrap/bootstrap.go b/vendor/github.com/mailru/easyjson/bootstrap/bootstrap.go new file mode 100644 index 000000000..3c20e09ca --- /dev/null +++ b/vendor/github.com/mailru/easyjson/bootstrap/bootstrap.go @@ -0,0 +1,188 @@ +// Package bootstrap implements the bootstrapping logic: generation of a .go file to +// launch the actual generator and launching the generator itself. +// +// The package may be preferred to a command-line utility if generating the serializers +// from golang code is required. +package bootstrap + +import ( + "fmt" + "io/ioutil" + "os" + "os/exec" + "path/filepath" + "sort" +) + +const genPackage = "github.com/mailru/easyjson/gen" +const pkgWriter = "github.com/mailru/easyjson/jwriter" +const pkgLexer = "github.com/mailru/easyjson/jlexer" + +type Generator struct { + PkgPath, PkgName string + Types []string + + NoStdMarshalers bool + SnakeCase bool + LowerCamelCase bool + OmitEmpty bool + + OutName string + BuildTags string + + StubsOnly bool + LeaveTemps bool + NoFormat bool +} + +// writeStub outputs an initial stubs for marshalers/unmarshalers so that the package +// using marshalers/unmarshales compiles correctly for boostrapping code. +func (g *Generator) writeStub() error { + f, err := os.Create(g.OutName) + if err != nil { + return err + } + defer f.Close() + + if g.BuildTags != "" { + fmt.Fprintln(f, "// +build ", g.BuildTags) + fmt.Fprintln(f) + } + fmt.Fprintln(f, "// TEMPORARY AUTOGENERATED FILE: easyjson stub code to make the package") + fmt.Fprintln(f, "// compilable during generation.") + fmt.Fprintln(f) + fmt.Fprintln(f, "package ", g.PkgName) + + if len(g.Types) > 0 { + fmt.Fprintln(f) + fmt.Fprintln(f, "import (") + fmt.Fprintln(f, ` "`+pkgWriter+`"`) + fmt.Fprintln(f, ` "`+pkgLexer+`"`) + fmt.Fprintln(f, ")") + } + + sort.Strings(g.Types) + for _, t := range g.Types { + fmt.Fprintln(f) + if !g.NoStdMarshalers { + fmt.Fprintln(f, "func (", t, ") MarshalJSON() ([]byte, error) { return nil, nil }") + fmt.Fprintln(f, "func (*", t, ") UnmarshalJSON([]byte) error { return nil }") + } + + fmt.Fprintln(f, "func (", t, ") MarshalEasyJSON(w *jwriter.Writer) {}") + fmt.Fprintln(f, "func (*", t, ") UnmarshalEasyJSON(l *jlexer.Lexer) {}") + fmt.Fprintln(f) + fmt.Fprintln(f, "type EasyJSON_exporter_"+t+" *"+t) + } + return nil +} + +// writeMain creates a .go file that launches the generator if 'go run'. +func (g *Generator) writeMain() (path string, err error) { + f, err := ioutil.TempFile(filepath.Dir(g.OutName), "easyjson-bootstrap") + if err != nil { + return "", err + } + + fmt.Fprintln(f, "// +build ignore") + fmt.Fprintln(f) + fmt.Fprintln(f, "// TEMPORARY AUTOGENERATED FILE: easyjson bootstapping code to launch") + fmt.Fprintln(f, "// the actual generator.") + fmt.Fprintln(f) + fmt.Fprintln(f, "package main") + fmt.Fprintln(f) + fmt.Fprintln(f, "import (") + fmt.Fprintln(f, ` "fmt"`) + fmt.Fprintln(f, ` "os"`) + fmt.Fprintln(f) + fmt.Fprintf(f, " %q\n", genPackage) + if len(g.Types) > 0 { + fmt.Fprintln(f) + fmt.Fprintf(f, " pkg %q\n", g.PkgPath) + } + fmt.Fprintln(f, ")") + fmt.Fprintln(f) + fmt.Fprintln(f, "func main() {") + fmt.Fprintf(f, " g := gen.NewGenerator(%q)\n", filepath.Base(g.OutName)) + fmt.Fprintf(f, " g.SetPkg(%q, %q)\n", g.PkgName, g.PkgPath) + if g.BuildTags != "" { + fmt.Fprintf(f, " g.SetBuildTags(%q)\n", g.BuildTags) + } + if g.SnakeCase { + fmt.Fprintln(f, " g.UseSnakeCase()") + } + if g.LowerCamelCase { + fmt.Fprintln(f, " g.UseLowerCamelCase()") + } + if g.OmitEmpty { + fmt.Fprintln(f, " g.OmitEmpty()") + } + if g.NoStdMarshalers { + fmt.Fprintln(f, " g.NoStdMarshalers()") + } + + sort.Strings(g.Types) + for _, v := range g.Types { + fmt.Fprintln(f, " g.Add(pkg.EasyJSON_exporter_"+v+"(nil))") + } + + fmt.Fprintln(f, " if err := g.Run(os.Stdout); err != nil {") + fmt.Fprintln(f, " fmt.Fprintln(os.Stderr, err)") + fmt.Fprintln(f, " os.Exit(1)") + fmt.Fprintln(f, " }") + fmt.Fprintln(f, "}") + + src := f.Name() + if err := f.Close(); err != nil { + return src, err + } + + dest := src + ".go" + return dest, os.Rename(src, dest) +} + +func (g *Generator) Run() error { + if err := g.writeStub(); err != nil { + return err + } + if g.StubsOnly { + return nil + } + + path, err := g.writeMain() + if err != nil { + return err + } + if !g.LeaveTemps { + defer os.Remove(path) + } + + f, err := os.Create(g.OutName + ".tmp") + if err != nil { + return err + } + if !g.LeaveTemps { + defer os.Remove(f.Name()) // will not remove after rename + } + + cmd := exec.Command("go", "run", "-tags", g.BuildTags, path) + cmd.Stdout = f + cmd.Stderr = os.Stderr + if err = cmd.Run(); err != nil { + return err + } + + f.Close() + + if !g.NoFormat { + cmd = exec.Command("gofmt", "-w", f.Name()) + cmd.Stderr = os.Stderr + cmd.Stdout = os.Stdout + + if err = cmd.Run(); err != nil { + return err + } + } + + return os.Rename(f.Name(), g.OutName) +} diff --git a/vendor/github.com/mailru/easyjson/buffer/pool.go b/vendor/github.com/mailru/easyjson/buffer/pool.go new file mode 100644 index 000000000..07fb4bc1f --- /dev/null +++ b/vendor/github.com/mailru/easyjson/buffer/pool.go @@ -0,0 +1,270 @@ +// Package buffer implements a buffer for serialization, consisting of a chain of []byte-s to +// reduce copying and to allow reuse of individual chunks. +package buffer + +import ( + "io" + "sync" +) + +// PoolConfig contains configuration for the allocation and reuse strategy. +type PoolConfig struct { + StartSize int // Minimum chunk size that is allocated. + PooledSize int // Minimum chunk size that is reused, reusing chunks too small will result in overhead. + MaxSize int // Maximum chunk size that will be allocated. +} + +var config = PoolConfig{ + StartSize: 128, + PooledSize: 512, + MaxSize: 32768, +} + +// Reuse pool: chunk size -> pool. +var buffers = map[int]*sync.Pool{} + +func initBuffers() { + for l := config.PooledSize; l <= config.MaxSize; l *= 2 { + buffers[l] = new(sync.Pool) + } +} + +func init() { + initBuffers() +} + +// Init sets up a non-default pooling and allocation strategy. Should be run before serialization is done. +func Init(cfg PoolConfig) { + config = cfg + initBuffers() +} + +// putBuf puts a chunk to reuse pool if it can be reused. +func putBuf(buf []byte) { + size := cap(buf) + if size < config.PooledSize { + return + } + if c := buffers[size]; c != nil { + c.Put(buf[:0]) + } +} + +// getBuf gets a chunk from reuse pool or creates a new one if reuse failed. +func getBuf(size int) []byte { + if size < config.PooledSize { + return make([]byte, 0, size) + } + + if c := buffers[size]; c != nil { + v := c.Get() + if v != nil { + return v.([]byte) + } + } + return make([]byte, 0, size) +} + +// Buffer is a buffer optimized for serialization without extra copying. +type Buffer struct { + + // Buf is the current chunk that can be used for serialization. + Buf []byte + + toPool []byte + bufs [][]byte +} + +// EnsureSpace makes sure that the current chunk contains at least s free bytes, +// possibly creating a new chunk. +func (b *Buffer) EnsureSpace(s int) { + if cap(b.Buf)-len(b.Buf) >= s { + return + } + l := len(b.Buf) + if l > 0 { + if cap(b.toPool) != cap(b.Buf) { + // Chunk was reallocated, toPool can be pooled. + putBuf(b.toPool) + } + if cap(b.bufs) == 0 { + b.bufs = make([][]byte, 0, 8) + } + b.bufs = append(b.bufs, b.Buf) + l = cap(b.toPool) * 2 + } else { + l = config.StartSize + } + + if l > config.MaxSize { + l = config.MaxSize + } + b.Buf = getBuf(l) + b.toPool = b.Buf +} + +// AppendByte appends a single byte to buffer. +func (b *Buffer) AppendByte(data byte) { + if cap(b.Buf) == len(b.Buf) { // EnsureSpace won't be inlined. + b.EnsureSpace(1) + } + b.Buf = append(b.Buf, data) +} + +// AppendBytes appends a byte slice to buffer. +func (b *Buffer) AppendBytes(data []byte) { + for len(data) > 0 { + if cap(b.Buf) == len(b.Buf) { // EnsureSpace won't be inlined. + b.EnsureSpace(1) + } + + sz := cap(b.Buf) - len(b.Buf) + if sz > len(data) { + sz = len(data) + } + + b.Buf = append(b.Buf, data[:sz]...) + data = data[sz:] + } +} + +// AppendBytes appends a string to buffer. +func (b *Buffer) AppendString(data string) { + for len(data) > 0 { + if cap(b.Buf) == len(b.Buf) { // EnsureSpace won't be inlined. + b.EnsureSpace(1) + } + + sz := cap(b.Buf) - len(b.Buf) + if sz > len(data) { + sz = len(data) + } + + b.Buf = append(b.Buf, data[:sz]...) + data = data[sz:] + } +} + +// Size computes the size of a buffer by adding sizes of every chunk. +func (b *Buffer) Size() int { + size := len(b.Buf) + for _, buf := range b.bufs { + size += len(buf) + } + return size +} + +// DumpTo outputs the contents of a buffer to a writer and resets the buffer. +func (b *Buffer) DumpTo(w io.Writer) (written int, err error) { + var n int + for _, buf := range b.bufs { + if err == nil { + n, err = w.Write(buf) + written += n + } + putBuf(buf) + } + + if err == nil { + n, err = w.Write(b.Buf) + written += n + } + putBuf(b.toPool) + + b.bufs = nil + b.Buf = nil + b.toPool = nil + + return +} + +// BuildBytes creates a single byte slice with all the contents of the buffer. Data is +// copied if it does not fit in a single chunk. You can optionally provide one byte +// slice as argument that it will try to reuse. +func (b *Buffer) BuildBytes(reuse ...[]byte) []byte { + if len(b.bufs) == 0 { + ret := b.Buf + b.toPool = nil + b.Buf = nil + return ret + } + + var ret []byte + size := b.Size() + + // If we got a buffer as argument and it is big enought, reuse it. + if len(reuse) == 1 && cap(reuse[0]) >= size { + ret = reuse[0][:0] + } else { + ret = make([]byte, 0, size) + } + for _, buf := range b.bufs { + ret = append(ret, buf...) + putBuf(buf) + } + + ret = append(ret, b.Buf...) + putBuf(b.toPool) + + b.bufs = nil + b.toPool = nil + b.Buf = nil + + return ret +} + +type readCloser struct { + offset int + bufs [][]byte +} + +func (r *readCloser) Read(p []byte) (n int, err error) { + for _, buf := range r.bufs { + // Copy as much as we can. + x := copy(p[n:], buf[r.offset:]) + n += x // Increment how much we filled. + + // Did we empty the whole buffer? + if r.offset+x == len(buf) { + // On to the next buffer. + r.offset = 0 + r.bufs = r.bufs[1:] + + // We can release this buffer. + putBuf(buf) + } else { + r.offset += x + } + + if n == len(p) { + break + } + } + // No buffers left or nothing read? + if len(r.bufs) == 0 { + err = io.EOF + } + return +} + +func (r *readCloser) Close() error { + // Release all remaining buffers. + for _, buf := range r.bufs { + putBuf(buf) + } + // In case Close gets called multiple times. + r.bufs = nil + + return nil +} + +// ReadCloser creates an io.ReadCloser with all the contents of the buffer. +func (b *Buffer) ReadCloser() io.ReadCloser { + ret := &readCloser{0, append(b.bufs, b.Buf)} + + b.bufs = nil + b.toPool = nil + b.Buf = nil + + return ret +} diff --git a/vendor/github.com/mailru/easyjson/buffer/pool_test.go b/vendor/github.com/mailru/easyjson/buffer/pool_test.go new file mode 100644 index 000000000..680623ace --- /dev/null +++ b/vendor/github.com/mailru/easyjson/buffer/pool_test.go @@ -0,0 +1,107 @@ +package buffer + +import ( + "bytes" + "testing" +) + +func TestAppendByte(t *testing.T) { + var b Buffer + var want []byte + + for i := 0; i < 1000; i++ { + b.AppendByte(1) + b.AppendByte(2) + want = append(want, 1, 2) + } + + got := b.BuildBytes() + if !bytes.Equal(got, want) { + t.Errorf("BuildBytes() = %v; want %v", got, want) + } +} + +func TestAppendBytes(t *testing.T) { + var b Buffer + var want []byte + + for i := 0; i < 1000; i++ { + b.AppendBytes([]byte{1, 2}) + want = append(want, 1, 2) + } + + got := b.BuildBytes() + if !bytes.Equal(got, want) { + t.Errorf("BuildBytes() = %v; want %v", got, want) + } +} + +func TestAppendString(t *testing.T) { + var b Buffer + var want []byte + + s := "test" + for i := 0; i < 1000; i++ { + b.AppendBytes([]byte(s)) + want = append(want, s...) + } + + got := b.BuildBytes() + if !bytes.Equal(got, want) { + t.Errorf("BuildBytes() = %v; want %v", got, want) + } +} + +func TestDumpTo(t *testing.T) { + var b Buffer + var want []byte + + s := "test" + for i := 0; i < 1000; i++ { + b.AppendBytes([]byte(s)) + want = append(want, s...) + } + + out := &bytes.Buffer{} + n, err := b.DumpTo(out) + if err != nil { + t.Errorf("DumpTo() error: %v", err) + } + + got := out.Bytes() + if !bytes.Equal(got, want) { + t.Errorf("DumpTo(): got %v; want %v", got, want) + } + + if n != len(want) { + t.Errorf("DumpTo() = %v; want %v", n, len(want)) + } +} + +func TestReadCloser(t *testing.T) { + var b Buffer + var want []byte + + s := "test" + for i := 0; i < 1000; i++ { + b.AppendBytes([]byte(s)) + want = append(want, s...) + } + + out := &bytes.Buffer{} + rc := b.ReadCloser() + n, err := out.ReadFrom(rc) + if err != nil { + t.Errorf("ReadCloser() error: %v", err) + } + rc.Close() // Will always return nil + + got := out.Bytes() + if !bytes.Equal(got, want) { + t.Errorf("DumpTo(): got %v; want %v", got, want) + } + + if n != int64(len(want)) { + t.Errorf("DumpTo() = %v; want %v", n, len(want)) + } +} diff --git a/vendor/github.com/mailru/easyjson/easyjson/main.go b/vendor/github.com/mailru/easyjson/easyjson/main.go new file mode 100644 index 000000000..1cd30bb36 --- /dev/null +++ b/vendor/github.com/mailru/easyjson/easyjson/main.go @@ -0,0 +1,106 @@ +package main + +import ( + "errors" + "flag" + "fmt" + "os" + "path/filepath" + "strings" + + "github.com/mailru/easyjson/bootstrap" + // Reference the gen package to be friendly to vendoring tools, + // as it is an indirect dependency. + // (The temporary bootstrapping code uses it.) + _ "github.com/mailru/easyjson/gen" + "github.com/mailru/easyjson/parser" +) + +var buildTags = flag.String("build_tags", "", "build tags to add to generated file") +var snakeCase = flag.Bool("snake_case", false, "use snake_case names instead of CamelCase by default") +var lowerCamelCase = flag.Bool("lower_camel_case", false, "use lowerCamelCase names instead of CamelCase by default") +var noStdMarshalers = flag.Bool("no_std_marshalers", false, "don't generate MarshalJSON/UnmarshalJSON funcs") +var omitEmpty = flag.Bool("omit_empty", false, "omit empty fields by default") +var allStructs = flag.Bool("all", false, "generate marshaler/unmarshalers for all structs in a file") +var leaveTemps = flag.Bool("leave_temps", false, "do not delete temporary files") +var stubs = flag.Bool("stubs", false, "only generate stubs for marshaler/unmarshaler funcs") +var noformat = flag.Bool("noformat", false, "do not run 'gofmt -w' on output file") +var specifiedName = flag.String("output_filename", "", "specify the filename of the output") +var processPkg = flag.Bool("pkg", false, "process the whole package instead of just the given file") + +func generate(fname string) (err error) { + fInfo, err := os.Stat(fname) + if err != nil { + return err + } + + p := parser.Parser{AllStructs: *allStructs} + if err := p.Parse(fname, fInfo.IsDir()); err != nil { + return fmt.Errorf("Error parsing %v: %v", fname, err) + } + + var outName string + if fInfo.IsDir() { + outName = filepath.Join(fname, p.PkgName+"_easyjson.go") + } else { + if s := strings.TrimSuffix(fname, ".go"); s == fname { + return errors.New("Filename must end in '.go'") + } else { + outName = s + "_easyjson.go" + } + } + + if *specifiedName != "" { + outName = *specifiedName + } + + var trimmedBuildTags string + if *buildTags != "" { + trimmedBuildTags = strings.TrimSpace(*buildTags) + } + + g := bootstrap.Generator{ + BuildTags: trimmedBuildTags, + PkgPath: p.PkgPath, + PkgName: p.PkgName, + Types: p.StructNames, + SnakeCase: *snakeCase, + LowerCamelCase: *lowerCamelCase, + NoStdMarshalers: *noStdMarshalers, + OmitEmpty: *omitEmpty, + LeaveTemps: *leaveTemps, + OutName: outName, + StubsOnly: *stubs, + NoFormat: *noformat, + } + + if err := g.Run(); err != nil { + return fmt.Errorf("Bootstrap failed: %v", err) + } + return nil +} + +func main() { + flag.Parse() + + files := flag.Args() + + gofile := os.Getenv("GOFILE") + if *processPkg { + gofile = filepath.Dir(gofile) + } + + if len(files) == 0 && gofile != "" { + files = []string{gofile} + } else if len(files) == 0 { + flag.Usage() + os.Exit(1) + } + + for _, fname := range files { + if err := generate(fname); err != nil { + fmt.Fprintln(os.Stderr, err) + os.Exit(1) + } + } +} diff --git a/vendor/github.com/mailru/easyjson/gen/decoder.go b/vendor/github.com/mailru/easyjson/gen/decoder.go new file mode 100644 index 000000000..021933ac8 --- /dev/null +++ b/vendor/github.com/mailru/easyjson/gen/decoder.go @@ -0,0 +1,489 @@ +package gen + +import ( + "encoding" + "encoding/json" + "fmt" + "reflect" + "strings" + "unicode" + + "github.com/mailru/easyjson" +) + +// Target this byte size for initial slice allocation to reduce garbage collection. +const minSliceBytes = 64 + +func (g *Generator) getDecoderName(t reflect.Type) string { + return g.functionName("decode", t) +} + +var primitiveDecoders = map[reflect.Kind]string{ + reflect.String: "in.String()", + reflect.Bool: "in.Bool()", + reflect.Int: "in.Int()", + reflect.Int8: "in.Int8()", + reflect.Int16: "in.Int16()", + reflect.Int32: "in.Int32()", + reflect.Int64: "in.Int64()", + reflect.Uint: "in.Uint()", + reflect.Uint8: "in.Uint8()", + reflect.Uint16: "in.Uint16()", + reflect.Uint32: "in.Uint32()", + reflect.Uint64: "in.Uint64()", + reflect.Float32: "in.Float32()", + reflect.Float64: "in.Float64()", +} + +var primitiveStringDecoders = map[reflect.Kind]string{ + reflect.String: "in.String()", + reflect.Int: "in.IntStr()", + reflect.Int8: "in.Int8Str()", + reflect.Int16: "in.Int16Str()", + reflect.Int32: "in.Int32Str()", + reflect.Int64: "in.Int64Str()", + reflect.Uint: "in.UintStr()", + reflect.Uint8: "in.Uint8Str()", + reflect.Uint16: "in.Uint16Str()", + reflect.Uint32: "in.Uint32Str()", + reflect.Uint64: "in.Uint64Str()", + reflect.Uintptr: "in.UintptrStr()", +} + +var customDecoders = map[string]string{ + "json.Number": "in.JsonNumber()", +} + +// genTypeDecoder generates decoding code for the type t, but uses unmarshaler interface if implemented by t. +func (g *Generator) genTypeDecoder(t reflect.Type, out string, tags fieldTags, indent int) error { + ws := strings.Repeat(" ", indent) + + unmarshalerIface := reflect.TypeOf((*easyjson.Unmarshaler)(nil)).Elem() + if reflect.PtrTo(t).Implements(unmarshalerIface) { + fmt.Fprintln(g.out, ws+"("+out+").UnmarshalEasyJSON(in)") + return nil + } + + unmarshalerIface = reflect.TypeOf((*json.Unmarshaler)(nil)).Elem() + if reflect.PtrTo(t).Implements(unmarshalerIface) { + fmt.Fprintln(g.out, ws+"if data := in.Raw(); in.Ok() {") + fmt.Fprintln(g.out, ws+" in.AddError( ("+out+").UnmarshalJSON(data) )") + fmt.Fprintln(g.out, ws+"}") + return nil + } + + unmarshalerIface = reflect.TypeOf((*encoding.TextUnmarshaler)(nil)).Elem() + if reflect.PtrTo(t).Implements(unmarshalerIface) { + fmt.Fprintln(g.out, ws+"if data := in.UnsafeBytes(); in.Ok() {") + fmt.Fprintln(g.out, ws+" in.AddError( ("+out+").UnmarshalText(data) )") + fmt.Fprintln(g.out, ws+"}") + return nil + } + + err := g.genTypeDecoderNoCheck(t, out, tags, indent) + return err +} + +// genTypeDecoderNoCheck generates decoding code for the type t. +func (g *Generator) genTypeDecoderNoCheck(t reflect.Type, out string, tags fieldTags, indent int) error { + ws := strings.Repeat(" ", indent) + // Check whether type is primitive, needs to be done after interface check. + if dec := customDecoders[t.String()]; dec != "" { + fmt.Fprintln(g.out, ws+out+" = "+dec) + return nil + } else if dec := primitiveStringDecoders[t.Kind()]; dec != "" && tags.asString { + fmt.Fprintln(g.out, ws+out+" = "+g.getType(t)+"("+dec+")") + return nil + } else if dec := primitiveDecoders[t.Kind()]; dec != "" { + fmt.Fprintln(g.out, ws+out+" = "+g.getType(t)+"("+dec+")") + return nil + } + + switch t.Kind() { + case reflect.Slice: + tmpVar := g.uniqueVarName() + elem := t.Elem() + + if elem.Kind() == reflect.Uint8 { + fmt.Fprintln(g.out, ws+"if in.IsNull() {") + fmt.Fprintln(g.out, ws+" in.Skip()") + fmt.Fprintln(g.out, ws+" "+out+" = nil") + fmt.Fprintln(g.out, ws+"} else {") + fmt.Fprintln(g.out, ws+" "+out+" = in.Bytes()") + fmt.Fprintln(g.out, ws+"}") + + } else { + + capacity := minSliceBytes / elem.Size() + if capacity == 0 { + capacity = 1 + } + + fmt.Fprintln(g.out, ws+"if in.IsNull() {") + fmt.Fprintln(g.out, ws+" in.Skip()") + fmt.Fprintln(g.out, ws+" "+out+" = nil") + fmt.Fprintln(g.out, ws+"} else {") + fmt.Fprintln(g.out, ws+" in.Delim('[')") + fmt.Fprintln(g.out, ws+" if "+out+" == nil {") + fmt.Fprintln(g.out, ws+" if !in.IsDelim(']') {") + fmt.Fprintln(g.out, ws+" "+out+" = make("+g.getType(t)+", 0, "+fmt.Sprint(capacity)+")") + fmt.Fprintln(g.out, ws+" } else {") + fmt.Fprintln(g.out, ws+" "+out+" = "+g.getType(t)+"{}") + fmt.Fprintln(g.out, ws+" }") + fmt.Fprintln(g.out, ws+" } else { ") + fmt.Fprintln(g.out, ws+" "+out+" = ("+out+")[:0]") + fmt.Fprintln(g.out, ws+" }") + fmt.Fprintln(g.out, ws+" for !in.IsDelim(']') {") + fmt.Fprintln(g.out, ws+" var "+tmpVar+" "+g.getType(elem)) + + if err := g.genTypeDecoder(elem, tmpVar, tags, indent+2); err != nil { + return err + } + + fmt.Fprintln(g.out, ws+" "+out+" = append("+out+", "+tmpVar+")") + fmt.Fprintln(g.out, ws+" in.WantComma()") + fmt.Fprintln(g.out, ws+" }") + fmt.Fprintln(g.out, ws+" in.Delim(']')") + fmt.Fprintln(g.out, ws+"}") + } + + case reflect.Array: + iterVar := g.uniqueVarName() + elem := t.Elem() + + if elem.Kind() == reflect.Uint8 { + fmt.Fprintln(g.out, ws+"if in.IsNull() {") + fmt.Fprintln(g.out, ws+" in.Skip()") + fmt.Fprintln(g.out, ws+"} else {") + fmt.Fprintln(g.out, ws+" copy("+out+"[:], in.Bytes())") + fmt.Fprintln(g.out, ws+"}") + + } else { + + length := t.Len() + + fmt.Fprintln(g.out, ws+"if in.IsNull() {") + fmt.Fprintln(g.out, ws+" in.Skip()") + fmt.Fprintln(g.out, ws+"} else {") + fmt.Fprintln(g.out, ws+" in.Delim('[')") + fmt.Fprintln(g.out, ws+" "+iterVar+" := 0") + fmt.Fprintln(g.out, ws+" for !in.IsDelim(']') {") + fmt.Fprintln(g.out, ws+" if "+iterVar+" < "+fmt.Sprint(length)+" {") + + if err := g.genTypeDecoder(elem, out+"["+iterVar+"]", tags, indent+3); err != nil { + return err + } + + fmt.Fprintln(g.out, ws+" "+iterVar+"++") + fmt.Fprintln(g.out, ws+" } else {") + fmt.Fprintln(g.out, ws+" in.SkipRecursive()") + fmt.Fprintln(g.out, ws+" }") + fmt.Fprintln(g.out, ws+" in.WantComma()") + fmt.Fprintln(g.out, ws+" }") + fmt.Fprintln(g.out, ws+" in.Delim(']')") + fmt.Fprintln(g.out, ws+"}") + } + + case reflect.Struct: + dec := g.getDecoderName(t) + g.addType(t) + + fmt.Fprintln(g.out, ws+dec+"(in, &"+out+")") + + case reflect.Ptr: + fmt.Fprintln(g.out, ws+"if in.IsNull() {") + fmt.Fprintln(g.out, ws+" in.Skip()") + fmt.Fprintln(g.out, ws+" "+out+" = nil") + fmt.Fprintln(g.out, ws+"} else {") + fmt.Fprintln(g.out, ws+" if "+out+" == nil {") + fmt.Fprintln(g.out, ws+" "+out+" = new("+g.getType(t.Elem())+")") + fmt.Fprintln(g.out, ws+" }") + + if err := g.genTypeDecoder(t.Elem(), "*"+out, tags, indent+1); err != nil { + return err + } + + fmt.Fprintln(g.out, ws+"}") + + case reflect.Map: + key := t.Key() + keyDec, ok := primitiveStringDecoders[key.Kind()] + if !ok { + return fmt.Errorf("map type %v not supported: only string and integer keys are allowed", key) + } + elem := t.Elem() + tmpVar := g.uniqueVarName() + + fmt.Fprintln(g.out, ws+"if in.IsNull() {") + fmt.Fprintln(g.out, ws+" in.Skip()") + fmt.Fprintln(g.out, ws+"} else {") + fmt.Fprintln(g.out, ws+" in.Delim('{')") + fmt.Fprintln(g.out, ws+" if !in.IsDelim('}') {") + fmt.Fprintln(g.out, ws+" "+out+" = make("+g.getType(t)+")") + fmt.Fprintln(g.out, ws+" } else {") + fmt.Fprintln(g.out, ws+" "+out+" = nil") + fmt.Fprintln(g.out, ws+" }") + + fmt.Fprintln(g.out, ws+" for !in.IsDelim('}') {") + fmt.Fprintln(g.out, ws+" key := "+g.getType(key)+"("+keyDec+")") + fmt.Fprintln(g.out, ws+" in.WantColon()") + fmt.Fprintln(g.out, ws+" var "+tmpVar+" "+g.getType(elem)) + + if err := g.genTypeDecoder(elem, tmpVar, tags, indent+2); err != nil { + return err + } + + fmt.Fprintln(g.out, ws+" ("+out+")[key] = "+tmpVar) + fmt.Fprintln(g.out, ws+" in.WantComma()") + fmt.Fprintln(g.out, ws+" }") + fmt.Fprintln(g.out, ws+" in.Delim('}')") + fmt.Fprintln(g.out, ws+"}") + + case reflect.Interface: + if t.NumMethod() != 0 { + return fmt.Errorf("interface type %v not supported: only interface{} is allowed", t) + } + fmt.Fprintln(g.out, ws+"if m, ok := "+out+".(easyjson.Unmarshaler); ok {") + fmt.Fprintln(g.out, ws+"m.UnmarshalEasyJSON(in)") + fmt.Fprintln(g.out, ws+"} else if m, ok := "+out+".(json.Unmarshaler); ok {") + fmt.Fprintln(g.out, ws+"_ = m.UnmarshalJSON(in.Raw())") + fmt.Fprintln(g.out, ws+"} else {") + fmt.Fprintln(g.out, ws+" "+out+" = in.Interface()") + fmt.Fprintln(g.out, ws+"}") + default: + return fmt.Errorf("don't know how to decode %v", t) + } + return nil + +} + +func (g *Generator) genStructFieldDecoder(t reflect.Type, f reflect.StructField) error { + jsonName := g.fieldNamer.GetJSONFieldName(t, f) + tags := parseFieldTags(f) + + if tags.omit { + return nil + } + + fmt.Fprintf(g.out, " case %q:\n", jsonName) + if err := g.genTypeDecoder(f.Type, "out."+f.Name, tags, 3); err != nil { + return err + } + + if tags.required { + fmt.Fprintf(g.out, "%sSet = true\n", f.Name) + } + + return nil +} + +func (g *Generator) genRequiredFieldSet(t reflect.Type, f reflect.StructField) { + tags := parseFieldTags(f) + + if !tags.required { + return + } + + fmt.Fprintf(g.out, "var %sSet bool\n", f.Name) +} + +func (g *Generator) genRequiredFieldCheck(t reflect.Type, f reflect.StructField) { + jsonName := g.fieldNamer.GetJSONFieldName(t, f) + tags := parseFieldTags(f) + + if !tags.required { + return + } + + g.imports["fmt"] = "fmt" + + fmt.Fprintf(g.out, "if !%sSet {\n", f.Name) + fmt.Fprintf(g.out, " in.AddError(fmt.Errorf(\"key '%s' is required\"))\n", jsonName) + fmt.Fprintf(g.out, "}\n") +} + +func mergeStructFields(fields1, fields2 []reflect.StructField) (fields []reflect.StructField) { + used := map[string]bool{} + for _, f := range fields2 { + used[f.Name] = true + fields = append(fields, f) + } + + for _, f := range fields1 { + if !used[f.Name] { + fields = append(fields, f) + } + } + return +} + +func getStructFields(t reflect.Type) ([]reflect.StructField, error) { + if t.Kind() != reflect.Struct { + return nil, fmt.Errorf("got %v; expected a struct", t) + } + + var efields []reflect.StructField + for i := 0; i < t.NumField(); i++ { + f := t.Field(i) + if !f.Anonymous { + continue + } + + t1 := f.Type + if t1.Kind() == reflect.Ptr { + t1 = t1.Elem() + } + + fs, err := getStructFields(t1) + if err != nil { + return nil, fmt.Errorf("error processing embedded field: %v", err) + } + efields = mergeStructFields(efields, fs) + } + + var fields []reflect.StructField + for i := 0; i < t.NumField(); i++ { + f := t.Field(i) + if f.Anonymous { + continue + } + + c := []rune(f.Name)[0] + if unicode.IsUpper(c) { + fields = append(fields, f) + } + } + return mergeStructFields(efields, fields), nil +} + +func (g *Generator) genDecoder(t reflect.Type) error { + switch t.Kind() { + case reflect.Slice, reflect.Array, reflect.Map: + return g.genSliceArrayDecoder(t) + default: + return g.genStructDecoder(t) + } +} + +func (g *Generator) genSliceArrayDecoder(t reflect.Type) error { + switch t.Kind() { + case reflect.Slice, reflect.Array, reflect.Map: + default: + return fmt.Errorf("cannot generate encoder/decoder for %v, not a slice/array/map type", t) + } + + fname := g.getDecoderName(t) + typ := g.getType(t) + + fmt.Fprintln(g.out, "func "+fname+"(in *jlexer.Lexer, out *"+typ+") {") + fmt.Fprintln(g.out, " isTopLevel := in.IsStart()") + err := g.genTypeDecoderNoCheck(t, "*out", fieldTags{}, 1) + if err != nil { + return err + } + fmt.Fprintln(g.out, " if isTopLevel {") + fmt.Fprintln(g.out, " in.Consumed()") + fmt.Fprintln(g.out, " }") + fmt.Fprintln(g.out, "}") + + return nil +} + +func (g *Generator) genStructDecoder(t reflect.Type) error { + if t.Kind() != reflect.Struct { + return fmt.Errorf("cannot generate encoder/decoder for %v, not a struct type", t) + } + + fname := g.getDecoderName(t) + typ := g.getType(t) + + fmt.Fprintln(g.out, "func "+fname+"(in *jlexer.Lexer, out *"+typ+") {") + fmt.Fprintln(g.out, " isTopLevel := in.IsStart()") + fmt.Fprintln(g.out, " if in.IsNull() {") + fmt.Fprintln(g.out, " if isTopLevel {") + fmt.Fprintln(g.out, " in.Consumed()") + fmt.Fprintln(g.out, " }") + fmt.Fprintln(g.out, " in.Skip()") + fmt.Fprintln(g.out, " return") + fmt.Fprintln(g.out, " }") + + // Init embedded pointer fields. + for i := 0; i < t.NumField(); i++ { + f := t.Field(i) + if !f.Anonymous || f.Type.Kind() != reflect.Ptr { + continue + } + fmt.Fprintln(g.out, " out."+f.Name+" = new("+g.getType(f.Type.Elem())+")") + } + + fs, err := getStructFields(t) + if err != nil { + return fmt.Errorf("cannot generate decoder for %v: %v", t, err) + } + + for _, f := range fs { + g.genRequiredFieldSet(t, f) + } + + fmt.Fprintln(g.out, " in.Delim('{')") + fmt.Fprintln(g.out, " for !in.IsDelim('}') {") + fmt.Fprintln(g.out, " key := in.UnsafeString()") + fmt.Fprintln(g.out, " in.WantColon()") + fmt.Fprintln(g.out, " if in.IsNull() {") + fmt.Fprintln(g.out, " in.Skip()") + fmt.Fprintln(g.out, " in.WantComma()") + fmt.Fprintln(g.out, " continue") + fmt.Fprintln(g.out, " }") + + fmt.Fprintln(g.out, " switch key {") + for _, f := range fs { + if err := g.genStructFieldDecoder(t, f); err != nil { + return err + } + } + + fmt.Fprintln(g.out, " default:") + fmt.Fprintln(g.out, " in.SkipRecursive()") + fmt.Fprintln(g.out, " }") + fmt.Fprintln(g.out, " in.WantComma()") + fmt.Fprintln(g.out, " }") + fmt.Fprintln(g.out, " in.Delim('}')") + fmt.Fprintln(g.out, " if isTopLevel {") + fmt.Fprintln(g.out, " in.Consumed()") + fmt.Fprintln(g.out, " }") + + for _, f := range fs { + g.genRequiredFieldCheck(t, f) + } + + fmt.Fprintln(g.out, "}") + + return nil +} + +func (g *Generator) genStructUnmarshaler(t reflect.Type) error { + switch t.Kind() { + case reflect.Slice, reflect.Array, reflect.Map, reflect.Struct: + default: + return fmt.Errorf("cannot generate encoder/decoder for %v, not a struct/slice/array/map type", t) + } + + fname := g.getDecoderName(t) + typ := g.getType(t) + + if !g.noStdMarshalers { + fmt.Fprintln(g.out, "// UnmarshalJSON supports json.Unmarshaler interface") + fmt.Fprintln(g.out, "func (v *"+typ+") UnmarshalJSON(data []byte) error {") + fmt.Fprintln(g.out, " r := jlexer.Lexer{Data: data}") + fmt.Fprintln(g.out, " "+fname+"(&r, v)") + fmt.Fprintln(g.out, " return r.Error()") + fmt.Fprintln(g.out, "}") + } + + fmt.Fprintln(g.out, "// UnmarshalEasyJSON supports easyjson.Unmarshaler interface") + fmt.Fprintln(g.out, "func (v *"+typ+") UnmarshalEasyJSON(l *jlexer.Lexer) {") + fmt.Fprintln(g.out, " "+fname+"(l, v)") + fmt.Fprintln(g.out, "}") + + return nil +} diff --git a/vendor/github.com/mailru/easyjson/gen/encoder.go b/vendor/github.com/mailru/easyjson/gen/encoder.go new file mode 100644 index 000000000..48cba15d4 --- /dev/null +++ b/vendor/github.com/mailru/easyjson/gen/encoder.go @@ -0,0 +1,382 @@ +package gen + +import ( + "encoding" + "encoding/json" + "fmt" + "reflect" + "strconv" + "strings" + + "github.com/mailru/easyjson" +) + +func (g *Generator) getEncoderName(t reflect.Type) string { + return g.functionName("encode", t) +} + +var primitiveEncoders = map[reflect.Kind]string{ + reflect.String: "out.String(string(%v))", + reflect.Bool: "out.Bool(bool(%v))", + reflect.Int: "out.Int(int(%v))", + reflect.Int8: "out.Int8(int8(%v))", + reflect.Int16: "out.Int16(int16(%v))", + reflect.Int32: "out.Int32(int32(%v))", + reflect.Int64: "out.Int64(int64(%v))", + reflect.Uint: "out.Uint(uint(%v))", + reflect.Uint8: "out.Uint8(uint8(%v))", + reflect.Uint16: "out.Uint16(uint16(%v))", + reflect.Uint32: "out.Uint32(uint32(%v))", + reflect.Uint64: "out.Uint64(uint64(%v))", + reflect.Float32: "out.Float32(float32(%v))", + reflect.Float64: "out.Float64(float64(%v))", +} + +var primitiveStringEncoders = map[reflect.Kind]string{ + reflect.String: "out.String(string(%v))", + reflect.Int: "out.IntStr(int(%v))", + reflect.Int8: "out.Int8Str(int8(%v))", + reflect.Int16: "out.Int16Str(int16(%v))", + reflect.Int32: "out.Int32Str(int32(%v))", + reflect.Int64: "out.Int64Str(int64(%v))", + reflect.Uint: "out.UintStr(uint(%v))", + reflect.Uint8: "out.Uint8Str(uint8(%v))", + reflect.Uint16: "out.Uint16Str(uint16(%v))", + reflect.Uint32: "out.Uint32Str(uint32(%v))", + reflect.Uint64: "out.Uint64Str(uint64(%v))", + reflect.Uintptr: "out.UintptrStr(uintptr(%v))", +} + +// fieldTags contains parsed version of json struct field tags. +type fieldTags struct { + name string + + omit bool + omitEmpty bool + noOmitEmpty bool + asString bool + required bool +} + +// parseFieldTags parses the json field tag into a structure. +func parseFieldTags(f reflect.StructField) fieldTags { + var ret fieldTags + + for i, s := range strings.Split(f.Tag.Get("json"), ",") { + switch { + case i == 0 && s == "-": + ret.omit = true + case i == 0: + ret.name = s + case s == "omitempty": + ret.omitEmpty = true + case s == "!omitempty": + ret.noOmitEmpty = true + case s == "string": + ret.asString = true + case s == "required": + ret.required = true + } + } + + return ret +} + +// genTypeEncoder generates code that encodes in of type t into the writer, but uses marshaler interface if implemented by t. +func (g *Generator) genTypeEncoder(t reflect.Type, in string, tags fieldTags, indent int, assumeNonEmpty bool) error { + ws := strings.Repeat(" ", indent) + + marshalerIface := reflect.TypeOf((*easyjson.Marshaler)(nil)).Elem() + if reflect.PtrTo(t).Implements(marshalerIface) { + fmt.Fprintln(g.out, ws+"("+in+").MarshalEasyJSON(out)") + return nil + } + + marshalerIface = reflect.TypeOf((*json.Marshaler)(nil)).Elem() + if reflect.PtrTo(t).Implements(marshalerIface) { + fmt.Fprintln(g.out, ws+"out.Raw( ("+in+").MarshalJSON() )") + return nil + } + + marshalerIface = reflect.TypeOf((*encoding.TextMarshaler)(nil)).Elem() + if reflect.PtrTo(t).Implements(marshalerIface) { + fmt.Fprintln(g.out, ws+"out.RawText( ("+in+").MarshalText() )") + return nil + } + + err := g.genTypeEncoderNoCheck(t, in, tags, indent, assumeNonEmpty) + return err +} + +// genTypeEncoderNoCheck generates code that encodes in of type t into the writer. +func (g *Generator) genTypeEncoderNoCheck(t reflect.Type, in string, tags fieldTags, indent int, assumeNonEmpty bool) error { + ws := strings.Repeat(" ", indent) + + // Check whether type is primitive, needs to be done after interface check. + if enc := primitiveStringEncoders[t.Kind()]; enc != "" && tags.asString { + fmt.Fprintf(g.out, ws+enc+"\n", in) + return nil + } else if enc := primitiveEncoders[t.Kind()]; enc != "" { + fmt.Fprintf(g.out, ws+enc+"\n", in) + return nil + } + + switch t.Kind() { + case reflect.Slice: + elem := t.Elem() + iVar := g.uniqueVarName() + vVar := g.uniqueVarName() + + if t.Elem().Kind() == reflect.Uint8 { + fmt.Fprintln(g.out, ws+"out.Base64Bytes("+in+")") + } else { + if !assumeNonEmpty { + fmt.Fprintln(g.out, ws+"if "+in+" == nil && (out.Flags & jwriter.NilSliceAsEmpty) == 0 {") + fmt.Fprintln(g.out, ws+` out.RawString("null")`) + fmt.Fprintln(g.out, ws+"} else {") + } else { + fmt.Fprintln(g.out, ws+"{") + } + fmt.Fprintln(g.out, ws+" out.RawByte('[')") + fmt.Fprintln(g.out, ws+" for "+iVar+", "+vVar+" := range "+in+" {") + fmt.Fprintln(g.out, ws+" if "+iVar+" > 0 {") + fmt.Fprintln(g.out, ws+" out.RawByte(',')") + fmt.Fprintln(g.out, ws+" }") + + if err := g.genTypeEncoder(elem, vVar, tags, indent+2, false); err != nil { + return err + } + + fmt.Fprintln(g.out, ws+" }") + fmt.Fprintln(g.out, ws+" out.RawByte(']')") + fmt.Fprintln(g.out, ws+"}") + } + + case reflect.Array: + elem := t.Elem() + iVar := g.uniqueVarName() + + if t.Elem().Kind() == reflect.Uint8 { + fmt.Fprintln(g.out, ws+"out.Base64Bytes("+in+"[:])") + } else { + fmt.Fprintln(g.out, ws+"out.RawByte('[')") + fmt.Fprintln(g.out, ws+"for "+iVar+" := range "+in+" {") + fmt.Fprintln(g.out, ws+" if "+iVar+" > 0 {") + fmt.Fprintln(g.out, ws+" out.RawByte(',')") + fmt.Fprintln(g.out, ws+" }") + + if err := g.genTypeEncoder(elem, in+"["+iVar+"]", tags, indent+1, false); err != nil { + return err + } + + fmt.Fprintln(g.out, ws+"}") + fmt.Fprintln(g.out, ws+"out.RawByte(']')") + } + + case reflect.Struct: + enc := g.getEncoderName(t) + g.addType(t) + + fmt.Fprintln(g.out, ws+enc+"(out, "+in+")") + + case reflect.Ptr: + if !assumeNonEmpty { + fmt.Fprintln(g.out, ws+"if "+in+" == nil {") + fmt.Fprintln(g.out, ws+` out.RawString("null")`) + fmt.Fprintln(g.out, ws+"} else {") + } + + if err := g.genTypeEncoder(t.Elem(), "*"+in, tags, indent+1, false); err != nil { + return err + } + + if !assumeNonEmpty { + fmt.Fprintln(g.out, ws+"}") + } + + case reflect.Map: + key := t.Key() + keyEnc, ok := primitiveStringEncoders[key.Kind()] + if !ok { + return fmt.Errorf("map key type %v not supported: only string and integer keys are allowed", key) + } + tmpVar := g.uniqueVarName() + + if !assumeNonEmpty { + fmt.Fprintln(g.out, ws+"if "+in+" == nil && (out.Flags & jwriter.NilMapAsEmpty) == 0 {") + fmt.Fprintln(g.out, ws+" out.RawString(`null`)") + fmt.Fprintln(g.out, ws+"} else {") + } else { + fmt.Fprintln(g.out, ws+"{") + } + fmt.Fprintln(g.out, ws+" out.RawByte('{')") + fmt.Fprintln(g.out, ws+" "+tmpVar+"First := true") + fmt.Fprintln(g.out, ws+" for "+tmpVar+"Name, "+tmpVar+"Value := range "+in+" {") + fmt.Fprintln(g.out, ws+" if "+tmpVar+"First { "+tmpVar+"First = false } else { out.RawByte(',') }") + fmt.Fprintln(g.out, ws+" "+fmt.Sprintf(keyEnc, tmpVar+"Name")) + fmt.Fprintln(g.out, ws+" out.RawByte(':')") + + if err := g.genTypeEncoder(t.Elem(), tmpVar+"Value", tags, indent+2, false); err != nil { + return err + } + + fmt.Fprintln(g.out, ws+" }") + fmt.Fprintln(g.out, ws+" out.RawByte('}')") + fmt.Fprintln(g.out, ws+"}") + + case reflect.Interface: + if t.NumMethod() != 0 { + return fmt.Errorf("interface type %v not supported: only interface{} is allowed", t) + } + fmt.Fprintln(g.out, ws+"if m, ok := "+in+".(easyjson.Marshaler); ok {") + fmt.Fprintln(g.out, ws+" m.MarshalEasyJSON(out)") + fmt.Fprintln(g.out, ws+"} else if m, ok := "+in+".(json.Marshaler); ok {") + fmt.Fprintln(g.out, ws+" out.Raw(m.MarshalJSON())") + fmt.Fprintln(g.out, ws+"} else {") + fmt.Fprintln(g.out, ws+" out.Raw(json.Marshal("+in+"))") + fmt.Fprintln(g.out, ws+"}") + + default: + return fmt.Errorf("don't know how to encode %v", t) + } + return nil +} + +func (g *Generator) notEmptyCheck(t reflect.Type, v string) string { + optionalIface := reflect.TypeOf((*easyjson.Optional)(nil)).Elem() + if reflect.PtrTo(t).Implements(optionalIface) { + return "(" + v + ").IsDefined()" + } + + switch t.Kind() { + case reflect.Slice, reflect.Map: + return "len(" + v + ") != 0" + case reflect.Interface, reflect.Ptr: + return v + " != nil" + case reflect.Bool: + return v + case reflect.String: + return v + ` != ""` + case reflect.Float32, reflect.Float64, + reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, + reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64: + + return v + " != 0" + + default: + // note: Array types don't have a useful empty value + return "true" + } +} + +func (g *Generator) genStructFieldEncoder(t reflect.Type, f reflect.StructField) error { + jsonName := g.fieldNamer.GetJSONFieldName(t, f) + tags := parseFieldTags(f) + + if tags.omit { + return nil + } + noOmitEmpty := (!tags.omitEmpty && !g.omitEmpty) || tags.noOmitEmpty + if noOmitEmpty { + fmt.Fprintln(g.out, " {") + } else { + fmt.Fprintln(g.out, " if", g.notEmptyCheck(f.Type, "in."+f.Name), "{") + } + fmt.Fprintf(g.out, " const prefix string = %q\n", ","+strconv.Quote(jsonName)+":") + fmt.Fprintln(g.out, " if first {") + fmt.Fprintln(g.out, " first = false") + fmt.Fprintln(g.out, " out.RawString(prefix[1:])") + fmt.Fprintln(g.out, " } else {") + fmt.Fprintln(g.out, " out.RawString(prefix)") + fmt.Fprintln(g.out, " }") + + if err := g.genTypeEncoder(f.Type, "in."+f.Name, tags, 2, !noOmitEmpty); err != nil { + return err + } + fmt.Fprintln(g.out, " }") + return nil +} + +func (g *Generator) genEncoder(t reflect.Type) error { + switch t.Kind() { + case reflect.Slice, reflect.Array, reflect.Map: + return g.genSliceArrayMapEncoder(t) + default: + return g.genStructEncoder(t) + } +} + +func (g *Generator) genSliceArrayMapEncoder(t reflect.Type) error { + switch t.Kind() { + case reflect.Slice, reflect.Array, reflect.Map: + default: + return fmt.Errorf("cannot generate encoder/decoder for %v, not a slice/array/map type", t) + } + + fname := g.getEncoderName(t) + typ := g.getType(t) + + fmt.Fprintln(g.out, "func "+fname+"(out *jwriter.Writer, in "+typ+") {") + err := g.genTypeEncoderNoCheck(t, "in", fieldTags{}, 1, false) + if err != nil { + return err + } + fmt.Fprintln(g.out, "}") + return nil +} + +func (g *Generator) genStructEncoder(t reflect.Type) error { + if t.Kind() != reflect.Struct { + return fmt.Errorf("cannot generate encoder/decoder for %v, not a struct type", t) + } + + fname := g.getEncoderName(t) + typ := g.getType(t) + + fmt.Fprintln(g.out, "func "+fname+"(out *jwriter.Writer, in "+typ+") {") + fmt.Fprintln(g.out, " out.RawByte('{')") + fmt.Fprintln(g.out, " first := true") + fmt.Fprintln(g.out, " _ = first") + + fs, err := getStructFields(t) + if err != nil { + return fmt.Errorf("cannot generate encoder for %v: %v", t, err) + } + for _, f := range fs { + if err := g.genStructFieldEncoder(t, f); err != nil { + return err + } + } + + fmt.Fprintln(g.out, " out.RawByte('}')") + fmt.Fprintln(g.out, "}") + + return nil +} + +func (g *Generator) genStructMarshaler(t reflect.Type) error { + switch t.Kind() { + case reflect.Slice, reflect.Array, reflect.Map, reflect.Struct: + default: + return fmt.Errorf("cannot generate encoder/decoder for %v, not a struct/slice/array/map type", t) + } + + fname := g.getEncoderName(t) + typ := g.getType(t) + + if !g.noStdMarshalers { + fmt.Fprintln(g.out, "// MarshalJSON supports json.Marshaler interface") + fmt.Fprintln(g.out, "func (v "+typ+") MarshalJSON() ([]byte, error) {") + fmt.Fprintln(g.out, " w := jwriter.Writer{}") + fmt.Fprintln(g.out, " "+fname+"(&w, v)") + fmt.Fprintln(g.out, " return w.Buffer.BuildBytes(), w.Error") + fmt.Fprintln(g.out, "}") + } + + fmt.Fprintln(g.out, "// MarshalEasyJSON supports easyjson.Marshaler interface") + fmt.Fprintln(g.out, "func (v "+typ+") MarshalEasyJSON(w *jwriter.Writer) {") + fmt.Fprintln(g.out, " "+fname+"(w, v)") + fmt.Fprintln(g.out, "}") + + return nil +} diff --git a/vendor/github.com/mailru/easyjson/gen/generator.go b/vendor/github.com/mailru/easyjson/gen/generator.go new file mode 100644 index 000000000..eb0d70ba2 --- /dev/null +++ b/vendor/github.com/mailru/easyjson/gen/generator.go @@ -0,0 +1,523 @@ +package gen + +import ( + "bytes" + "fmt" + "hash/fnv" + "io" + "path" + "reflect" + "sort" + "strconv" + "strings" + "unicode" +) + +const pkgWriter = "github.com/mailru/easyjson/jwriter" +const pkgLexer = "github.com/mailru/easyjson/jlexer" +const pkgEasyJSON = "github.com/mailru/easyjson" + +// FieldNamer defines a policy for generating names for struct fields. +type FieldNamer interface { + GetJSONFieldName(t reflect.Type, f reflect.StructField) string +} + +// Generator generates the requested marshaler/unmarshalers. +type Generator struct { + out *bytes.Buffer + + pkgName string + pkgPath string + buildTags string + hashString string + + varCounter int + + noStdMarshalers bool + omitEmpty bool + fieldNamer FieldNamer + + // package path to local alias map for tracking imports + imports map[string]string + + // types that marshalers were requested for by user + marshalers map[reflect.Type]bool + + // types that encoders were already generated for + typesSeen map[reflect.Type]bool + + // types that encoders were requested for (e.g. by encoders of other types) + typesUnseen []reflect.Type + + // function name to relevant type maps to track names of de-/encoders in + // case of a name clash or unnamed structs + functionNames map[string]reflect.Type +} + +// NewGenerator initializes and returns a Generator. +func NewGenerator(filename string) *Generator { + ret := &Generator{ + imports: map[string]string{ + pkgWriter: "jwriter", + pkgLexer: "jlexer", + pkgEasyJSON: "easyjson", + "encoding/json": "json", + }, + fieldNamer: DefaultFieldNamer{}, + marshalers: make(map[reflect.Type]bool), + typesSeen: make(map[reflect.Type]bool), + functionNames: make(map[string]reflect.Type), + } + + // Use a file-unique prefix on all auxiliary funcs to avoid + // name clashes. + hash := fnv.New32() + hash.Write([]byte(filename)) + ret.hashString = fmt.Sprintf("%x", hash.Sum32()) + + return ret +} + +// SetPkg sets the name and path of output package. +func (g *Generator) SetPkg(name, path string) { + g.pkgName = name + g.pkgPath = path +} + +// SetBuildTags sets build tags for the output file. +func (g *Generator) SetBuildTags(tags string) { + g.buildTags = tags +} + +// SetFieldNamer sets field naming strategy. +func (g *Generator) SetFieldNamer(n FieldNamer) { + g.fieldNamer = n +} + +// UseSnakeCase sets snake_case field naming strategy. +func (g *Generator) UseSnakeCase() { + g.fieldNamer = SnakeCaseFieldNamer{} +} + +// UseLowerCamelCase sets lowerCamelCase field naming strategy. +func (g *Generator) UseLowerCamelCase() { + g.fieldNamer = LowerCamelCaseFieldNamer{} +} + +// NoStdMarshalers instructs not to generate standard MarshalJSON/UnmarshalJSON +// methods (only the custom interface). +func (g *Generator) NoStdMarshalers() { + g.noStdMarshalers = true +} + +// OmitEmpty triggers `json=",omitempty"` behaviour by default. +func (g *Generator) OmitEmpty() { + g.omitEmpty = true +} + +// addTypes requests to generate encoding/decoding funcs for the given type. +func (g *Generator) addType(t reflect.Type) { + if g.typesSeen[t] { + return + } + for _, t1 := range g.typesUnseen { + if t1 == t { + return + } + } + g.typesUnseen = append(g.typesUnseen, t) +} + +// Add requests to generate marshaler/unmarshalers and encoding/decoding +// funcs for the type of given object. +func (g *Generator) Add(obj interface{}) { + t := reflect.TypeOf(obj) + if t.Kind() == reflect.Ptr { + t = t.Elem() + } + g.addType(t) + g.marshalers[t] = true +} + +// printHeader prints package declaration and imports. +func (g *Generator) printHeader() { + if g.buildTags != "" { + fmt.Println("// +build ", g.buildTags) + fmt.Println() + } + fmt.Println("// Code generated by easyjson for marshaling/unmarshaling. DO NOT EDIT.") + fmt.Println() + fmt.Println("package ", g.pkgName) + fmt.Println() + + byAlias := map[string]string{} + var aliases []string + for path, alias := range g.imports { + aliases = append(aliases, alias) + byAlias[alias] = path + } + + sort.Strings(aliases) + fmt.Println("import (") + for _, alias := range aliases { + fmt.Printf(" %s %q\n", alias, byAlias[alias]) + } + + fmt.Println(")") + fmt.Println("") + fmt.Println("// suppress unused package warning") + fmt.Println("var (") + fmt.Println(" _ *json.RawMessage") + fmt.Println(" _ *jlexer.Lexer") + fmt.Println(" _ *jwriter.Writer") + fmt.Println(" _ easyjson.Marshaler") + fmt.Println(")") + + fmt.Println() +} + +// Run runs the generator and outputs generated code to out. +func (g *Generator) Run(out io.Writer) error { + g.out = &bytes.Buffer{} + + for len(g.typesUnseen) > 0 { + t := g.typesUnseen[len(g.typesUnseen)-1] + g.typesUnseen = g.typesUnseen[:len(g.typesUnseen)-1] + g.typesSeen[t] = true + + if err := g.genDecoder(t); err != nil { + return err + } + if err := g.genEncoder(t); err != nil { + return err + } + + if !g.marshalers[t] { + continue + } + + if err := g.genStructMarshaler(t); err != nil { + return err + } + if err := g.genStructUnmarshaler(t); err != nil { + return err + } + } + g.printHeader() + _, err := out.Write(g.out.Bytes()) + return err +} + +// fixes vendored paths +func fixPkgPathVendoring(pkgPath string) string { + const vendor = "/vendor/" + if i := strings.LastIndex(pkgPath, vendor); i != -1 { + return pkgPath[i+len(vendor):] + } + return pkgPath +} + +func fixAliasName(alias string) string { + alias = strings.Replace( + strings.Replace(alias, ".", "_", -1), + "-", + "_", + -1, + ) + + if alias[0] == 'v' { // to void conflicting with var names, say v1 + alias = "_" + alias + } + return alias +} + +// pkgAlias creates and returns and import alias for a given package. +func (g *Generator) pkgAlias(pkgPath string) string { + pkgPath = fixPkgPathVendoring(pkgPath) + if alias := g.imports[pkgPath]; alias != "" { + return alias + } + + for i := 0; ; i++ { + alias := fixAliasName(path.Base(pkgPath)) + if i > 0 { + alias += fmt.Sprint(i) + } + + exists := false + for _, v := range g.imports { + if v == alias { + exists = true + break + } + } + + if !exists { + g.imports[pkgPath] = alias + return alias + } + } +} + +// getType return the textual type name of given type that can be used in generated code. +func (g *Generator) getType(t reflect.Type) string { + if t.Name() == "" { + switch t.Kind() { + case reflect.Ptr: + return "*" + g.getType(t.Elem()) + case reflect.Slice: + return "[]" + g.getType(t.Elem()) + case reflect.Array: + return "[" + strconv.Itoa(t.Len()) + "]" + g.getType(t.Elem()) + case reflect.Map: + return "map[" + g.getType(t.Key()) + "]" + g.getType(t.Elem()) + } + } + + if t.Name() == "" || t.PkgPath() == "" { + if t.Kind() == reflect.Struct { + // the fields of an anonymous struct can have named types, + // and t.String() will not be sufficient because it does not + // remove the package name when it matches g.pkgPath. + // so we convert by hand + nf := t.NumField() + lines := make([]string, 0, nf) + for i := 0; i < nf; i++ { + f := t.Field(i) + line := f.Name + " " + g.getType(f.Type) + t := f.Tag + if t != "" { + line += " " + escapeTag(t) + } + lines = append(lines, line) + } + return strings.Join([]string{"struct { ", strings.Join(lines, "; "), " }"}, "") + } + return t.String() + } else if t.PkgPath() == g.pkgPath { + return t.Name() + } + return g.pkgAlias(t.PkgPath()) + "." + t.Name() +} + +// escape a struct field tag string back to source code +func escapeTag(tag reflect.StructTag) string { + t := string(tag) + if strings.ContainsRune(t, '`') { + // there are ` in the string; we can't use ` to enclose the string + return strconv.Quote(t) + } + return "`" + t + "`" +} + +// uniqueVarName returns a file-unique name that can be used for generated variables. +func (g *Generator) uniqueVarName() string { + g.varCounter++ + return fmt.Sprint("v", g.varCounter) +} + +// safeName escapes unsafe characters in pkg/type name and returns a string that can be used +// in encoder/decoder names for the type. +func (g *Generator) safeName(t reflect.Type) string { + name := t.PkgPath() + if t.Name() == "" { + name += "anonymous" + } else { + name += "." + t.Name() + } + + parts := []string{} + part := []rune{} + for _, c := range name { + if unicode.IsLetter(c) || unicode.IsDigit(c) { + part = append(part, c) + } else if len(part) > 0 { + parts = append(parts, string(part)) + part = []rune{} + } + } + return joinFunctionNameParts(false, parts...) +} + +// functionName returns a function name for a given type with a given prefix. If a function +// with this prefix already exists for a type, it is returned. +// +// Method is used to track encoder/decoder names for the type. +func (g *Generator) functionName(prefix string, t reflect.Type) string { + prefix = joinFunctionNameParts(true, "easyjson", g.hashString, prefix) + name := joinFunctionNameParts(true, prefix, g.safeName(t)) + + // Most of the names will be unique, try a shortcut first. + if e, ok := g.functionNames[name]; !ok || e == t { + g.functionNames[name] = t + return name + } + + // Search if the function already exists. + for name1, t1 := range g.functionNames { + if t1 == t && strings.HasPrefix(name1, prefix) { + return name1 + } + } + + // Create a new name in the case of a clash. + for i := 1; ; i++ { + nm := fmt.Sprint(name, i) + if _, ok := g.functionNames[nm]; ok { + continue + } + g.functionNames[nm] = t + return nm + } +} + +// DefaultFieldsNamer implements trivial naming policy equivalent to encoding/json. +type DefaultFieldNamer struct{} + +func (DefaultFieldNamer) GetJSONFieldName(t reflect.Type, f reflect.StructField) string { + jsonName := strings.Split(f.Tag.Get("json"), ",")[0] + if jsonName != "" { + return jsonName + } else { + return f.Name + } +} + +// LowerCamelCaseFieldNamer +type LowerCamelCaseFieldNamer struct{} + +func isLower(b byte) bool { + return b <= 122 && b >= 97 +} + +func isUpper(b byte) bool { + return b >= 65 && b <= 90 +} + +// convert HTTPRestClient to httpRestClient +func lowerFirst(s string) string { + if s == "" { + return "" + } + + str := "" + strlen := len(s) + + /** + Loop each char + If is uppercase: + If is first char, LOWER it + If the following char is lower, LEAVE it + If the following char is upper OR numeric, LOWER it + If is the end of string, LEAVE it + Else lowercase + */ + + foundLower := false + for i := range s { + ch := s[i] + if isUpper(ch) { + if i == 0 { + str += string(ch + 32) + } else if !foundLower { // Currently just a stream of capitals, eg JSONRESTS[erver] + if strlen > (i+1) && isLower(s[i+1]) { + // Next char is lower, keep this a capital + str += string(ch) + } else { + // Either at end of string or next char is capital + str += string(ch + 32) + } + } else { + str += string(ch) + } + } else { + foundLower = true + str += string(ch) + } + } + + return str +} + +func (LowerCamelCaseFieldNamer) GetJSONFieldName(t reflect.Type, f reflect.StructField) string { + jsonName := strings.Split(f.Tag.Get("json"), ",")[0] + if jsonName != "" { + return jsonName + } else { + return lowerFirst(f.Name) + } +} + +// SnakeCaseFieldNamer implements CamelCase to snake_case conversion for fields names. +type SnakeCaseFieldNamer struct{} + +func camelToSnake(name string) string { + var ret bytes.Buffer + + multipleUpper := false + var lastUpper rune + var beforeUpper rune + + for _, c := range name { + // Non-lowercase character after uppercase is considered to be uppercase too. + isUpper := (unicode.IsUpper(c) || (lastUpper != 0 && !unicode.IsLower(c))) + + if lastUpper != 0 { + // Output a delimiter if last character was either the first uppercase character + // in a row, or the last one in a row (e.g. 'S' in "HTTPServer"). + // Do not output a delimiter at the beginning of the name. + + firstInRow := !multipleUpper + lastInRow := !isUpper + + if ret.Len() > 0 && (firstInRow || lastInRow) && beforeUpper != '_' { + ret.WriteByte('_') + } + ret.WriteRune(unicode.ToLower(lastUpper)) + } + + // Buffer uppercase char, do not output it yet as a delimiter may be required if the + // next character is lowercase. + if isUpper { + multipleUpper = (lastUpper != 0) + lastUpper = c + continue + } + + ret.WriteRune(c) + lastUpper = 0 + beforeUpper = c + multipleUpper = false + } + + if lastUpper != 0 { + ret.WriteRune(unicode.ToLower(lastUpper)) + } + return string(ret.Bytes()) +} + +func (SnakeCaseFieldNamer) GetJSONFieldName(t reflect.Type, f reflect.StructField) string { + jsonName := strings.Split(f.Tag.Get("json"), ",")[0] + if jsonName != "" { + return jsonName + } + + return camelToSnake(f.Name) +} + +func joinFunctionNameParts(keepFirst bool, parts ...string) string { + buf := bytes.NewBufferString("") + for i, part := range parts { + if i == 0 && keepFirst { + buf.WriteString(part) + } else { + if len(part) > 0 { + buf.WriteString(strings.ToUpper(string(part[0]))) + } + if len(part) > 1 { + buf.WriteString(part[1:]) + } + } + } + return buf.String() +} diff --git a/vendor/github.com/mailru/easyjson/gen/generator_test.go b/vendor/github.com/mailru/easyjson/gen/generator_test.go new file mode 100644 index 000000000..0c9d27845 --- /dev/null +++ b/vendor/github.com/mailru/easyjson/gen/generator_test.go @@ -0,0 +1,87 @@ +package gen + +import ( + "testing" +) + +func TestCamelToSnake(t *testing.T) { + for i, test := range []struct { + In, Out string + }{ + {"", ""}, + {"A", "a"}, + {"SimpleExample", "simple_example"}, + {"internalField", "internal_field"}, + + {"SomeHTTPStuff", "some_http_stuff"}, + {"WriteJSON", "write_json"}, + {"HTTP2Server", "http2_server"}, + {"Some_Mixed_Case", "some_mixed_case"}, + {"do_nothing", "do_nothing"}, + + {"JSONHTTPRPCServer", "jsonhttprpc_server"}, // nothing can be done here without a dictionary + } { + got := camelToSnake(test.In) + if got != test.Out { + t.Errorf("[%d] camelToSnake(%s) = %s; want %s", i, test.In, got, test.Out) + } + } +} + +func TestCamelToLowerCamel(t *testing.T) { + for i, test := range []struct { + In, Out string + }{ + {"", ""}, + {"A", "a"}, + {"SimpleExample", "simpleExample"}, + {"internalField", "internalField"}, + + {"SomeHTTPStuff", "someHTTPStuff"}, + {"WriteJSON", "writeJSON"}, + {"HTTP2Server", "http2Server"}, + + {"JSONHTTPRPCServer", "jsonhttprpcServer"}, // nothing can be done here without a dictionary + } { + got := lowerFirst(test.In) + if got != test.Out { + t.Errorf("[%d] lowerFirst(%s) = %s; want %s", i, test.In, got, test.Out) + } + } +} + +func TestJoinFunctionNameParts(t *testing.T) { + for i, test := range []struct { + keepFirst bool + parts []string + out string + }{ + {false, []string{}, ""}, + {false, []string{"a"}, "A"}, + {false, []string{"simple", "example"}, "SimpleExample"}, + {true, []string{"first", "example"}, "firstExample"}, + {false, []string{"some", "UPPER", "case"}, "SomeUPPERCase"}, + {false, []string{"number", "123"}, "Number123"}, + } { + got := joinFunctionNameParts(test.keepFirst, test.parts...) + if got != test.out { + t.Errorf("[%d] joinFunctionNameParts(%v) = %s; want %s", i, test.parts, got, test.out) + } + } +} + +func TestFixVendorPath(t *testing.T) { + for i, test := range []struct { + In, Out string + }{ + {"", ""}, + {"time", "time"}, + {"project/vendor/subpackage", "subpackage"}, + } { + got := fixPkgPathVendoring(test.In) + if got != test.Out { + t.Errorf("[%d] fixPkgPathVendoring(%s) = %s; want %s", i, test.In, got, test.Out) + } + } + +} diff --git a/vendor/github.com/mailru/easyjson/helpers.go b/vendor/github.com/mailru/easyjson/helpers.go new file mode 100644 index 000000000..b86b87d22 --- /dev/null +++ b/vendor/github.com/mailru/easyjson/helpers.go @@ -0,0 +1,78 @@ +// Package easyjson contains marshaler/unmarshaler interfaces and helper functions. +package easyjson + +import ( + "io" + "io/ioutil" + "net/http" + "strconv" + + "github.com/mailru/easyjson/jlexer" + "github.com/mailru/easyjson/jwriter" +) + +// Marshaler is an easyjson-compatible marshaler interface. +type Marshaler interface { + MarshalEasyJSON(w *jwriter.Writer) +} + +// Marshaler is an easyjson-compatible unmarshaler interface. +type Unmarshaler interface { + UnmarshalEasyJSON(w *jlexer.Lexer) +} + +// Optional defines an undefined-test method for a type to integrate with 'omitempty' logic. +type Optional interface { + IsDefined() bool +} + +// Marshal returns data as a single byte slice. Method is suboptimal as the data is likely to be copied +// from a chain of smaller chunks. +func Marshal(v Marshaler) ([]byte, error) { + w := jwriter.Writer{} + v.MarshalEasyJSON(&w) + return w.BuildBytes() +} + +// MarshalToWriter marshals the data to an io.Writer. +func MarshalToWriter(v Marshaler, w io.Writer) (written int, err error) { + jw := jwriter.Writer{} + v.MarshalEasyJSON(&jw) + return jw.DumpTo(w) +} + +// MarshalToHTTPResponseWriter sets Content-Length and Content-Type headers for the +// http.ResponseWriter, and send the data to the writer. started will be equal to +// false if an error occurred before any http.ResponseWriter methods were actually +// invoked (in this case a 500 reply is possible). +func MarshalToHTTPResponseWriter(v Marshaler, w http.ResponseWriter) (started bool, written int, err error) { + jw := jwriter.Writer{} + v.MarshalEasyJSON(&jw) + if jw.Error != nil { + return false, 0, jw.Error + } + w.Header().Set("Content-Type", "application/json") + w.Header().Set("Content-Length", strconv.Itoa(jw.Size())) + + started = true + written, err = jw.DumpTo(w) + return +} + +// Unmarshal decodes the JSON in data into the object. +func Unmarshal(data []byte, v Unmarshaler) error { + l := jlexer.Lexer{Data: data} + v.UnmarshalEasyJSON(&l) + return l.Error() +} + +// UnmarshalFromReader reads all the data in the reader and decodes as JSON into the object. +func UnmarshalFromReader(r io.Reader, v Unmarshaler) error { + data, err := ioutil.ReadAll(r) + if err != nil { + return err + } + l := jlexer.Lexer{Data: data} + v.UnmarshalEasyJSON(&l) + return l.Error() +} diff --git a/vendor/github.com/mailru/easyjson/jlexer/bytestostr.go b/vendor/github.com/mailru/easyjson/jlexer/bytestostr.go new file mode 100644 index 000000000..ff7b27c5b --- /dev/null +++ b/vendor/github.com/mailru/easyjson/jlexer/bytestostr.go @@ -0,0 +1,24 @@ +// This file will only be included to the build if neither +// easyjson_nounsafe nor appengine build tag is set. See README notes +// for more details. + +//+build !easyjson_nounsafe +//+build !appengine + +package jlexer + +import ( + "reflect" + "unsafe" +) + +// bytesToStr creates a string pointing at the slice to avoid copying. +// +// Warning: the string returned by the function should be used with care, as the whole input data +// chunk may be either blocked from being freed by GC because of a single string or the buffer.Data +// may be garbage-collected even when the string exists. +func bytesToStr(data []byte) string { + h := (*reflect.SliceHeader)(unsafe.Pointer(&data)) + shdr := reflect.StringHeader{Data: h.Data, Len: h.Len} + return *(*string)(unsafe.Pointer(&shdr)) +} diff --git a/vendor/github.com/mailru/easyjson/jlexer/bytestostr_nounsafe.go b/vendor/github.com/mailru/easyjson/jlexer/bytestostr_nounsafe.go new file mode 100644 index 000000000..864d1be67 --- /dev/null +++ b/vendor/github.com/mailru/easyjson/jlexer/bytestostr_nounsafe.go @@ -0,0 +1,13 @@ +// This file is included to the build if any of the buildtags below +// are defined. Refer to README notes for more details. + +//+build easyjson_nounsafe appengine + +package jlexer + +// bytesToStr creates a string normally from []byte +// +// Note that this method is roughly 1.5x slower than using the 'unsafe' method. +func bytesToStr(data []byte) string { + return string(data) +} diff --git a/vendor/github.com/mailru/easyjson/jlexer/error.go b/vendor/github.com/mailru/easyjson/jlexer/error.go new file mode 100644 index 000000000..e90ec40d0 --- /dev/null +++ b/vendor/github.com/mailru/easyjson/jlexer/error.go @@ -0,0 +1,15 @@ +package jlexer + +import "fmt" + +// LexerError implements the error interface and represents all possible errors that can be +// generated during parsing the JSON data. +type LexerError struct { + Reason string + Offset int + Data string +} + +func (l *LexerError) Error() string { + return fmt.Sprintf("parse error: %s near offset %d of '%s'", l.Reason, l.Offset, l.Data) +} diff --git a/vendor/github.com/mailru/easyjson/jlexer/lexer.go b/vendor/github.com/mailru/easyjson/jlexer/lexer.go new file mode 100644 index 000000000..e5558ae39 --- /dev/null +++ b/vendor/github.com/mailru/easyjson/jlexer/lexer.go @@ -0,0 +1,1141 @@ +// Package jlexer contains a JSON lexer implementation. +// +// It is expected that it is mostly used with generated parser code, so the interface is tuned +// for a parser that knows what kind of data is expected. +package jlexer + +import ( + "encoding/base64" + "encoding/json" + "errors" + "fmt" + "io" + "strconv" + "unicode" + "unicode/utf16" + "unicode/utf8" +) + +// tokenKind determines type of a token. +type tokenKind byte + +const ( + tokenUndef tokenKind = iota // No token. + tokenDelim // Delimiter: one of '{', '}', '[' or ']'. + tokenString // A string literal, e.g. "abc\u1234" + tokenNumber // Number literal, e.g. 1.5e5 + tokenBool // Boolean literal: true or false. + tokenNull // null keyword. +) + +// token describes a single token: type, position in the input and value. +type token struct { + kind tokenKind // Type of a token. + + boolValue bool // Value if a boolean literal token. + byteValue []byte // Raw value of a token. + delimValue byte +} + +// Lexer is a JSON lexer: it iterates over JSON tokens in a byte slice. +type Lexer struct { + Data []byte // Input data given to the lexer. + + start int // Start of the current token. + pos int // Current unscanned position in the input stream. + token token // Last scanned token, if token.kind != tokenUndef. + + firstElement bool // Whether current element is the first in array or an object. + wantSep byte // A comma or a colon character, which need to occur before a token. + + UseMultipleErrors bool // If we want to use multiple errors. + fatalError error // Fatal error occurred during lexing. It is usually a syntax error. + multipleErrors []*LexerError // Semantic errors occurred during lexing. Marshalling will be continued after finding this errors. +} + +// FetchToken scans the input for the next token. +func (r *Lexer) FetchToken() { + r.token.kind = tokenUndef + r.start = r.pos + + // Check if r.Data has r.pos element + // If it doesn't, it mean corrupted input data + if len(r.Data) < r.pos { + r.errParse("Unexpected end of data") + return + } + // Determine the type of a token by skipping whitespace and reading the + // first character. + for _, c := range r.Data[r.pos:] { + switch c { + case ':', ',': + if r.wantSep == c { + r.pos++ + r.start++ + r.wantSep = 0 + } else { + r.errSyntax() + } + + case ' ', '\t', '\r', '\n': + r.pos++ + r.start++ + + case '"': + if r.wantSep != 0 { + r.errSyntax() + } + + r.token.kind = tokenString + r.fetchString() + return + + case '{', '[': + if r.wantSep != 0 { + r.errSyntax() + } + r.firstElement = true + r.token.kind = tokenDelim + r.token.delimValue = r.Data[r.pos] + r.pos++ + return + + case '}', ']': + if !r.firstElement && (r.wantSep != ',') { + r.errSyntax() + } + r.wantSep = 0 + r.token.kind = tokenDelim + r.token.delimValue = r.Data[r.pos] + r.pos++ + return + + case '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '-': + if r.wantSep != 0 { + r.errSyntax() + } + r.token.kind = tokenNumber + r.fetchNumber() + return + + case 'n': + if r.wantSep != 0 { + r.errSyntax() + } + + r.token.kind = tokenNull + r.fetchNull() + return + + case 't': + if r.wantSep != 0 { + r.errSyntax() + } + + r.token.kind = tokenBool + r.token.boolValue = true + r.fetchTrue() + return + + case 'f': + if r.wantSep != 0 { + r.errSyntax() + } + + r.token.kind = tokenBool + r.token.boolValue = false + r.fetchFalse() + return + + default: + r.errSyntax() + return + } + } + r.fatalError = io.EOF + return +} + +// isTokenEnd returns true if the char can follow a non-delimiter token +func isTokenEnd(c byte) bool { + return c == ' ' || c == '\t' || c == '\r' || c == '\n' || c == '[' || c == ']' || c == '{' || c == '}' || c == ',' || c == ':' +} + +// fetchNull fetches and checks remaining bytes of null keyword. +func (r *Lexer) fetchNull() { + r.pos += 4 + if r.pos > len(r.Data) || + r.Data[r.pos-3] != 'u' || + r.Data[r.pos-2] != 'l' || + r.Data[r.pos-1] != 'l' || + (r.pos != len(r.Data) && !isTokenEnd(r.Data[r.pos])) { + + r.pos -= 4 + r.errSyntax() + } +} + +// fetchTrue fetches and checks remaining bytes of true keyword. +func (r *Lexer) fetchTrue() { + r.pos += 4 + if r.pos > len(r.Data) || + r.Data[r.pos-3] != 'r' || + r.Data[r.pos-2] != 'u' || + r.Data[r.pos-1] != 'e' || + (r.pos != len(r.Data) && !isTokenEnd(r.Data[r.pos])) { + + r.pos -= 4 + r.errSyntax() + } +} + +// fetchFalse fetches and checks remaining bytes of false keyword. +func (r *Lexer) fetchFalse() { + r.pos += 5 + if r.pos > len(r.Data) || + r.Data[r.pos-4] != 'a' || + r.Data[r.pos-3] != 'l' || + r.Data[r.pos-2] != 's' || + r.Data[r.pos-1] != 'e' || + (r.pos != len(r.Data) && !isTokenEnd(r.Data[r.pos])) { + + r.pos -= 5 + r.errSyntax() + } +} + +// fetchNumber scans a number literal token. +func (r *Lexer) fetchNumber() { + hasE := false + afterE := false + hasDot := false + + r.pos++ + for i, c := range r.Data[r.pos:] { + switch { + case c >= '0' && c <= '9': + afterE = false + case c == '.' && !hasDot: + hasDot = true + case (c == 'e' || c == 'E') && !hasE: + hasE = true + hasDot = true + afterE = true + case (c == '+' || c == '-') && afterE: + afterE = false + default: + r.pos += i + if !isTokenEnd(c) { + r.errSyntax() + } else { + r.token.byteValue = r.Data[r.start:r.pos] + } + return + } + } + + r.pos = len(r.Data) + r.token.byteValue = r.Data[r.start:] +} + +// findStringLen tries to scan into the string literal for ending quote char to determine required size. +// The size will be exact if no escapes are present and may be inexact if there are escaped chars. +func findStringLen(data []byte) (hasEscapes bool, length int) { + delta := 0 + + for i := 0; i < len(data); i++ { + switch data[i] { + case '\\': + i++ + delta++ + if i < len(data) && data[i] == 'u' { + delta++ + } + case '"': + return (delta > 0), (i - delta) + } + } + + return false, len(data) +} + +// getu4 decodes \uXXXX from the beginning of s, returning the hex value, +// or it returns -1. +func getu4(s []byte) rune { + if len(s) < 6 || s[0] != '\\' || s[1] != 'u' { + return -1 + } + var val rune + for i := 2; i < len(s) && i < 6; i++ { + var v byte + c := s[i] + switch c { + case '0', '1', '2', '3', '4', '5', '6', '7', '8', '9': + v = c - '0' + case 'a', 'b', 'c', 'd', 'e', 'f': + v = c - 'a' + 10 + case 'A', 'B', 'C', 'D', 'E', 'F': + v = c - 'A' + 10 + default: + return -1 + } + + val <<= 4 + val |= rune(v) + } + return val +} + +// processEscape processes a single escape sequence and returns number of bytes processed. +func (r *Lexer) processEscape(data []byte) (int, error) { + if len(data) < 2 { + return 0, fmt.Errorf("syntax error at %v", string(data)) + } + + c := data[1] + switch c { + case '"', '/', '\\': + r.token.byteValue = append(r.token.byteValue, c) + return 2, nil + case 'b': + r.token.byteValue = append(r.token.byteValue, '\b') + return 2, nil + case 'f': + r.token.byteValue = append(r.token.byteValue, '\f') + return 2, nil + case 'n': + r.token.byteValue = append(r.token.byteValue, '\n') + return 2, nil + case 'r': + r.token.byteValue = append(r.token.byteValue, '\r') + return 2, nil + case 't': + r.token.byteValue = append(r.token.byteValue, '\t') + return 2, nil + case 'u': + rr := getu4(data) + if rr < 0 { + return 0, errors.New("syntax error") + } + + read := 6 + if utf16.IsSurrogate(rr) { + rr1 := getu4(data[read:]) + if dec := utf16.DecodeRune(rr, rr1); dec != unicode.ReplacementChar { + read += 6 + rr = dec + } else { + rr = unicode.ReplacementChar + } + } + var d [4]byte + s := utf8.EncodeRune(d[:], rr) + r.token.byteValue = append(r.token.byteValue, d[:s]...) + return read, nil + } + + return 0, errors.New("syntax error") +} + +// fetchString scans a string literal token. +func (r *Lexer) fetchString() { + r.pos++ + data := r.Data[r.pos:] + + hasEscapes, length := findStringLen(data) + if !hasEscapes { + r.token.byteValue = data[:length] + r.pos += length + 1 + return + } + + r.token.byteValue = make([]byte, 0, length) + p := 0 + for i := 0; i < len(data); { + switch data[i] { + case '"': + r.pos += i + 1 + r.token.byteValue = append(r.token.byteValue, data[p:i]...) + i++ + return + + case '\\': + r.token.byteValue = append(r.token.byteValue, data[p:i]...) + off, err := r.processEscape(data[i:]) + if err != nil { + r.errParse(err.Error()) + return + } + i += off + p = i + + default: + i++ + } + } + r.errParse("unterminated string literal") +} + +// scanToken scans the next token if no token is currently available in the lexer. +func (r *Lexer) scanToken() { + if r.token.kind != tokenUndef || r.fatalError != nil { + return + } + + r.FetchToken() +} + +// consume resets the current token to allow scanning the next one. +func (r *Lexer) consume() { + r.token.kind = tokenUndef + r.token.delimValue = 0 +} + +// Ok returns true if no error (including io.EOF) was encountered during scanning. +func (r *Lexer) Ok() bool { + return r.fatalError == nil +} + +const maxErrorContextLen = 13 + +func (r *Lexer) errParse(what string) { + if r.fatalError == nil { + var str string + if len(r.Data)-r.pos <= maxErrorContextLen { + str = string(r.Data) + } else { + str = string(r.Data[r.pos:r.pos+maxErrorContextLen-3]) + "..." + } + r.fatalError = &LexerError{ + Reason: what, + Offset: r.pos, + Data: str, + } + } +} + +func (r *Lexer) errSyntax() { + r.errParse("syntax error") +} + +func (r *Lexer) errInvalidToken(expected string) { + if r.fatalError != nil { + return + } + if r.UseMultipleErrors { + r.pos = r.start + r.consume() + r.SkipRecursive() + switch expected { + case "[": + r.token.delimValue = ']' + r.token.kind = tokenDelim + case "{": + r.token.delimValue = '}' + r.token.kind = tokenDelim + } + r.addNonfatalError(&LexerError{ + Reason: fmt.Sprintf("expected %s", expected), + Offset: r.start, + Data: string(r.Data[r.start:r.pos]), + }) + return + } + + var str string + if len(r.token.byteValue) <= maxErrorContextLen { + str = string(r.token.byteValue) + } else { + str = string(r.token.byteValue[:maxErrorContextLen-3]) + "..." + } + r.fatalError = &LexerError{ + Reason: fmt.Sprintf("expected %s", expected), + Offset: r.pos, + Data: str, + } +} + +func (r *Lexer) GetPos() int { + return r.pos +} + +// Delim consumes a token and verifies that it is the given delimiter. +func (r *Lexer) Delim(c byte) { + if r.token.kind == tokenUndef && r.Ok() { + r.FetchToken() + } + + if !r.Ok() || r.token.delimValue != c { + r.consume() // errInvalidToken can change token if UseMultipleErrors is enabled. + r.errInvalidToken(string([]byte{c})) + } else { + r.consume() + } +} + +// IsDelim returns true if there was no scanning error and next token is the given delimiter. +func (r *Lexer) IsDelim(c byte) bool { + if r.token.kind == tokenUndef && r.Ok() { + r.FetchToken() + } + return !r.Ok() || r.token.delimValue == c +} + +// Null verifies that the next token is null and consumes it. +func (r *Lexer) Null() { + if r.token.kind == tokenUndef && r.Ok() { + r.FetchToken() + } + if !r.Ok() || r.token.kind != tokenNull { + r.errInvalidToken("null") + } + r.consume() +} + +// IsNull returns true if the next token is a null keyword. +func (r *Lexer) IsNull() bool { + if r.token.kind == tokenUndef && r.Ok() { + r.FetchToken() + } + return r.Ok() && r.token.kind == tokenNull +} + +// Skip skips a single token. +func (r *Lexer) Skip() { + if r.token.kind == tokenUndef && r.Ok() { + r.FetchToken() + } + r.consume() +} + +// SkipRecursive skips next array or object completely, or just skips a single token if not +// an array/object. +// +// Note: no syntax validation is performed on the skipped data. +func (r *Lexer) SkipRecursive() { + r.scanToken() + var start, end byte + + if r.token.delimValue == '{' { + start, end = '{', '}' + } else if r.token.delimValue == '[' { + start, end = '[', ']' + } else { + r.consume() + return + } + + r.consume() + + level := 1 + inQuotes := false + wasEscape := false + + for i, c := range r.Data[r.pos:] { + switch { + case c == start && !inQuotes: + level++ + case c == end && !inQuotes: + level-- + if level == 0 { + r.pos += i + 1 + return + } + case c == '\\' && inQuotes: + wasEscape = !wasEscape + continue + case c == '"' && inQuotes: + inQuotes = wasEscape + case c == '"': + inQuotes = true + } + wasEscape = false + } + r.pos = len(r.Data) + r.fatalError = &LexerError{ + Reason: "EOF reached while skipping array/object or token", + Offset: r.pos, + Data: string(r.Data[r.pos:]), + } +} + +// Raw fetches the next item recursively as a data slice +func (r *Lexer) Raw() []byte { + r.SkipRecursive() + if !r.Ok() { + return nil + } + return r.Data[r.start:r.pos] +} + +// IsStart returns whether the lexer is positioned at the start +// of an input string. +func (r *Lexer) IsStart() bool { + return r.pos == 0 +} + +// Consumed reads all remaining bytes from the input, publishing an error if +// there is anything but whitespace remaining. +func (r *Lexer) Consumed() { + if r.pos > len(r.Data) || !r.Ok() { + return + } + + for _, c := range r.Data[r.pos:] { + if c != ' ' && c != '\t' && c != '\r' && c != '\n' { + r.AddError(&LexerError{ + Reason: "invalid character '" + string(c) + "' after top-level value", + Offset: r.pos, + Data: string(r.Data[r.pos:]), + }) + return + } + + r.pos++ + r.start++ + } +} + +func (r *Lexer) unsafeString() (string, []byte) { + if r.token.kind == tokenUndef && r.Ok() { + r.FetchToken() + } + if !r.Ok() || r.token.kind != tokenString { + r.errInvalidToken("string") + return "", nil + } + bytes := r.token.byteValue + ret := bytesToStr(r.token.byteValue) + r.consume() + return ret, bytes +} + +// UnsafeString returns the string value if the token is a string literal. +// +// Warning: returned string may point to the input buffer, so the string should not outlive +// the input buffer. Intended pattern of usage is as an argument to a switch statement. +func (r *Lexer) UnsafeString() string { + ret, _ := r.unsafeString() + return ret +} + +// UnsafeBytes returns the byte slice if the token is a string literal. +func (r *Lexer) UnsafeBytes() []byte { + _, ret := r.unsafeString() + return ret +} + +// String reads a string literal. +func (r *Lexer) String() string { + if r.token.kind == tokenUndef && r.Ok() { + r.FetchToken() + } + if !r.Ok() || r.token.kind != tokenString { + r.errInvalidToken("string") + return "" + } + ret := string(r.token.byteValue) + r.consume() + return ret +} + +// Bytes reads a string literal and base64 decodes it into a byte slice. +func (r *Lexer) Bytes() []byte { + if r.token.kind == tokenUndef && r.Ok() { + r.FetchToken() + } + if !r.Ok() || r.token.kind != tokenString { + r.errInvalidToken("string") + return nil + } + ret := make([]byte, base64.StdEncoding.DecodedLen(len(r.token.byteValue))) + len, err := base64.StdEncoding.Decode(ret, r.token.byteValue) + if err != nil { + r.fatalError = &LexerError{ + Reason: err.Error(), + } + return nil + } + + r.consume() + return ret[:len] +} + +// Bool reads a true or false boolean keyword. +func (r *Lexer) Bool() bool { + if r.token.kind == tokenUndef && r.Ok() { + r.FetchToken() + } + if !r.Ok() || r.token.kind != tokenBool { + r.errInvalidToken("bool") + return false + } + ret := r.token.boolValue + r.consume() + return ret +} + +func (r *Lexer) number() string { + if r.token.kind == tokenUndef && r.Ok() { + r.FetchToken() + } + if !r.Ok() || r.token.kind != tokenNumber { + r.errInvalidToken("number") + return "" + } + ret := bytesToStr(r.token.byteValue) + r.consume() + return ret +} + +func (r *Lexer) Uint8() uint8 { + s := r.number() + if !r.Ok() { + return 0 + } + + n, err := strconv.ParseUint(s, 10, 8) + if err != nil { + r.addNonfatalError(&LexerError{ + Offset: r.start, + Reason: err.Error(), + Data: s, + }) + } + return uint8(n) +} + +func (r *Lexer) Uint16() uint16 { + s := r.number() + if !r.Ok() { + return 0 + } + + n, err := strconv.ParseUint(s, 10, 16) + if err != nil { + r.addNonfatalError(&LexerError{ + Offset: r.start, + Reason: err.Error(), + Data: s, + }) + } + return uint16(n) +} + +func (r *Lexer) Uint32() uint32 { + s := r.number() + if !r.Ok() { + return 0 + } + + n, err := strconv.ParseUint(s, 10, 32) + if err != nil { + r.addNonfatalError(&LexerError{ + Offset: r.start, + Reason: err.Error(), + Data: s, + }) + } + return uint32(n) +} + +func (r *Lexer) Uint64() uint64 { + s := r.number() + if !r.Ok() { + return 0 + } + + n, err := strconv.ParseUint(s, 10, 64) + if err != nil { + r.addNonfatalError(&LexerError{ + Offset: r.start, + Reason: err.Error(), + Data: s, + }) + } + return n +} + +func (r *Lexer) Uint() uint { + return uint(r.Uint64()) +} + +func (r *Lexer) Int8() int8 { + s := r.number() + if !r.Ok() { + return 0 + } + + n, err := strconv.ParseInt(s, 10, 8) + if err != nil { + r.addNonfatalError(&LexerError{ + Offset: r.start, + Reason: err.Error(), + Data: s, + }) + } + return int8(n) +} + +func (r *Lexer) Int16() int16 { + s := r.number() + if !r.Ok() { + return 0 + } + + n, err := strconv.ParseInt(s, 10, 16) + if err != nil { + r.addNonfatalError(&LexerError{ + Offset: r.start, + Reason: err.Error(), + Data: s, + }) + } + return int16(n) +} + +func (r *Lexer) Int32() int32 { + s := r.number() + if !r.Ok() { + return 0 + } + + n, err := strconv.ParseInt(s, 10, 32) + if err != nil { + r.addNonfatalError(&LexerError{ + Offset: r.start, + Reason: err.Error(), + Data: s, + }) + } + return int32(n) +} + +func (r *Lexer) Int64() int64 { + s := r.number() + if !r.Ok() { + return 0 + } + + n, err := strconv.ParseInt(s, 10, 64) + if err != nil { + r.addNonfatalError(&LexerError{ + Offset: r.start, + Reason: err.Error(), + Data: s, + }) + } + return n +} + +func (r *Lexer) Int() int { + return int(r.Int64()) +} + +func (r *Lexer) Uint8Str() uint8 { + s, b := r.unsafeString() + if !r.Ok() { + return 0 + } + + n, err := strconv.ParseUint(s, 10, 8) + if err != nil { + r.addNonfatalError(&LexerError{ + Offset: r.start, + Reason: err.Error(), + Data: string(b), + }) + } + return uint8(n) +} + +func (r *Lexer) Uint16Str() uint16 { + s, b := r.unsafeString() + if !r.Ok() { + return 0 + } + + n, err := strconv.ParseUint(s, 10, 16) + if err != nil { + r.addNonfatalError(&LexerError{ + Offset: r.start, + Reason: err.Error(), + Data: string(b), + }) + } + return uint16(n) +} + +func (r *Lexer) Uint32Str() uint32 { + s, b := r.unsafeString() + if !r.Ok() { + return 0 + } + + n, err := strconv.ParseUint(s, 10, 32) + if err != nil { + r.addNonfatalError(&LexerError{ + Offset: r.start, + Reason: err.Error(), + Data: string(b), + }) + } + return uint32(n) +} + +func (r *Lexer) Uint64Str() uint64 { + s, b := r.unsafeString() + if !r.Ok() { + return 0 + } + + n, err := strconv.ParseUint(s, 10, 64) + if err != nil { + r.addNonfatalError(&LexerError{ + Offset: r.start, + Reason: err.Error(), + Data: string(b), + }) + } + return n +} + +func (r *Lexer) UintStr() uint { + return uint(r.Uint64Str()) +} + +func (r *Lexer) UintptrStr() uintptr { + return uintptr(r.Uint64Str()) +} + +func (r *Lexer) Int8Str() int8 { + s, b := r.unsafeString() + if !r.Ok() { + return 0 + } + + n, err := strconv.ParseInt(s, 10, 8) + if err != nil { + r.addNonfatalError(&LexerError{ + Offset: r.start, + Reason: err.Error(), + Data: string(b), + }) + } + return int8(n) +} + +func (r *Lexer) Int16Str() int16 { + s, b := r.unsafeString() + if !r.Ok() { + return 0 + } + + n, err := strconv.ParseInt(s, 10, 16) + if err != nil { + r.addNonfatalError(&LexerError{ + Offset: r.start, + Reason: err.Error(), + Data: string(b), + }) + } + return int16(n) +} + +func (r *Lexer) Int32Str() int32 { + s, b := r.unsafeString() + if !r.Ok() { + return 0 + } + + n, err := strconv.ParseInt(s, 10, 32) + if err != nil { + r.addNonfatalError(&LexerError{ + Offset: r.start, + Reason: err.Error(), + Data: string(b), + }) + } + return int32(n) +} + +func (r *Lexer) Int64Str() int64 { + s, b := r.unsafeString() + if !r.Ok() { + return 0 + } + + n, err := strconv.ParseInt(s, 10, 64) + if err != nil { + r.addNonfatalError(&LexerError{ + Offset: r.start, + Reason: err.Error(), + Data: string(b), + }) + } + return n +} + +func (r *Lexer) IntStr() int { + return int(r.Int64Str()) +} + +func (r *Lexer) Float32() float32 { + s := r.number() + if !r.Ok() { + return 0 + } + + n, err := strconv.ParseFloat(s, 32) + if err != nil { + r.addNonfatalError(&LexerError{ + Offset: r.start, + Reason: err.Error(), + Data: s, + }) + } + return float32(n) +} + +func (r *Lexer) Float64() float64 { + s := r.number() + if !r.Ok() { + return 0 + } + + n, err := strconv.ParseFloat(s, 64) + if err != nil { + r.addNonfatalError(&LexerError{ + Offset: r.start, + Reason: err.Error(), + Data: s, + }) + } + return n +} + +func (r *Lexer) Error() error { + return r.fatalError +} + +func (r *Lexer) AddError(e error) { + if r.fatalError == nil { + r.fatalError = e + } +} + +func (r *Lexer) AddNonFatalError(e error) { + r.addNonfatalError(&LexerError{ + Offset: r.start, + Data: string(r.Data[r.start:r.pos]), + Reason: e.Error(), + }) +} + +func (r *Lexer) addNonfatalError(err *LexerError) { + if r.UseMultipleErrors { + // We don't want to add errors with the same offset. + if len(r.multipleErrors) != 0 && r.multipleErrors[len(r.multipleErrors)-1].Offset == err.Offset { + return + } + r.multipleErrors = append(r.multipleErrors, err) + return + } + r.fatalError = err +} + +func (r *Lexer) GetNonFatalErrors() []*LexerError { + return r.multipleErrors +} + +// JsonNumber fetches and json.Number from 'encoding/json' package. +// Both int, float or string, contains them are valid values +func (r *Lexer) JsonNumber() json.Number { + if r.token.kind == tokenUndef && r.Ok() { + r.FetchToken() + } + if !r.Ok() { + r.errInvalidToken("json.Number") + return json.Number("0") + } + + switch r.token.kind { + case tokenString: + return json.Number(r.String()) + case tokenNumber: + return json.Number(r.Raw()) + default: + r.errSyntax() + return json.Number("0") + } +} + +// Interface fetches an interface{} analogous to the 'encoding/json' package. +func (r *Lexer) Interface() interface{} { + if r.token.kind == tokenUndef && r.Ok() { + r.FetchToken() + } + + if !r.Ok() { + return nil + } + switch r.token.kind { + case tokenString: + return r.String() + case tokenNumber: + return r.Float64() + case tokenBool: + return r.Bool() + case tokenNull: + r.Null() + return nil + } + + if r.token.delimValue == '{' { + r.consume() + + ret := map[string]interface{}{} + for !r.IsDelim('}') { + key := r.String() + r.WantColon() + ret[key] = r.Interface() + r.WantComma() + } + r.Delim('}') + + if r.Ok() { + return ret + } else { + return nil + } + } else if r.token.delimValue == '[' { + r.consume() + + var ret []interface{} + for !r.IsDelim(']') { + ret = append(ret, r.Interface()) + r.WantComma() + } + r.Delim(']') + + if r.Ok() { + return ret + } else { + return nil + } + } + r.errSyntax() + return nil +} + +// WantComma requires a comma to be present before fetching next token. +func (r *Lexer) WantComma() { + r.wantSep = ',' + r.firstElement = false +} + +// WantColon requires a colon to be present before fetching next token. +func (r *Lexer) WantColon() { + r.wantSep = ':' + r.firstElement = false +} diff --git a/vendor/github.com/mailru/easyjson/jlexer/lexer_test.go b/vendor/github.com/mailru/easyjson/jlexer/lexer_test.go new file mode 100644 index 000000000..4ce4abe6a --- /dev/null +++ b/vendor/github.com/mailru/easyjson/jlexer/lexer_test.go @@ -0,0 +1,311 @@ +package jlexer + +import ( + "bytes" + "encoding/json" + "reflect" + "testing" +) + +func TestString(t *testing.T) { + for i, test := range []struct { + toParse string + want string + wantError bool + }{ + {toParse: `"simple string"`, want: "simple string"}, + {toParse: " \r\r\n\t " + `"test"`, want: "test"}, + {toParse: `"\n\t\"\/\\\f\r"`, want: "\n\t\"/\\\f\r"}, + {toParse: `"\u0020"`, want: " "}, + {toParse: `"\u0020-\t"`, want: " -\t"}, + {toParse: `"\ufffd\uFFFD"`, want: "\ufffd\ufffd"}, + {toParse: `"\ud83d\ude00"`, want: "😀"}, + {toParse: `"\ud83d\ude08"`, want: "😈"}, + {toParse: `"\ud8"`, wantError: true}, + + {toParse: `"test"junk`, want: "test"}, + + {toParse: `5`, wantError: true}, // not a string + {toParse: `"\x"`, wantError: true}, // invalid escape + {toParse: `"\ud800"`, want: "�"}, // invalid utf-8 char; return replacement char + } { + l := Lexer{Data: []byte(test.toParse)} + + got := l.String() + if got != test.want { + t.Errorf("[%d, %q] String() = %v; want %v", i, test.toParse, got, test.want) + } + err := l.Error() + if err != nil && !test.wantError { + t.Errorf("[%d, %q] String() error: %v", i, test.toParse, err) + } else if err == nil && test.wantError { + t.Errorf("[%d, %q] String() ok; want error", i, test.toParse) + } + } +} + +func TestBytes(t *testing.T) { + for i, test := range []struct { + toParse string + want string + wantError bool + }{ + {toParse: `"c2ltcGxlIHN0cmluZw=="`, want: "simple string"}, + {toParse: " \r\r\n\t " + `"dGVzdA=="`, want: "test"}, + + {toParse: `5`, wantError: true}, // not a JSON string + {toParse: `"foobar"`, wantError: true}, // not base64 encoded + {toParse: `"c2ltcGxlIHN0cmluZw="`, wantError: true}, // invalid base64 padding + } { + l := Lexer{Data: []byte(test.toParse)} + + got := l.Bytes() + if bytes.Compare(got, []byte(test.want)) != 0 { + t.Errorf("[%d, %q] Bytes() = %v; want: %v", i, test.toParse, got, []byte(test.want)) + } + err := l.Error() + if err != nil && !test.wantError { + t.Errorf("[%d, %q] Bytes() error: %v", i, test.toParse, err) + } else if err == nil && test.wantError { + t.Errorf("[%d, %q] Bytes() ok; want error", i, test.toParse) + } + } +} + +func TestNumber(t *testing.T) { + for i, test := range []struct { + toParse string + want string + wantError bool + }{ + {toParse: "123", want: "123"}, + {toParse: "-123", want: "-123"}, + {toParse: "\r\n12.35", want: "12.35"}, + {toParse: "12.35e+1", want: "12.35e+1"}, + {toParse: "12.35e-15", want: "12.35e-15"}, + {toParse: "12.35E-15", want: "12.35E-15"}, + {toParse: "12.35E15", want: "12.35E15"}, + + {toParse: `"a"`, wantError: true}, + {toParse: "123junk", wantError: true}, + {toParse: "1.2.3", wantError: true}, + {toParse: "1e2e3", wantError: true}, + {toParse: "1e2.3", wantError: true}, + } { + l := Lexer{Data: []byte(test.toParse)} + + got := l.number() + if got != test.want { + t.Errorf("[%d, %q] number() = %v; want %v", i, test.toParse, got, test.want) + } + err := l.Error() + if err != nil && !test.wantError { + t.Errorf("[%d, %q] number() error: %v", i, test.toParse, err) + } else if err == nil && test.wantError { + t.Errorf("[%d, %q] number() ok; want error", i, test.toParse) + } + } +} + +func TestBool(t *testing.T) { + for i, test := range []struct { + toParse string + want bool + wantError bool + }{ + {toParse: "true", want: true}, + {toParse: "false", want: false}, + + {toParse: "1", wantError: true}, + {toParse: "truejunk", wantError: true}, + {toParse: `false"junk"`, wantError: true}, + {toParse: "True", wantError: true}, + {toParse: "False", wantError: true}, + } { + l := Lexer{Data: []byte(test.toParse)} + + got := l.Bool() + if got != test.want { + t.Errorf("[%d, %q] Bool() = %v; want %v", i, test.toParse, got, test.want) + } + err := l.Error() + if err != nil && !test.wantError { + t.Errorf("[%d, %q] Bool() error: %v", i, test.toParse, err) + } else if err == nil && test.wantError { + t.Errorf("[%d, %q] Bool() ok; want error", i, test.toParse) + } + } +} + +func TestSkipRecursive(t *testing.T) { + for i, test := range []struct { + toParse string + left string + wantError bool + }{ + {toParse: "5, 4", left: ", 4"}, + {toParse: "[5, 6], 4", left: ", 4"}, + {toParse: "[5, [7,8]]: 4", left: ": 4"}, + + {toParse: `{"a":1}, 4`, left: ", 4"}, + {toParse: `{"a":1, "b":{"c": 5}, "e":[12,15]}, 4`, left: ", 4"}, + + // array start/end chars in a string + {toParse: `[5, "]"], 4`, left: ", 4"}, + {toParse: `[5, "\"]"], 4`, left: ", 4"}, + {toParse: `[5, "["], 4`, left: ", 4"}, + {toParse: `[5, "\"["], 4`, left: ", 4"}, + + // object start/end chars in a string + {toParse: `{"a}":1}, 4`, left: ", 4"}, + {toParse: `{"a\"}":1}, 4`, left: ", 4"}, + {toParse: `{"a{":1}, 4`, left: ", 4"}, + {toParse: `{"a\"{":1}, 4`, left: ", 4"}, + + // object with double slashes at the end of string + {toParse: `{"a":"hey\\"}, 4`, left: ", 4"}, + } { + l := Lexer{Data: []byte(test.toParse)} + + l.SkipRecursive() + + got := string(l.Data[l.pos:]) + if got != test.left { + t.Errorf("[%d, %q] SkipRecursive() left = %v; want %v", i, test.toParse, got, test.left) + } + err := l.Error() + if err != nil && !test.wantError { + t.Errorf("[%d, %q] SkipRecursive() error: %v", i, test.toParse, err) + } else if err == nil && test.wantError { + t.Errorf("[%d, %q] SkipRecursive() ok; want error", i, test.toParse) + } + } +} + +func TestInterface(t *testing.T) { + for i, test := range []struct { + toParse string + want interface{} + wantError bool + }{ + {toParse: "null", want: nil}, + {toParse: "true", want: true}, + {toParse: `"a"`, want: "a"}, + {toParse: "5", want: float64(5)}, + + {toParse: `{}`, want: map[string]interface{}{}}, + {toParse: `[]`, want: []interface{}(nil)}, + + {toParse: `{"a": "b"}`, want: map[string]interface{}{"a": "b"}}, + {toParse: `[5]`, want: []interface{}{float64(5)}}, + + {toParse: `{"a":5 , "b" : "string"}`, want: map[string]interface{}{"a": float64(5), "b": "string"}}, + {toParse: `["a", 5 , null, true]`, want: []interface{}{"a", float64(5), nil, true}}, + + {toParse: `{"a" "b"}`, wantError: true}, + {toParse: `{"a": "b",}`, wantError: true}, + {toParse: `{"a":"b","c" "b"}`, wantError: true}, + {toParse: `{"a": "b","c":"d",}`, wantError: true}, + {toParse: `{,}`, wantError: true}, + + {toParse: `[1, 2,]`, wantError: true}, + {toParse: `[1 2]`, wantError: true}, + {toParse: `[,]`, wantError: true}, + } { + l := Lexer{Data: []byte(test.toParse)} + + got := l.Interface() + if !reflect.DeepEqual(got, test.want) { + t.Errorf("[%d, %q] Interface() = %v; want %v", i, test.toParse, got, test.want) + } + err := l.Error() + if err != nil && !test.wantError { + t.Errorf("[%d, %q] Interface() error: %v", i, test.toParse, err) + } else if err == nil && test.wantError { + t.Errorf("[%d, %q] Interface() ok; want error", i, test.toParse) + } + } +} + +func TestConsumed(t *testing.T) { + for i, test := range []struct { + toParse string + wantError bool + }{ + {toParse: "", wantError: false}, + {toParse: " ", wantError: false}, + {toParse: "\r\n", wantError: false}, + {toParse: "\t\t", wantError: false}, + + {toParse: "{", wantError: true}, + } { + l := Lexer{Data: []byte(test.toParse)} + l.Consumed() + + err := l.Error() + if err != nil && !test.wantError { + t.Errorf("[%d, %q] Consumed() error: %v", i, test.toParse, err) + } else if err == nil && test.wantError { + t.Errorf("[%d, %q] Consumed() ok; want error", i, test.toParse) + } + } +} + +func TestJsonNumber(t *testing.T) { + for i, test := range []struct { + toParse string + want json.Number + wantLexerError bool + wantValue interface{} + wantValueError bool + }{ + {toParse: `10`, want: json.Number("10"), wantValue: int64(10)}, + {toParse: `0`, want: json.Number("0"), wantValue: int64(0)}, + {toParse: `0.12`, want: json.Number("0.12"), wantValue: 0.12}, + {toParse: `25E-4`, want: json.Number("25E-4"), wantValue: 25E-4}, + + {toParse: `"10"`, want: json.Number("10"), wantValue: int64(10)}, + {toParse: `"0"`, want: json.Number("0"), wantValue: int64(0)}, + {toParse: `"0.12"`, want: json.Number("0.12"), wantValue: 0.12}, + {toParse: `"25E-4"`, want: json.Number("25E-4"), wantValue: 25E-4}, + + {toParse: `"a""`, wantValueError: true}, + + {toParse: `[1]`, wantLexerError: true}, + {toParse: `{}`, wantLexerError: true}, + {toParse: `a`, wantLexerError: true}, + } { + l := Lexer{Data: []byte(test.toParse)} + + got := l.JsonNumber() + if got != test.want && !test.wantLexerError && !test.wantValueError { + t.Errorf("[%d, %q] JsonNumber() = %v; want %v", i, test.toParse, got, test.want) + } + + err := l.Error() + if err != nil && !test.wantLexerError { + t.Errorf("[%d, %q] JsonNumber() lexer error: %v", i, test.toParse, err) + } else if err == nil && test.wantLexerError { + t.Errorf("[%d, %q] JsonNumber() ok; want lexer error", i, test.toParse) + } + + var valueErr error + var gotValue interface{} + switch test.wantValue.(type) { + case float64: + gotValue, valueErr = got.Float64() + default: + gotValue, valueErr = got.Int64() + } + + if !reflect.DeepEqual(gotValue, test.wantValue) && !test.wantLexerError && !test.wantValueError { + t.Errorf("[%d, %q] JsonNumber() = %v; want %v", i, test.toParse, gotValue, test.wantValue) + } + + if valueErr != nil && !test.wantValueError { + t.Errorf("[%d, %q] JsonNumber() value error: %v", i, test.toParse, err) + } else if valueErr == nil && test.wantValueError { + t.Errorf("[%d, %q] JsonNumber() ok; want value error", i, test.toParse) + } + } +} diff --git a/vendor/github.com/mailru/easyjson/jwriter/writer.go b/vendor/github.com/mailru/easyjson/jwriter/writer.go new file mode 100644 index 000000000..e5a5ddfdb --- /dev/null +++ b/vendor/github.com/mailru/easyjson/jwriter/writer.go @@ -0,0 +1,377 @@ +// Package jwriter contains a JSON writer. +package jwriter + +import ( + "io" + "strconv" + "unicode/utf8" + + "github.com/mailru/easyjson/buffer" +) + +// Flags describe various encoding options. The behavior may be actually implemented in the encoder, but +// Flags field in Writer is used to set and pass them around. +type Flags int + +const ( + NilMapAsEmpty Flags = 1 << iota // Encode nil map as '{}' rather than 'null'. + NilSliceAsEmpty // Encode nil slice as '[]' rather than 'null'. +) + +// Writer is a JSON writer. +type Writer struct { + Flags Flags + + Error error + Buffer buffer.Buffer + NoEscapeHTML bool +} + +// Size returns the size of the data that was written out. +func (w *Writer) Size() int { + return w.Buffer.Size() +} + +// DumpTo outputs the data to given io.Writer, resetting the buffer. +func (w *Writer) DumpTo(out io.Writer) (written int, err error) { + return w.Buffer.DumpTo(out) +} + +// BuildBytes returns writer data as a single byte slice. You can optionally provide one byte slice +// as argument that it will try to reuse. +func (w *Writer) BuildBytes(reuse ...[]byte) ([]byte, error) { + if w.Error != nil { + return nil, w.Error + } + + return w.Buffer.BuildBytes(reuse...), nil +} + +// ReadCloser returns an io.ReadCloser that can be used to read the data. +// ReadCloser also resets the buffer. +func (w *Writer) ReadCloser() (io.ReadCloser, error) { + if w.Error != nil { + return nil, w.Error + } + + return w.Buffer.ReadCloser(), nil +} + +// RawByte appends raw binary data to the buffer. +func (w *Writer) RawByte(c byte) { + w.Buffer.AppendByte(c) +} + +// RawByte appends raw binary data to the buffer. +func (w *Writer) RawString(s string) { + w.Buffer.AppendString(s) +} + +// Raw appends raw binary data to the buffer or sets the error if it is given. Useful for +// calling with results of MarshalJSON-like functions. +func (w *Writer) Raw(data []byte, err error) { + switch { + case w.Error != nil: + return + case err != nil: + w.Error = err + case len(data) > 0: + w.Buffer.AppendBytes(data) + default: + w.RawString("null") + } +} + +// RawText encloses raw binary data in quotes and appends in to the buffer. +// Useful for calling with results of MarshalText-like functions. +func (w *Writer) RawText(data []byte, err error) { + switch { + case w.Error != nil: + return + case err != nil: + w.Error = err + case len(data) > 0: + w.String(string(data)) + default: + w.RawString("null") + } +} + +// Base64Bytes appends data to the buffer after base64 encoding it +func (w *Writer) Base64Bytes(data []byte) { + if data == nil { + w.Buffer.AppendString("null") + return + } + w.Buffer.AppendByte('"') + w.base64(data) + w.Buffer.AppendByte('"') +} + +func (w *Writer) Uint8(n uint8) { + w.Buffer.EnsureSpace(3) + w.Buffer.Buf = strconv.AppendUint(w.Buffer.Buf, uint64(n), 10) +} + +func (w *Writer) Uint16(n uint16) { + w.Buffer.EnsureSpace(5) + w.Buffer.Buf = strconv.AppendUint(w.Buffer.Buf, uint64(n), 10) +} + +func (w *Writer) Uint32(n uint32) { + w.Buffer.EnsureSpace(10) + w.Buffer.Buf = strconv.AppendUint(w.Buffer.Buf, uint64(n), 10) +} + +func (w *Writer) Uint(n uint) { + w.Buffer.EnsureSpace(20) + w.Buffer.Buf = strconv.AppendUint(w.Buffer.Buf, uint64(n), 10) +} + +func (w *Writer) Uint64(n uint64) { + w.Buffer.EnsureSpace(20) + w.Buffer.Buf = strconv.AppendUint(w.Buffer.Buf, n, 10) +} + +func (w *Writer) Int8(n int8) { + w.Buffer.EnsureSpace(4) + w.Buffer.Buf = strconv.AppendInt(w.Buffer.Buf, int64(n), 10) +} + +func (w *Writer) Int16(n int16) { + w.Buffer.EnsureSpace(6) + w.Buffer.Buf = strconv.AppendInt(w.Buffer.Buf, int64(n), 10) +} + +func (w *Writer) Int32(n int32) { + w.Buffer.EnsureSpace(11) + w.Buffer.Buf = strconv.AppendInt(w.Buffer.Buf, int64(n), 10) +} + +func (w *Writer) Int(n int) { + w.Buffer.EnsureSpace(21) + w.Buffer.Buf = strconv.AppendInt(w.Buffer.Buf, int64(n), 10) +} + +func (w *Writer) Int64(n int64) { + w.Buffer.EnsureSpace(21) + w.Buffer.Buf = strconv.AppendInt(w.Buffer.Buf, n, 10) +} + +func (w *Writer) Uint8Str(n uint8) { + w.Buffer.EnsureSpace(3) + w.Buffer.Buf = append(w.Buffer.Buf, '"') + w.Buffer.Buf = strconv.AppendUint(w.Buffer.Buf, uint64(n), 10) + w.Buffer.Buf = append(w.Buffer.Buf, '"') +} + +func (w *Writer) Uint16Str(n uint16) { + w.Buffer.EnsureSpace(5) + w.Buffer.Buf = append(w.Buffer.Buf, '"') + w.Buffer.Buf = strconv.AppendUint(w.Buffer.Buf, uint64(n), 10) + w.Buffer.Buf = append(w.Buffer.Buf, '"') +} + +func (w *Writer) Uint32Str(n uint32) { + w.Buffer.EnsureSpace(10) + w.Buffer.Buf = append(w.Buffer.Buf, '"') + w.Buffer.Buf = strconv.AppendUint(w.Buffer.Buf, uint64(n), 10) + w.Buffer.Buf = append(w.Buffer.Buf, '"') +} + +func (w *Writer) UintStr(n uint) { + w.Buffer.EnsureSpace(20) + w.Buffer.Buf = append(w.Buffer.Buf, '"') + w.Buffer.Buf = strconv.AppendUint(w.Buffer.Buf, uint64(n), 10) + w.Buffer.Buf = append(w.Buffer.Buf, '"') +} + +func (w *Writer) Uint64Str(n uint64) { + w.Buffer.EnsureSpace(20) + w.Buffer.Buf = append(w.Buffer.Buf, '"') + w.Buffer.Buf = strconv.AppendUint(w.Buffer.Buf, n, 10) + w.Buffer.Buf = append(w.Buffer.Buf, '"') +} + +func (w *Writer) UintptrStr(n uintptr) { + w.Buffer.EnsureSpace(20) + w.Buffer.Buf = append(w.Buffer.Buf, '"') + w.Buffer.Buf = strconv.AppendUint(w.Buffer.Buf, uint64(n), 10) + w.Buffer.Buf = append(w.Buffer.Buf, '"') +} + +func (w *Writer) Int8Str(n int8) { + w.Buffer.EnsureSpace(4) + w.Buffer.Buf = append(w.Buffer.Buf, '"') + w.Buffer.Buf = strconv.AppendInt(w.Buffer.Buf, int64(n), 10) + w.Buffer.Buf = append(w.Buffer.Buf, '"') +} + +func (w *Writer) Int16Str(n int16) { + w.Buffer.EnsureSpace(6) + w.Buffer.Buf = append(w.Buffer.Buf, '"') + w.Buffer.Buf = strconv.AppendInt(w.Buffer.Buf, int64(n), 10) + w.Buffer.Buf = append(w.Buffer.Buf, '"') +} + +func (w *Writer) Int32Str(n int32) { + w.Buffer.EnsureSpace(11) + w.Buffer.Buf = append(w.Buffer.Buf, '"') + w.Buffer.Buf = strconv.AppendInt(w.Buffer.Buf, int64(n), 10) + w.Buffer.Buf = append(w.Buffer.Buf, '"') +} + +func (w *Writer) IntStr(n int) { + w.Buffer.EnsureSpace(21) + w.Buffer.Buf = append(w.Buffer.Buf, '"') + w.Buffer.Buf = strconv.AppendInt(w.Buffer.Buf, int64(n), 10) + w.Buffer.Buf = append(w.Buffer.Buf, '"') +} + +func (w *Writer) Int64Str(n int64) { + w.Buffer.EnsureSpace(21) + w.Buffer.Buf = append(w.Buffer.Buf, '"') + w.Buffer.Buf = strconv.AppendInt(w.Buffer.Buf, n, 10) + w.Buffer.Buf = append(w.Buffer.Buf, '"') +} + +func (w *Writer) Float32(n float32) { + w.Buffer.EnsureSpace(20) + w.Buffer.Buf = strconv.AppendFloat(w.Buffer.Buf, float64(n), 'g', -1, 32) +} + +func (w *Writer) Float64(n float64) { + w.Buffer.EnsureSpace(20) + w.Buffer.Buf = strconv.AppendFloat(w.Buffer.Buf, n, 'g', -1, 64) +} + +func (w *Writer) Bool(v bool) { + w.Buffer.EnsureSpace(5) + if v { + w.Buffer.Buf = append(w.Buffer.Buf, "true"...) + } else { + w.Buffer.Buf = append(w.Buffer.Buf, "false"...) + } +} + +const chars = "0123456789abcdef" + +func isNotEscapedSingleChar(c byte, escapeHTML bool) bool { + // Note: might make sense to use a table if there are more chars to escape. With 4 chars + // it benchmarks the same. + if escapeHTML { + return c != '<' && c != '>' && c != '&' && c != '\\' && c != '"' && c >= 0x20 && c < utf8.RuneSelf + } else { + return c != '\\' && c != '"' && c >= 0x20 && c < utf8.RuneSelf + } +} + +func (w *Writer) String(s string) { + w.Buffer.AppendByte('"') + + // Portions of the string that contain no escapes are appended as + // byte slices. + + p := 0 // last non-escape symbol + + for i := 0; i < len(s); { + c := s[i] + + if isNotEscapedSingleChar(c, !w.NoEscapeHTML) { + // single-width character, no escaping is required + i++ + continue + } else if c < utf8.RuneSelf { + // single-with character, need to escape + w.Buffer.AppendString(s[p:i]) + switch c { + case '\t': + w.Buffer.AppendString(`\t`) + case '\r': + w.Buffer.AppendString(`\r`) + case '\n': + w.Buffer.AppendString(`\n`) + case '\\': + w.Buffer.AppendString(`\\`) + case '"': + w.Buffer.AppendString(`\"`) + default: + w.Buffer.AppendString(`\u00`) + w.Buffer.AppendByte(chars[c>>4]) + w.Buffer.AppendByte(chars[c&0xf]) + } + + i++ + p = i + continue + } + + // broken utf + runeValue, runeWidth := utf8.DecodeRuneInString(s[i:]) + if runeValue == utf8.RuneError && runeWidth == 1 { + w.Buffer.AppendString(s[p:i]) + w.Buffer.AppendString(`\ufffd`) + i++ + p = i + continue + } + + // jsonp stuff - tab separator and line separator + if runeValue == '\u2028' || runeValue == '\u2029' { + w.Buffer.AppendString(s[p:i]) + w.Buffer.AppendString(`\u202`) + w.Buffer.AppendByte(chars[runeValue&0xf]) + i += runeWidth + p = i + continue + } + i += runeWidth + } + w.Buffer.AppendString(s[p:]) + w.Buffer.AppendByte('"') +} + +const encode = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/" +const padChar = '=' + +func (w *Writer) base64(in []byte) { + + if len(in) == 0 { + return + } + + w.Buffer.EnsureSpace(((len(in) - 1) / 3 + 1) * 4) + + si := 0 + n := (len(in) / 3) * 3 + + + for si < n { + // Convert 3x 8bit source bytes into 4 bytes + val := uint(in[si+0])<<16 | uint(in[si+1])<<8 | uint(in[si+2]) + + w.Buffer.Buf = append(w.Buffer.Buf, encode[val>>18&0x3F], encode[val>>12&0x3F], encode[val>>6&0x3F], encode[val&0x3F]) + + si += 3 + } + + remain := len(in) - si + if remain == 0 { + return + } + + // Add the remaining small block + val := uint(in[si+0]) << 16 + if remain == 2 { + val |= uint(in[si+1]) << 8 + } + + w.Buffer.Buf = append(w.Buffer.Buf, encode[val>>18&0x3F], encode[val>>12&0x3F]) + + switch remain { + case 2: + w.Buffer.Buf = append(w.Buffer.Buf, encode[val>>6&0x3F], byte(padChar)) + case 1: + w.Buffer.Buf = append(w.Buffer.Buf, byte(padChar), byte(padChar)) + } +} diff --git a/vendor/github.com/mailru/easyjson/opt/gotemplate_Bool.go b/vendor/github.com/mailru/easyjson/opt/gotemplate_Bool.go new file mode 100644 index 000000000..6978ee971 --- /dev/null +++ b/vendor/github.com/mailru/easyjson/opt/gotemplate_Bool.go @@ -0,0 +1,79 @@ +// generated by gotemplate + +package opt + +import ( + "fmt" + + "github.com/mailru/easyjson/jlexer" + "github.com/mailru/easyjson/jwriter" +) + +// template type Optional(A) + +// A 'gotemplate'-based type for providing optional semantics without using pointers. +type Bool struct { + V bool + Defined bool +} + +// Creates an optional type with a given value. +func OBool(v bool) Bool { + return Bool{V: v, Defined: true} +} + +// Get returns the value or given default in the case the value is undefined. +func (v Bool) Get(deflt bool) bool { + if !v.Defined { + return deflt + } + return v.V +} + +// MarshalEasyJSON does JSON marshaling using easyjson interface. +func (v Bool) MarshalEasyJSON(w *jwriter.Writer) { + if v.Defined { + w.Bool(v.V) + } else { + w.RawString("null") + } +} + +// UnmarshalEasyJSON does JSON unmarshaling using easyjson interface. +func (v *Bool) UnmarshalEasyJSON(l *jlexer.Lexer) { + if l.IsNull() { + l.Skip() + *v = Bool{} + } else { + v.V = l.Bool() + v.Defined = true + } +} + +// MarshalJSON implements a standard json marshaler interface. +func (v Bool) MarshalJSON() ([]byte, error) { + w := jwriter.Writer{} + v.MarshalEasyJSON(&w) + return w.Buffer.BuildBytes(), w.Error +} + +// UnmarshalJSON implements a standard json unmarshaler interface. +func (v *Bool) UnmarshalJSON(data []byte) error { + l := jlexer.Lexer{Data: data} + v.UnmarshalEasyJSON(&l) + return l.Error() +} + +// IsDefined returns whether the value is defined, a function is required so that it can +// be used in an interface. +func (v Bool) IsDefined() bool { + return v.Defined +} + +// String implements a stringer interface using fmt.Sprint for the value. +func (v Bool) String() string { + if !v.Defined { + return "<undefined>" + } + return fmt.Sprint(v.V) +} diff --git a/vendor/github.com/mailru/easyjson/opt/gotemplate_Float32.go b/vendor/github.com/mailru/easyjson/opt/gotemplate_Float32.go new file mode 100644 index 000000000..643cea359 --- /dev/null +++ b/vendor/github.com/mailru/easyjson/opt/gotemplate_Float32.go @@ -0,0 +1,79 @@ +// generated by gotemplate + +package opt + +import ( + "fmt" + + "github.com/mailru/easyjson/jlexer" + "github.com/mailru/easyjson/jwriter" +) + +// template type Optional(A) + +// A 'gotemplate'-based type for providing optional semantics without using pointers. +type Float32 struct { + V float32 + Defined bool +} + +// Creates an optional type with a given value. +func OFloat32(v float32) Float32 { + return Float32{V: v, Defined: true} +} + +// Get returns the value or given default in the case the value is undefined. +func (v Float32) Get(deflt float32) float32 { + if !v.Defined { + return deflt + } + return v.V +} + +// MarshalEasyJSON does JSON marshaling using easyjson interface. +func (v Float32) MarshalEasyJSON(w *jwriter.Writer) { + if v.Defined { + w.Float32(v.V) + } else { + w.RawString("null") + } +} + +// UnmarshalEasyJSON does JSON unmarshaling using easyjson interface. +func (v *Float32) UnmarshalEasyJSON(l *jlexer.Lexer) { + if l.IsNull() { + l.Skip() + *v = Float32{} + } else { + v.V = l.Float32() + v.Defined = true + } +} + +// MarshalJSON implements a standard json marshaler interface. +func (v Float32) MarshalJSON() ([]byte, error) { + w := jwriter.Writer{} + v.MarshalEasyJSON(&w) + return w.Buffer.BuildBytes(), w.Error +} + +// UnmarshalJSON implements a standard json unmarshaler interface. +func (v *Float32) UnmarshalJSON(data []byte) error { + l := jlexer.Lexer{Data: data} + v.UnmarshalEasyJSON(&l) + return l.Error() +} + +// IsDefined returns whether the value is defined, a function is required so that it can +// be used in an interface. +func (v Float32) IsDefined() bool { + return v.Defined +} + +// String implements a stringer interface using fmt.Sprint for the value. +func (v Float32) String() string { + if !v.Defined { + return "<undefined>" + } + return fmt.Sprint(v.V) +} diff --git a/vendor/github.com/mailru/easyjson/opt/gotemplate_Float64.go b/vendor/github.com/mailru/easyjson/opt/gotemplate_Float64.go new file mode 100644 index 000000000..75ae72757 --- /dev/null +++ b/vendor/github.com/mailru/easyjson/opt/gotemplate_Float64.go @@ -0,0 +1,79 @@ +// generated by gotemplate + +package opt + +import ( + "fmt" + + "github.com/mailru/easyjson/jlexer" + "github.com/mailru/easyjson/jwriter" +) + +// template type Optional(A) + +// A 'gotemplate'-based type for providing optional semantics without using pointers. +type Float64 struct { + V float64 + Defined bool +} + +// Creates an optional type with a given value. +func OFloat64(v float64) Float64 { + return Float64{V: v, Defined: true} +} + +// Get returns the value or given default in the case the value is undefined. +func (v Float64) Get(deflt float64) float64 { + if !v.Defined { + return deflt + } + return v.V +} + +// MarshalEasyJSON does JSON marshaling using easyjson interface. +func (v Float64) MarshalEasyJSON(w *jwriter.Writer) { + if v.Defined { + w.Float64(v.V) + } else { + w.RawString("null") + } +} + +// UnmarshalEasyJSON does JSON unmarshaling using easyjson interface. +func (v *Float64) UnmarshalEasyJSON(l *jlexer.Lexer) { + if l.IsNull() { + l.Skip() + *v = Float64{} + } else { + v.V = l.Float64() + v.Defined = true + } +} + +// MarshalJSON implements a standard json marshaler interface. +func (v Float64) MarshalJSON() ([]byte, error) { + w := jwriter.Writer{} + v.MarshalEasyJSON(&w) + return w.Buffer.BuildBytes(), w.Error +} + +// UnmarshalJSON implements a standard json unmarshaler interface. +func (v *Float64) UnmarshalJSON(data []byte) error { + l := jlexer.Lexer{Data: data} + v.UnmarshalEasyJSON(&l) + return l.Error() +} + +// IsDefined returns whether the value is defined, a function is required so that it can +// be used in an interface. +func (v Float64) IsDefined() bool { + return v.Defined +} + +// String implements a stringer interface using fmt.Sprint for the value. +func (v Float64) String() string { + if !v.Defined { + return "<undefined>" + } + return fmt.Sprint(v.V) +} diff --git a/vendor/github.com/mailru/easyjson/opt/gotemplate_Int.go b/vendor/github.com/mailru/easyjson/opt/gotemplate_Int.go new file mode 100644 index 000000000..469742fee --- /dev/null +++ b/vendor/github.com/mailru/easyjson/opt/gotemplate_Int.go @@ -0,0 +1,79 @@ +// generated by gotemplate + +package opt + +import ( + "fmt" + + "github.com/mailru/easyjson/jlexer" + "github.com/mailru/easyjson/jwriter" +) + +// template type Optional(A) + +// A 'gotemplate'-based type for providing optional semantics without using pointers. +type Int struct { + V int + Defined bool +} + +// Creates an optional type with a given value. +func OInt(v int) Int { + return Int{V: v, Defined: true} +} + +// Get returns the value or given default in the case the value is undefined. +func (v Int) Get(deflt int) int { + if !v.Defined { + return deflt + } + return v.V +} + +// MarshalEasyJSON does JSON marshaling using easyjson interface. +func (v Int) MarshalEasyJSON(w *jwriter.Writer) { + if v.Defined { + w.Int(v.V) + } else { + w.RawString("null") + } +} + +// UnmarshalEasyJSON does JSON unmarshaling using easyjson interface. +func (v *Int) UnmarshalEasyJSON(l *jlexer.Lexer) { + if l.IsNull() { + l.Skip() + *v = Int{} + } else { + v.V = l.Int() + v.Defined = true + } +} + +// MarshalJSON implements a standard json marshaler interface. +func (v Int) MarshalJSON() ([]byte, error) { + w := jwriter.Writer{} + v.MarshalEasyJSON(&w) + return w.Buffer.BuildBytes(), w.Error +} + +// UnmarshalJSON implements a standard json unmarshaler interface. +func (v *Int) UnmarshalJSON(data []byte) error { + l := jlexer.Lexer{Data: data} + v.UnmarshalEasyJSON(&l) + return l.Error() +} + +// IsDefined returns whether the value is defined, a function is required so that it can +// be used in an interface. +func (v Int) IsDefined() bool { + return v.Defined +} + +// String implements a stringer interface using fmt.Sprint for the value. +func (v Int) String() string { + if !v.Defined { + return "<undefined>" + } + return fmt.Sprint(v.V) +} diff --git a/vendor/github.com/mailru/easyjson/opt/gotemplate_Int16.go b/vendor/github.com/mailru/easyjson/opt/gotemplate_Int16.go new file mode 100644 index 000000000..b7723e241 --- /dev/null +++ b/vendor/github.com/mailru/easyjson/opt/gotemplate_Int16.go @@ -0,0 +1,79 @@ +// generated by gotemplate + +package opt + +import ( + "fmt" + + "github.com/mailru/easyjson/jlexer" + "github.com/mailru/easyjson/jwriter" +) + +// template type Optional(A) + +// A 'gotemplate'-based type for providing optional semantics without using pointers. +type Int16 struct { + V int16 + Defined bool +} + +// Creates an optional type with a given value. +func OInt16(v int16) Int16 { + return Int16{V: v, Defined: true} +} + +// Get returns the value or given default in the case the value is undefined. +func (v Int16) Get(deflt int16) int16 { + if !v.Defined { + return deflt + } + return v.V +} + +// MarshalEasyJSON does JSON marshaling using easyjson interface. +func (v Int16) MarshalEasyJSON(w *jwriter.Writer) { + if v.Defined { + w.Int16(v.V) + } else { + w.RawString("null") + } +} + +// UnmarshalEasyJSON does JSON unmarshaling using easyjson interface. +func (v *Int16) UnmarshalEasyJSON(l *jlexer.Lexer) { + if l.IsNull() { + l.Skip() + *v = Int16{} + } else { + v.V = l.Int16() + v.Defined = true + } +} + +// MarshalJSON implements a standard json marshaler interface. +func (v Int16) MarshalJSON() ([]byte, error) { + w := jwriter.Writer{} + v.MarshalEasyJSON(&w) + return w.Buffer.BuildBytes(), w.Error +} + +// UnmarshalJSON implements a standard json unmarshaler interface. +func (v *Int16) UnmarshalJSON(data []byte) error { + l := jlexer.Lexer{Data: data} + v.UnmarshalEasyJSON(&l) + return l.Error() +} + +// IsDefined returns whether the value is defined, a function is required so that it can +// be used in an interface. +func (v Int16) IsDefined() bool { + return v.Defined +} + +// String implements a stringer interface using fmt.Sprint for the value. +func (v Int16) String() string { + if !v.Defined { + return "<undefined>" + } + return fmt.Sprint(v.V) +} diff --git a/vendor/github.com/mailru/easyjson/opt/gotemplate_Int32.go b/vendor/github.com/mailru/easyjson/opt/gotemplate_Int32.go new file mode 100644 index 000000000..7c7637a38 --- /dev/null +++ b/vendor/github.com/mailru/easyjson/opt/gotemplate_Int32.go @@ -0,0 +1,79 @@ +// generated by gotemplate + +package opt + +import ( + "fmt" + + "github.com/mailru/easyjson/jlexer" + "github.com/mailru/easyjson/jwriter" +) + +// template type Optional(A) + +// A 'gotemplate'-based type for providing optional semantics without using pointers. +type Int32 struct { + V int32 + Defined bool +} + +// Creates an optional type with a given value. +func OInt32(v int32) Int32 { + return Int32{V: v, Defined: true} +} + +// Get returns the value or given default in the case the value is undefined. +func (v Int32) Get(deflt int32) int32 { + if !v.Defined { + return deflt + } + return v.V +} + +// MarshalEasyJSON does JSON marshaling using easyjson interface. +func (v Int32) MarshalEasyJSON(w *jwriter.Writer) { + if v.Defined { + w.Int32(v.V) + } else { + w.RawString("null") + } +} + +// UnmarshalEasyJSON does JSON unmarshaling using easyjson interface. +func (v *Int32) UnmarshalEasyJSON(l *jlexer.Lexer) { + if l.IsNull() { + l.Skip() + *v = Int32{} + } else { + v.V = l.Int32() + v.Defined = true + } +} + +// MarshalJSON implements a standard json marshaler interface. +func (v Int32) MarshalJSON() ([]byte, error) { + w := jwriter.Writer{} + v.MarshalEasyJSON(&w) + return w.Buffer.BuildBytes(), w.Error +} + +// UnmarshalJSON implements a standard json unmarshaler interface. +func (v *Int32) UnmarshalJSON(data []byte) error { + l := jlexer.Lexer{Data: data} + v.UnmarshalEasyJSON(&l) + return l.Error() +} + +// IsDefined returns whether the value is defined, a function is required so that it can +// be used in an interface. +func (v Int32) IsDefined() bool { + return v.Defined +} + +// String implements a stringer interface using fmt.Sprint for the value. +func (v Int32) String() string { + if !v.Defined { + return "<undefined>" + } + return fmt.Sprint(v.V) +} diff --git a/vendor/github.com/mailru/easyjson/opt/gotemplate_Int64.go b/vendor/github.com/mailru/easyjson/opt/gotemplate_Int64.go new file mode 100644 index 000000000..e6ea6dc41 --- /dev/null +++ b/vendor/github.com/mailru/easyjson/opt/gotemplate_Int64.go @@ -0,0 +1,79 @@ +// generated by gotemplate + +package opt + +import ( + "fmt" + + "github.com/mailru/easyjson/jlexer" + "github.com/mailru/easyjson/jwriter" +) + +// template type Optional(A) + +// A 'gotemplate'-based type for providing optional semantics without using pointers. +type Int64 struct { + V int64 + Defined bool +} + +// Creates an optional type with a given value. +func OInt64(v int64) Int64 { + return Int64{V: v, Defined: true} +} + +// Get returns the value or given default in the case the value is undefined. +func (v Int64) Get(deflt int64) int64 { + if !v.Defined { + return deflt + } + return v.V +} + +// MarshalEasyJSON does JSON marshaling using easyjson interface. +func (v Int64) MarshalEasyJSON(w *jwriter.Writer) { + if v.Defined { + w.Int64(v.V) + } else { + w.RawString("null") + } +} + +// UnmarshalEasyJSON does JSON unmarshaling using easyjson interface. +func (v *Int64) UnmarshalEasyJSON(l *jlexer.Lexer) { + if l.IsNull() { + l.Skip() + *v = Int64{} + } else { + v.V = l.Int64() + v.Defined = true + } +} + +// MarshalJSON implements a standard json marshaler interface. +func (v Int64) MarshalJSON() ([]byte, error) { + w := jwriter.Writer{} + v.MarshalEasyJSON(&w) + return w.Buffer.BuildBytes(), w.Error +} + +// UnmarshalJSON implements a standard json unmarshaler interface. +func (v *Int64) UnmarshalJSON(data []byte) error { + l := jlexer.Lexer{Data: data} + v.UnmarshalEasyJSON(&l) + return l.Error() +} + +// IsDefined returns whether the value is defined, a function is required so that it can +// be used in an interface. +func (v Int64) IsDefined() bool { + return v.Defined +} + +// String implements a stringer interface using fmt.Sprint for the value. +func (v Int64) String() string { + if !v.Defined { + return "<undefined>" + } + return fmt.Sprint(v.V) +} diff --git a/vendor/github.com/mailru/easyjson/opt/gotemplate_Int8.go b/vendor/github.com/mailru/easyjson/opt/gotemplate_Int8.go new file mode 100644 index 000000000..ddc666580 --- /dev/null +++ b/vendor/github.com/mailru/easyjson/opt/gotemplate_Int8.go @@ -0,0 +1,79 @@ +// generated by gotemplate + +package opt + +import ( + "fmt" + + "github.com/mailru/easyjson/jlexer" + "github.com/mailru/easyjson/jwriter" +) + +// template type Optional(A) + +// A 'gotemplate'-based type for providing optional semantics without using pointers. +type Int8 struct { + V int8 + Defined bool +} + +// Creates an optional type with a given value. +func OInt8(v int8) Int8 { + return Int8{V: v, Defined: true} +} + +// Get returns the value or given default in the case the value is undefined. +func (v Int8) Get(deflt int8) int8 { + if !v.Defined { + return deflt + } + return v.V +} + +// MarshalEasyJSON does JSON marshaling using easyjson interface. +func (v Int8) MarshalEasyJSON(w *jwriter.Writer) { + if v.Defined { + w.Int8(v.V) + } else { + w.RawString("null") + } +} + +// UnmarshalEasyJSON does JSON unmarshaling using easyjson interface. +func (v *Int8) UnmarshalEasyJSON(l *jlexer.Lexer) { + if l.IsNull() { + l.Skip() + *v = Int8{} + } else { + v.V = l.Int8() + v.Defined = true + } +} + +// MarshalJSON implements a standard json marshaler interface. +func (v Int8) MarshalJSON() ([]byte, error) { + w := jwriter.Writer{} + v.MarshalEasyJSON(&w) + return w.Buffer.BuildBytes(), w.Error +} + +// UnmarshalJSON implements a standard json unmarshaler interface. +func (v *Int8) UnmarshalJSON(data []byte) error { + l := jlexer.Lexer{Data: data} + v.UnmarshalEasyJSON(&l) + return l.Error() +} + +// IsDefined returns whether the value is defined, a function is required so that it can +// be used in an interface. +func (v Int8) IsDefined() bool { + return v.Defined +} + +// String implements a stringer interface using fmt.Sprint for the value. +func (v Int8) String() string { + if !v.Defined { + return "<undefined>" + } + return fmt.Sprint(v.V) +} diff --git a/vendor/github.com/mailru/easyjson/opt/gotemplate_String.go b/vendor/github.com/mailru/easyjson/opt/gotemplate_String.go new file mode 100644 index 000000000..11c90b4ed --- /dev/null +++ b/vendor/github.com/mailru/easyjson/opt/gotemplate_String.go @@ -0,0 +1,79 @@ +// generated by gotemplate + +package opt + +import ( + "fmt" + + "github.com/mailru/easyjson/jlexer" + "github.com/mailru/easyjson/jwriter" +) + +// template type Optional(A) + +// A 'gotemplate'-based type for providing optional semantics without using pointers. +type String struct { + V string + Defined bool +} + +// Creates an optional type with a given value. +func OString(v string) String { + return String{V: v, Defined: true} +} + +// Get returns the value or given default in the case the value is undefined. +func (v String) Get(deflt string) string { + if !v.Defined { + return deflt + } + return v.V +} + +// MarshalEasyJSON does JSON marshaling using easyjson interface. +func (v String) MarshalEasyJSON(w *jwriter.Writer) { + if v.Defined { + w.String(v.V) + } else { + w.RawString("null") + } +} + +// UnmarshalEasyJSON does JSON unmarshaling using easyjson interface. +func (v *String) UnmarshalEasyJSON(l *jlexer.Lexer) { + if l.IsNull() { + l.Skip() + *v = String{} + } else { + v.V = l.String() + v.Defined = true + } +} + +// MarshalJSON implements a standard json marshaler interface. +func (v String) MarshalJSON() ([]byte, error) { + w := jwriter.Writer{} + v.MarshalEasyJSON(&w) + return w.Buffer.BuildBytes(), w.Error +} + +// UnmarshalJSON implements a standard json unmarshaler interface. +func (v *String) UnmarshalJSON(data []byte) error { + l := jlexer.Lexer{Data: data} + v.UnmarshalEasyJSON(&l) + return l.Error() +} + +// IsDefined returns whether the value is defined, a function is required so that it can +// be used in an interface. +func (v String) IsDefined() bool { + return v.Defined +} + +// String implements a stringer interface using fmt.Sprint for the value. +func (v String) String() string { + if !v.Defined { + return "<undefined>" + } + return fmt.Sprint(v.V) +} diff --git a/vendor/github.com/mailru/easyjson/opt/gotemplate_Uint.go b/vendor/github.com/mailru/easyjson/opt/gotemplate_Uint.go new file mode 100644 index 000000000..57efd3185 --- /dev/null +++ b/vendor/github.com/mailru/easyjson/opt/gotemplate_Uint.go @@ -0,0 +1,79 @@ +// generated by gotemplate + +package opt + +import ( + "fmt" + + "github.com/mailru/easyjson/jlexer" + "github.com/mailru/easyjson/jwriter" +) + +// template type Optional(A) + +// A 'gotemplate'-based type for providing optional semantics without using pointers. +type Uint struct { + V uint + Defined bool +} + +// Creates an optional type with a given value. +func OUint(v uint) Uint { + return Uint{V: v, Defined: true} +} + +// Get returns the value or given default in the case the value is undefined. +func (v Uint) Get(deflt uint) uint { + if !v.Defined { + return deflt + } + return v.V +} + +// MarshalEasyJSON does JSON marshaling using easyjson interface. +func (v Uint) MarshalEasyJSON(w *jwriter.Writer) { + if v.Defined { + w.Uint(v.V) + } else { + w.RawString("null") + } +} + +// UnmarshalEasyJSON does JSON unmarshaling using easyjson interface. +func (v *Uint) UnmarshalEasyJSON(l *jlexer.Lexer) { + if l.IsNull() { + l.Skip() + *v = Uint{} + } else { + v.V = l.Uint() + v.Defined = true + } +} + +// MarshalJSON implements a standard json marshaler interface. +func (v Uint) MarshalJSON() ([]byte, error) { + w := jwriter.Writer{} + v.MarshalEasyJSON(&w) + return w.Buffer.BuildBytes(), w.Error +} + +// UnmarshalJSON implements a standard json unmarshaler interface. +func (v *Uint) UnmarshalJSON(data []byte) error { + l := jlexer.Lexer{Data: data} + v.UnmarshalEasyJSON(&l) + return l.Error() +} + +// IsDefined returns whether the value is defined, a function is required so that it can +// be used in an interface. +func (v Uint) IsDefined() bool { + return v.Defined +} + +// String implements a stringer interface using fmt.Sprint for the value. +func (v Uint) String() string { + if !v.Defined { + return "<undefined>" + } + return fmt.Sprint(v.V) +} diff --git a/vendor/github.com/mailru/easyjson/opt/gotemplate_Uint16.go b/vendor/github.com/mailru/easyjson/opt/gotemplate_Uint16.go new file mode 100644 index 000000000..f28e1d2ef --- /dev/null +++ b/vendor/github.com/mailru/easyjson/opt/gotemplate_Uint16.go @@ -0,0 +1,79 @@ +// generated by gotemplate + +package opt + +import ( + "fmt" + + "github.com/mailru/easyjson/jlexer" + "github.com/mailru/easyjson/jwriter" +) + +// template type Optional(A) + +// A 'gotemplate'-based type for providing optional semantics without using pointers. +type Uint16 struct { + V uint16 + Defined bool +} + +// Creates an optional type with a given value. +func OUint16(v uint16) Uint16 { + return Uint16{V: v, Defined: true} +} + +// Get returns the value or given default in the case the value is undefined. +func (v Uint16) Get(deflt uint16) uint16 { + if !v.Defined { + return deflt + } + return v.V +} + +// MarshalEasyJSON does JSON marshaling using easyjson interface. +func (v Uint16) MarshalEasyJSON(w *jwriter.Writer) { + if v.Defined { + w.Uint16(v.V) + } else { + w.RawString("null") + } +} + +// UnmarshalEasyJSON does JSON unmarshaling using easyjson interface. +func (v *Uint16) UnmarshalEasyJSON(l *jlexer.Lexer) { + if l.IsNull() { + l.Skip() + *v = Uint16{} + } else { + v.V = l.Uint16() + v.Defined = true + } +} + +// MarshalJSON implements a standard json marshaler interface. +func (v Uint16) MarshalJSON() ([]byte, error) { + w := jwriter.Writer{} + v.MarshalEasyJSON(&w) + return w.Buffer.BuildBytes(), w.Error +} + +// UnmarshalJSON implements a standard json unmarshaler interface. +func (v *Uint16) UnmarshalJSON(data []byte) error { + l := jlexer.Lexer{Data: data} + v.UnmarshalEasyJSON(&l) + return l.Error() +} + +// IsDefined returns whether the value is defined, a function is required so that it can +// be used in an interface. +func (v Uint16) IsDefined() bool { + return v.Defined +} + +// String implements a stringer interface using fmt.Sprint for the value. +func (v Uint16) String() string { + if !v.Defined { + return "<undefined>" + } + return fmt.Sprint(v.V) +} diff --git a/vendor/github.com/mailru/easyjson/opt/gotemplate_Uint32.go b/vendor/github.com/mailru/easyjson/opt/gotemplate_Uint32.go new file mode 100644 index 000000000..9fb95c0db --- /dev/null +++ b/vendor/github.com/mailru/easyjson/opt/gotemplate_Uint32.go @@ -0,0 +1,79 @@ +// generated by gotemplate + +package opt + +import ( + "fmt" + + "github.com/mailru/easyjson/jlexer" + "github.com/mailru/easyjson/jwriter" +) + +// template type Optional(A) + +// A 'gotemplate'-based type for providing optional semantics without using pointers. +type Uint32 struct { + V uint32 + Defined bool +} + +// Creates an optional type with a given value. +func OUint32(v uint32) Uint32 { + return Uint32{V: v, Defined: true} +} + +// Get returns the value or given default in the case the value is undefined. +func (v Uint32) Get(deflt uint32) uint32 { + if !v.Defined { + return deflt + } + return v.V +} + +// MarshalEasyJSON does JSON marshaling using easyjson interface. +func (v Uint32) MarshalEasyJSON(w *jwriter.Writer) { + if v.Defined { + w.Uint32(v.V) + } else { + w.RawString("null") + } +} + +// UnmarshalEasyJSON does JSON unmarshaling using easyjson interface. +func (v *Uint32) UnmarshalEasyJSON(l *jlexer.Lexer) { + if l.IsNull() { + l.Skip() + *v = Uint32{} + } else { + v.V = l.Uint32() + v.Defined = true + } +} + +// MarshalJSON implements a standard json marshaler interface. +func (v Uint32) MarshalJSON() ([]byte, error) { + w := jwriter.Writer{} + v.MarshalEasyJSON(&w) + return w.Buffer.BuildBytes(), w.Error +} + +// UnmarshalJSON implements a standard json unmarshaler interface. +func (v *Uint32) UnmarshalJSON(data []byte) error { + l := jlexer.Lexer{Data: data} + v.UnmarshalEasyJSON(&l) + return l.Error() +} + +// IsDefined returns whether the value is defined, a function is required so that it can +// be used in an interface. +func (v Uint32) IsDefined() bool { + return v.Defined +} + +// String implements a stringer interface using fmt.Sprint for the value. +func (v Uint32) String() string { + if !v.Defined { + return "<undefined>" + } + return fmt.Sprint(v.V) +} diff --git a/vendor/github.com/mailru/easyjson/opt/gotemplate_Uint64.go b/vendor/github.com/mailru/easyjson/opt/gotemplate_Uint64.go new file mode 100644 index 000000000..0e623c62d --- /dev/null +++ b/vendor/github.com/mailru/easyjson/opt/gotemplate_Uint64.go @@ -0,0 +1,79 @@ +// generated by gotemplate + +package opt + +import ( + "fmt" + + "github.com/mailru/easyjson/jlexer" + "github.com/mailru/easyjson/jwriter" +) + +// template type Optional(A) + +// A 'gotemplate'-based type for providing optional semantics without using pointers. +type Uint64 struct { + V uint64 + Defined bool +} + +// Creates an optional type with a given value. +func OUint64(v uint64) Uint64 { + return Uint64{V: v, Defined: true} +} + +// Get returns the value or given default in the case the value is undefined. +func (v Uint64) Get(deflt uint64) uint64 { + if !v.Defined { + return deflt + } + return v.V +} + +// MarshalEasyJSON does JSON marshaling using easyjson interface. +func (v Uint64) MarshalEasyJSON(w *jwriter.Writer) { + if v.Defined { + w.Uint64(v.V) + } else { + w.RawString("null") + } +} + +// UnmarshalEasyJSON does JSON unmarshaling using easyjson interface. +func (v *Uint64) UnmarshalEasyJSON(l *jlexer.Lexer) { + if l.IsNull() { + l.Skip() + *v = Uint64{} + } else { + v.V = l.Uint64() + v.Defined = true + } +} + +// MarshalJSON implements a standard json marshaler interface. +func (v Uint64) MarshalJSON() ([]byte, error) { + w := jwriter.Writer{} + v.MarshalEasyJSON(&w) + return w.Buffer.BuildBytes(), w.Error +} + +// UnmarshalJSON implements a standard json unmarshaler interface. +func (v *Uint64) UnmarshalJSON(data []byte) error { + l := jlexer.Lexer{Data: data} + v.UnmarshalEasyJSON(&l) + return l.Error() +} + +// IsDefined returns whether the value is defined, a function is required so that it can +// be used in an interface. +func (v Uint64) IsDefined() bool { + return v.Defined +} + +// String implements a stringer interface using fmt.Sprint for the value. +func (v Uint64) String() string { + if !v.Defined { + return "<undefined>" + } + return fmt.Sprint(v.V) +} diff --git a/vendor/github.com/mailru/easyjson/opt/gotemplate_Uint8.go b/vendor/github.com/mailru/easyjson/opt/gotemplate_Uint8.go new file mode 100644 index 000000000..c629e4453 --- /dev/null +++ b/vendor/github.com/mailru/easyjson/opt/gotemplate_Uint8.go @@ -0,0 +1,79 @@ +// generated by gotemplate + +package opt + +import ( + "fmt" + + "github.com/mailru/easyjson/jlexer" + "github.com/mailru/easyjson/jwriter" +) + +// template type Optional(A) + +// A 'gotemplate'-based type for providing optional semantics without using pointers. +type Uint8 struct { + V uint8 + Defined bool +} + +// Creates an optional type with a given value. +func OUint8(v uint8) Uint8 { + return Uint8{V: v, Defined: true} +} + +// Get returns the value or given default in the case the value is undefined. +func (v Uint8) Get(deflt uint8) uint8 { + if !v.Defined { + return deflt + } + return v.V +} + +// MarshalEasyJSON does JSON marshaling using easyjson interface. +func (v Uint8) MarshalEasyJSON(w *jwriter.Writer) { + if v.Defined { + w.Uint8(v.V) + } else { + w.RawString("null") + } +} + +// UnmarshalEasyJSON does JSON unmarshaling using easyjson interface. +func (v *Uint8) UnmarshalEasyJSON(l *jlexer.Lexer) { + if l.IsNull() { + l.Skip() + *v = Uint8{} + } else { + v.V = l.Uint8() + v.Defined = true + } +} + +// MarshalJSON implements a standard json marshaler interface. +func (v Uint8) MarshalJSON() ([]byte, error) { + w := jwriter.Writer{} + v.MarshalEasyJSON(&w) + return w.Buffer.BuildBytes(), w.Error +} + +// UnmarshalJSON implements a standard json unmarshaler interface. +func (v *Uint8) UnmarshalJSON(data []byte) error { + l := jlexer.Lexer{Data: data} + v.UnmarshalEasyJSON(&l) + return l.Error() +} + +// IsDefined returns whether the value is defined, a function is required so that it can +// be used in an interface. +func (v Uint8) IsDefined() bool { + return v.Defined +} + +// String implements a stringer interface using fmt.Sprint for the value. +func (v Uint8) String() string { + if !v.Defined { + return "<undefined>" + } + return fmt.Sprint(v.V) +} diff --git a/vendor/github.com/mailru/easyjson/opt/optional/opt.go b/vendor/github.com/mailru/easyjson/opt/optional/opt.go new file mode 100644 index 000000000..277dd1a3b --- /dev/null +++ b/vendor/github.com/mailru/easyjson/opt/optional/opt.go @@ -0,0 +1,80 @@ +// +build none + +package optional + +import ( + "fmt" + + "github.com/mailru/easyjson/jlexer" + "github.com/mailru/easyjson/jwriter" +) + +// template type Optional(A) +type A int + +// A 'gotemplate'-based type for providing optional semantics without using pointers. +type Optional struct { + V A + Defined bool +} + +// Creates an optional type with a given value. +func OOptional(v A) Optional { + return Optional{V: v, Defined: true} +} + +// Get returns the value or given default in the case the value is undefined. +func (v Optional) Get(deflt A) A { + if !v.Defined { + return deflt + } + return v.V +} + +// MarshalEasyJSON does JSON marshaling using easyjson interface. +func (v Optional) MarshalEasyJSON(w *jwriter.Writer) { + if v.Defined { + w.Optional(v.V) + } else { + w.RawString("null") + } +} + +// UnmarshalEasyJSON does JSON unmarshaling using easyjson interface. +func (v *Optional) UnmarshalEasyJSON(l *jlexer.Lexer) { + if l.IsNull() { + l.Skip() + *v = Optional{} + } else { + v.V = l.Optional() + v.Defined = true + } +} + +// MarshalJSON implements a standard json marshaler interface. +func (v Optional) MarshalJSON() ([]byte, error) { + w := jwriter.Writer{} + v.MarshalEasyJSON(&w) + return w.Buffer.BuildBytes(), w.Error +} + +// UnmarshalJSON implements a standard json unmarshaler interface. +func (v *Optional) UnmarshalJSON(data []byte) error { + l := jlexer.Lexer{Data: data} + v.UnmarshalEasyJSON(&l) + return l.Error() +} + +// IsDefined returns whether the value is defined, a function is required so that it can +// be used in an interface. +func (v Optional) IsDefined() bool { + return v.Defined +} + +// String implements a stringer interface using fmt.Sprint for the value. +func (v Optional) String() string { + if !v.Defined { + return "<undefined>" + } + return fmt.Sprint(v.V) +} diff --git a/vendor/github.com/mailru/easyjson/opt/opts.go b/vendor/github.com/mailru/easyjson/opt/opts.go new file mode 100644 index 000000000..3617f7f9f --- /dev/null +++ b/vendor/github.com/mailru/easyjson/opt/opts.go @@ -0,0 +1,22 @@ +package opt + +//go:generate sed -i "s/\\+build none/generated by gotemplate/" optional/opt.go +//go:generate gotemplate "github.com/mailru/easyjson/opt/optional" Int(int) +//go:generate gotemplate "github.com/mailru/easyjson/opt/optional" Uint(uint) + +//go:generate gotemplate "github.com/mailru/easyjson/opt/optional" Int8(int8) +//go:generate gotemplate "github.com/mailru/easyjson/opt/optional" Int16(int16) +//go:generate gotemplate "github.com/mailru/easyjson/opt/optional" Int32(int32) +//go:generate gotemplate "github.com/mailru/easyjson/opt/optional" Int64(int64) + +//go:generate gotemplate "github.com/mailru/easyjson/opt/optional" Uint8(uint8) +//go:generate gotemplate "github.com/mailru/easyjson/opt/optional" Uint16(uint16) +//go:generate gotemplate "github.com/mailru/easyjson/opt/optional" Uint32(uint32) +//go:generate gotemplate "github.com/mailru/easyjson/opt/optional" Uint64(uint64) + +//go:generate gotemplate "github.com/mailru/easyjson/opt/optional" Float32(float32) +//go:generate gotemplate "github.com/mailru/easyjson/opt/optional" Float64(float64) + +//go:generate gotemplate "github.com/mailru/easyjson/opt/optional" Bool(bool) +//go:generate gotemplate "github.com/mailru/easyjson/opt/optional" String(string) +//go:generate sed -i "s/generated by gotemplate/+build none/" optional/opt.go diff --git a/vendor/github.com/mailru/easyjson/parser/parser.go b/vendor/github.com/mailru/easyjson/parser/parser.go new file mode 100644 index 000000000..5bd06e946 --- /dev/null +++ b/vendor/github.com/mailru/easyjson/parser/parser.go @@ -0,0 +1,97 @@ +package parser + +import ( + "go/ast" + "go/parser" + "go/token" + "os/exec" + "strings" +) + +const structComment = "easyjson:json" + +type Parser struct { + PkgPath string + PkgName string + StructNames []string + AllStructs bool +} + +type visitor struct { + *Parser + + name string + explicit bool +} + +func (p *Parser) needType(comments string) bool { + for _, v := range strings.Split(comments, "\n") { + if strings.HasPrefix(v, structComment) { + return true + } + } + return false +} + +func (v *visitor) Visit(n ast.Node) (w ast.Visitor) { + switch n := n.(type) { + case *ast.Package: + return v + case *ast.File: + v.PkgName = n.Name.String() + return v + + case *ast.GenDecl: + v.explicit = v.needType(n.Doc.Text()) + + if !v.explicit && !v.AllStructs { + return nil + } + return v + case *ast.TypeSpec: + v.name = n.Name.String() + + // Allow to specify non-structs explicitly independent of '-all' flag. + if v.explicit { + v.StructNames = append(v.StructNames, v.name) + return nil + } + return v + case *ast.StructType: + v.StructNames = append(v.StructNames, v.name) + return nil + } + return nil +} + +func (p *Parser) Parse(fname string, isDir bool) error { + var err error + if p.PkgPath, err = getPkgPath(fname, isDir); err != nil { + return err + } + + fset := token.NewFileSet() + if isDir { + packages, err := parser.ParseDir(fset, fname, nil, parser.ParseComments) + if err != nil { + return err + } + + for _, pckg := range packages { + ast.Walk(&visitor{Parser: p}, pckg) + } + } else { + f, err := parser.ParseFile(fset, fname, nil, parser.ParseComments) + if err != nil { + return err + } + + ast.Walk(&visitor{Parser: p}, f) + } + return nil +} + +func getDefaultGoPath() (string, error) { + output, err := exec.Command("go", "env", "GOPATH").Output() + return string(output), err +} diff --git a/vendor/github.com/mailru/easyjson/parser/parser_unix.go b/vendor/github.com/mailru/easyjson/parser/parser_unix.go new file mode 100644 index 000000000..09b20a2e1 --- /dev/null +++ b/vendor/github.com/mailru/easyjson/parser/parser_unix.go @@ -0,0 +1,42 @@ +// +build !windows + +package parser + +import ( + "fmt" + "os" + "path" + "strings" +) + +func getPkgPath(fname string, isDir bool) (string, error) { + if !path.IsAbs(fname) { + pwd, err := os.Getwd() + if err != nil { + return "", err + } + fname = path.Join(pwd, fname) + } + + gopath := os.Getenv("GOPATH") + if gopath == "" { + var err error + gopath, err = getDefaultGoPath() + if err != nil { + return "", fmt.Errorf("cannot determine GOPATH: %s", err) + } + } + + for _, p := range strings.Split(os.Getenv("GOPATH"), ":") { + prefix := path.Join(p, "src") + "/" + if rel := strings.TrimPrefix(fname, prefix); rel != fname { + if !isDir { + return path.Dir(rel), nil + } else { + return path.Clean(rel), nil + } + } + } + + return "", fmt.Errorf("file '%v' is not in GOPATH", fname) +} diff --git a/vendor/github.com/mailru/easyjson/parser/parser_windows.go b/vendor/github.com/mailru/easyjson/parser/parser_windows.go new file mode 100644 index 000000000..90d3a78b5 --- /dev/null +++ b/vendor/github.com/mailru/easyjson/parser/parser_windows.go @@ -0,0 +1,49 @@ +package parser
+
+import (
+ "fmt"
+ "os"
+ "path"
+ "path/filepath"
+ "strings"
+)
+
+func normalizePath(path string) string {
+ // use lower case, as Windows file systems will almost always be case insensitive
+ return strings.ToLower(strings.Replace(path, "\\", "/", -1))
+}
+
+func getPkgPath(fname string, isDir bool) (string, error) {
+ // path.IsAbs doesn't work properly on Windows; use filepath.IsAbs instead
+ if !filepath.IsAbs(fname) {
+ pwd, err := os.Getwd()
+ if err != nil {
+ return "", err
+ }
+ fname = path.Join(pwd, fname)
+ }
+
+ fname = normalizePath(fname)
+
+ gopath := os.Getenv("GOPATH")
+ if gopath == "" {
+ var err error
+ gopath, err = getDefaultGoPath()
+ if err != nil {
+ return "", fmt.Errorf("cannot determine GOPATH: %s", err)
+ }
+ }
+
+ for _, p := range strings.Split(os.Getenv("GOPATH"), ";") {
+ prefix := path.Join(normalizePath(p), "src") + "/"
+ if rel := strings.TrimPrefix(fname, prefix); rel != fname {
+ if !isDir {
+ return path.Dir(rel), nil
+ } else {
+ return path.Clean(rel), nil
+ }
+ }
+ }
+
+ return "", fmt.Errorf("file '%v' is not in GOPATH", fname)
+}
diff --git a/vendor/github.com/mailru/easyjson/raw.go b/vendor/github.com/mailru/easyjson/raw.go new file mode 100644 index 000000000..81bd002e1 --- /dev/null +++ b/vendor/github.com/mailru/easyjson/raw.go @@ -0,0 +1,45 @@ +package easyjson + +import ( + "github.com/mailru/easyjson/jlexer" + "github.com/mailru/easyjson/jwriter" +) + +// RawMessage is a raw piece of JSON (number, string, bool, object, array or +// null) that is extracted without parsing and output as is during marshaling. +type RawMessage []byte + +// MarshalEasyJSON does JSON marshaling using easyjson interface. +func (v *RawMessage) MarshalEasyJSON(w *jwriter.Writer) { + if len(*v) == 0 { + w.RawString("null") + } else { + w.Raw(*v, nil) + } +} + +// UnmarshalEasyJSON does JSON unmarshaling using easyjson interface. +func (v *RawMessage) UnmarshalEasyJSON(l *jlexer.Lexer) { + *v = RawMessage(l.Raw()) +} + +// UnmarshalJSON implements encoding/json.Unmarshaler interface. +func (v *RawMessage) UnmarshalJSON(data []byte) error { + *v = data + return nil +} + +var nullBytes = []byte("null") + +// MarshalJSON implements encoding/json.Marshaler interface. +func (v RawMessage) MarshalJSON() ([]byte, error) { + if len(v) == 0 { + return nullBytes, nil + } + return v, nil +} + +// IsDefined is required for integration with omitempty easyjson logic. +func (v *RawMessage) IsDefined() bool { + return len(*v) > 0 +} diff --git a/vendor/github.com/mailru/easyjson/tests/basic_test.go b/vendor/github.com/mailru/easyjson/tests/basic_test.go new file mode 100644 index 000000000..018678402 --- /dev/null +++ b/vendor/github.com/mailru/easyjson/tests/basic_test.go @@ -0,0 +1,231 @@ +package tests + +import ( + "reflect" + "testing" + + "encoding/json" + + "github.com/mailru/easyjson" + "github.com/mailru/easyjson/jwriter" +) + +type testType interface { + json.Marshaler + json.Unmarshaler +} + +var testCases = []struct { + Decoded testType + Encoded string +}{ + {&primitiveTypesValue, primitiveTypesString}, + {&namedPrimitiveTypesValue, namedPrimitiveTypesString}, + {&structsValue, structsString}, + {&omitEmptyValue, omitEmptyString}, + {&snakeStructValue, snakeStructString}, + {&omitEmptyDefaultValue, omitEmptyDefaultString}, + {&optsValue, optsString}, + {&rawValue, rawString}, + {&stdMarshalerValue, stdMarshalerString}, + {&userMarshalerValue, userMarshalerString}, + {&unexportedStructValue, unexportedStructString}, + {&excludedFieldValue, excludedFieldString}, + {&sliceValue, sliceString}, + {&arrayValue, arrayString}, + {&mapsValue, mapsString}, + {&deepNestValue, deepNestString}, + {&IntsValue, IntsString}, + {&mapStringStringValue, mapStringStringString}, + {&namedTypeValue, namedTypeValueString}, + {&mapMyIntStringValue, mapMyIntStringValueString}, + {&mapIntStringValue, mapIntStringValueString}, + {&mapInt32StringValue, mapInt32StringValueString}, + {&mapInt64StringValue, mapInt64StringValueString}, + {&mapUintStringValue, mapUintStringValueString}, + {&mapUint32StringValue, mapUint32StringValueString}, + {&mapUint64StringValue, mapUint64StringValueString}, + {&mapUintptrStringValue, mapUintptrStringValueString}, + {&intKeyedMapStructValue, intKeyedMapStructValueString}, +} + +func TestMarshal(t *testing.T) { + for i, test := range testCases { + data, err := test.Decoded.MarshalJSON() + if err != nil { + t.Errorf("[%d, %T] MarshalJSON() error: %v", i, test.Decoded, err) + } + + got := string(data) + if got != test.Encoded { + t.Errorf("[%d, %T] MarshalJSON(): got \n%v\n\t\t want \n%v", i, test.Decoded, got, test.Encoded) + } + } +} + +func TestUnmarshal(t *testing.T) { + for i, test := range testCases { + v1 := reflect.New(reflect.TypeOf(test.Decoded).Elem()).Interface() + v := v1.(testType) + + err := v.UnmarshalJSON([]byte(test.Encoded)) + if err != nil { + t.Errorf("[%d, %T] UnmarshalJSON() error: %v", i, test.Decoded, err) + } + + if !reflect.DeepEqual(v, test.Decoded) { + t.Errorf("[%d, %T] UnmarshalJSON(): got \n%+v\n\t\t want \n%+v", i, test.Decoded, v, test.Decoded) + } + } +} + +func TestRawMessageSTD(t *testing.T) { + type T struct { + F easyjson.RawMessage + Fnil easyjson.RawMessage + } + + val := T{F: easyjson.RawMessage([]byte(`"test"`))} + str := `{"F":"test","Fnil":null}` + + data, err := json.Marshal(val) + if err != nil { + t.Errorf("json.Marshal() error: %v", err) + } + got := string(data) + if got != str { + t.Errorf("json.Marshal() = %v; want %v", got, str) + } + + wantV := T{F: easyjson.RawMessage([]byte(`"test"`)), Fnil: easyjson.RawMessage([]byte("null"))} + var gotV T + + err = json.Unmarshal([]byte(str), &gotV) + if err != nil { + t.Errorf("json.Unmarshal() error: %v", err) + } + if !reflect.DeepEqual(gotV, wantV) { + t.Errorf("json.Unmarshal() = %v; want %v", gotV, wantV) + } +} + +func TestParseNull(t *testing.T) { + var got, want SubStruct + if err := easyjson.Unmarshal([]byte("null"), &got); err != nil { + t.Errorf("Unmarshal() error: %v", err) + } + + if !reflect.DeepEqual(got, want) { + t.Errorf("Unmarshal() = %+v; want %+v", got, want) + } +} + +var testSpecialCases = []struct { + EncodedString string + Value string +}{ + {`"Username \u003cuser@example.com\u003e"`, `Username <user@example.com>`}, + {`"Username\ufffd"`, "Username\xc5"}, + {`"тестzтест"`, "тестzтест"}, + {`"тест\ufffdтест"`, "тест\xc5тест"}, + {`"绿茶"`, "绿茶"}, + {`"绿\ufffd茶"`, "绿\xc5茶"}, + {`"тест\u2028"`, "тест\xE2\x80\xA8"}, + {`"\\\r\n\t\""`, "\\\r\n\t\""}, + {`"ü"`, "ü"}, +} + +func TestSpecialCases(t *testing.T) { + for i, test := range testSpecialCases { + w := jwriter.Writer{} + w.String(test.Value) + got := string(w.Buffer.BuildBytes()) + if got != test.EncodedString { + t.Errorf("[%d] Encoded() = %+v; want %+v", i, got, test.EncodedString) + } + } +} + +func TestOverflowArray(t *testing.T) { + var a Arrays + err := easyjson.Unmarshal([]byte(arrayOverflowString), &a) + if err != nil { + t.Error(err) + } + if a != arrayValue { + t.Errorf("Unmarshal(%v) = %+v; want %+v", arrayOverflowString, a, arrayValue) + } +} + +func TestUnderflowArray(t *testing.T) { + var a Arrays + err := easyjson.Unmarshal([]byte(arrayUnderflowString), &a) + if err != nil { + t.Error(err) + } + if a != arrayUnderflowValue { + t.Errorf("Unmarshal(%v) = %+v; want %+v", arrayUnderflowString, a, arrayUnderflowValue) + } +} + +func TestEncodingFlags(t *testing.T) { + for i, test := range []struct { + Flags jwriter.Flags + In easyjson.Marshaler + Want string + }{ + {0, EncodingFlagsTestMap{}, `{"F":null}`}, + {0, EncodingFlagsTestSlice{}, `{"F":null}`}, + {jwriter.NilMapAsEmpty, EncodingFlagsTestMap{}, `{"F":{}}`}, + {jwriter.NilSliceAsEmpty, EncodingFlagsTestSlice{}, `{"F":[]}`}, + } { + w := &jwriter.Writer{Flags: test.Flags} + test.In.MarshalEasyJSON(w) + + data, err := w.BuildBytes() + if err != nil { + t.Errorf("[%v] easyjson.Marshal(%+v) error: %v", i, test.In, err) + } + + v := string(data) + if v != test.Want { + t.Errorf("[%v] easyjson.Marshal(%+v) = %v; want %v", i, test.In, v, test.Want) + } + } + +} + +func TestNestedEasyJsonMarshal(t *testing.T) { + n := map[string]*NestedEasyMarshaler{ + "Value": {}, + "Slice1": {}, + "Slice2": {}, + "Map1": {}, + "Map2": {}, + } + + ni := NestedInterfaces{ + Value: n["Value"], + Slice: []interface{}{n["Slice1"], n["Slice2"]}, + Map: map[string]interface{}{"1": n["Map1"], "2": n["Map2"]}, + } + easyjson.Marshal(ni) + + for k, v := range n { + if !v.EasilyMarshaled { + t.Errorf("Nested interface %s wasn't easily marshaled", k) + } + } +} + +func TestUnmarshalStructWithEmbeddedPtrStruct(t *testing.T) { + var s = StructWithInterface{Field2: &EmbeddedStruct{}} + var err error + err = easyjson.Unmarshal([]byte(structWithInterfaceString), &s) + if err != nil { + t.Errorf("easyjson.Unmarshal() error: %v", err) + } + if !reflect.DeepEqual(s, structWithInterfaceValueFilled) { + t.Errorf("easyjson.Unmarshal() = %#v; want %#v", s, structWithInterfaceValueFilled) + } +} diff --git a/vendor/github.com/mailru/easyjson/tests/data.go b/vendor/github.com/mailru/easyjson/tests/data.go new file mode 100644 index 000000000..145f093d6 --- /dev/null +++ b/vendor/github.com/mailru/easyjson/tests/data.go @@ -0,0 +1,759 @@ +package tests + +import ( + "fmt" + "math" + "net" + "time" + + "github.com/mailru/easyjson" + "github.com/mailru/easyjson/opt" +) + +type PrimitiveTypes struct { + String string + Bool bool + + Int int + Int8 int8 + Int16 int16 + Int32 int32 + Int64 int64 + + Uint uint + Uint8 uint8 + Uint16 uint16 + Uint32 uint32 + Uint64 uint64 + + IntString int `json:",string"` + Int8String int8 `json:",string"` + Int16String int16 `json:",string"` + Int32String int32 `json:",string"` + Int64String int64 `json:",string"` + + UintString uint `json:",string"` + Uint8String uint8 `json:",string"` + Uint16String uint16 `json:",string"` + Uint32String uint32 `json:",string"` + Uint64String uint64 `json:",string"` + + Float32 float32 + Float64 float64 + + Ptr *string + PtrNil *string +} + +var str = "bla" + +var primitiveTypesValue = PrimitiveTypes{ + String: "test", Bool: true, + + Int: math.MinInt32, + Int8: math.MinInt8, + Int16: math.MinInt16, + Int32: math.MinInt32, + Int64: math.MinInt64, + + Uint: math.MaxUint32, + Uint8: math.MaxUint8, + Uint16: math.MaxUint16, + Uint32: math.MaxUint32, + Uint64: math.MaxUint64, + + IntString: math.MinInt32, + Int8String: math.MinInt8, + Int16String: math.MinInt16, + Int32String: math.MinInt32, + Int64String: math.MinInt64, + + UintString: math.MaxUint32, + Uint8String: math.MaxUint8, + Uint16String: math.MaxUint16, + Uint32String: math.MaxUint32, + Uint64String: math.MaxUint64, + + Float32: 1.5, + Float64: math.MaxFloat64, + + Ptr: &str, +} + +var primitiveTypesString = "{" + + `"String":"test","Bool":true,` + + + `"Int":` + fmt.Sprint(math.MinInt32) + `,` + + `"Int8":` + fmt.Sprint(math.MinInt8) + `,` + + `"Int16":` + fmt.Sprint(math.MinInt16) + `,` + + `"Int32":` + fmt.Sprint(math.MinInt32) + `,` + + `"Int64":` + fmt.Sprint(int64(math.MinInt64)) + `,` + + + `"Uint":` + fmt.Sprint(uint32(math.MaxUint32)) + `,` + + `"Uint8":` + fmt.Sprint(math.MaxUint8) + `,` + + `"Uint16":` + fmt.Sprint(math.MaxUint16) + `,` + + `"Uint32":` + fmt.Sprint(uint32(math.MaxUint32)) + `,` + + `"Uint64":` + fmt.Sprint(uint64(math.MaxUint64)) + `,` + + + `"IntString":"` + fmt.Sprint(math.MinInt32) + `",` + + `"Int8String":"` + fmt.Sprint(math.MinInt8) + `",` + + `"Int16String":"` + fmt.Sprint(math.MinInt16) + `",` + + `"Int32String":"` + fmt.Sprint(math.MinInt32) + `",` + + `"Int64String":"` + fmt.Sprint(int64(math.MinInt64)) + `",` + + + `"UintString":"` + fmt.Sprint(uint32(math.MaxUint32)) + `",` + + `"Uint8String":"` + fmt.Sprint(math.MaxUint8) + `",` + + `"Uint16String":"` + fmt.Sprint(math.MaxUint16) + `",` + + `"Uint32String":"` + fmt.Sprint(uint32(math.MaxUint32)) + `",` + + `"Uint64String":"` + fmt.Sprint(uint64(math.MaxUint64)) + `",` + + + `"Float32":` + fmt.Sprint(1.5) + `,` + + `"Float64":` + fmt.Sprint(math.MaxFloat64) + `,` + + + `"Ptr":"bla",` + + `"PtrNil":null` + + + "}" + +type ( + NamedString string + NamedBool bool + + NamedInt int + NamedInt8 int8 + NamedInt16 int16 + NamedInt32 int32 + NamedInt64 int64 + + NamedUint uint + NamedUint8 uint8 + NamedUint16 uint16 + NamedUint32 uint32 + NamedUint64 uint64 + + NamedFloat32 float32 + NamedFloat64 float64 + + NamedStrPtr *string +) + +type NamedPrimitiveTypes struct { + String NamedString + Bool NamedBool + + Int NamedInt + Int8 NamedInt8 + Int16 NamedInt16 + Int32 NamedInt32 + Int64 NamedInt64 + + Uint NamedUint + Uint8 NamedUint8 + Uint16 NamedUint16 + Uint32 NamedUint32 + Uint64 NamedUint64 + + Float32 NamedFloat32 + Float64 NamedFloat64 + + Ptr NamedStrPtr + PtrNil NamedStrPtr +} + +var namedPrimitiveTypesValue = NamedPrimitiveTypes{ + String: "test", + Bool: true, + + Int: math.MinInt32, + Int8: math.MinInt8, + Int16: math.MinInt16, + Int32: math.MinInt32, + Int64: math.MinInt64, + + Uint: math.MaxUint32, + Uint8: math.MaxUint8, + Uint16: math.MaxUint16, + Uint32: math.MaxUint32, + Uint64: math.MaxUint64, + + Float32: 1.5, + Float64: math.MaxFloat64, + + Ptr: NamedStrPtr(&str), +} + +var namedPrimitiveTypesString = "{" + + `"String":"test",` + + `"Bool":true,` + + + `"Int":` + fmt.Sprint(math.MinInt32) + `,` + + `"Int8":` + fmt.Sprint(math.MinInt8) + `,` + + `"Int16":` + fmt.Sprint(math.MinInt16) + `,` + + `"Int32":` + fmt.Sprint(math.MinInt32) + `,` + + `"Int64":` + fmt.Sprint(int64(math.MinInt64)) + `,` + + + `"Uint":` + fmt.Sprint(uint32(math.MaxUint32)) + `,` + + `"Uint8":` + fmt.Sprint(math.MaxUint8) + `,` + + `"Uint16":` + fmt.Sprint(math.MaxUint16) + `,` + + `"Uint32":` + fmt.Sprint(uint32(math.MaxUint32)) + `,` + + `"Uint64":` + fmt.Sprint(uint64(math.MaxUint64)) + `,` + + + `"Float32":` + fmt.Sprint(1.5) + `,` + + `"Float64":` + fmt.Sprint(math.MaxFloat64) + `,` + + + `"Ptr":"bla",` + + `"PtrNil":null` + + "}" + +type SubStruct struct { + Value string + Value2 string + unexpored bool +} + +type SubP struct { + V string +} + +type SubStructAlias SubStruct + +type Structs struct { + SubStruct + *SubP + + Value2 int + + Sub1 SubStruct `json:"substruct"` + Sub2 *SubStruct + SubNil *SubStruct + + SubSlice []SubStruct + SubSliceNil []SubStruct + + SubPtrSlice []*SubStruct + SubPtrSliceNil []*SubStruct + + SubA1 SubStructAlias + SubA2 *SubStructAlias + + Anonymous struct { + V string + I int + } + Anonymous1 *struct { + V string + } + + AnonymousSlice []struct{ V int } + AnonymousPtrSlice []*struct{ V int } + + Slice []string + + unexported bool +} + +var structsValue = Structs{ + SubStruct: SubStruct{Value: "test"}, + SubP: &SubP{V: "subp"}, + + Value2: 5, + + Sub1: SubStruct{Value: "test1", Value2: "v"}, + Sub2: &SubStruct{Value: "test2", Value2: "v2"}, + + SubSlice: []SubStruct{ + {Value: "s1"}, + {Value: "s2"}, + }, + + SubPtrSlice: []*SubStruct{ + {Value: "p1"}, + {Value: "p2"}, + }, + + SubA1: SubStructAlias{Value: "test3", Value2: "v3"}, + SubA2: &SubStructAlias{Value: "test4", Value2: "v4"}, + + Anonymous: struct { + V string + I int + }{V: "bla", I: 5}, + + Anonymous1: &struct { + V string + }{V: "bla1"}, + + AnonymousSlice: []struct{ V int }{{1}, {2}}, + AnonymousPtrSlice: []*struct{ V int }{{3}, {4}}, + + Slice: []string{"test5", "test6"}, +} + +var structsString = "{" + + `"Value2":5,` + + + `"substruct":{"Value":"test1","Value2":"v"},` + + `"Sub2":{"Value":"test2","Value2":"v2"},` + + `"SubNil":null,` + + + `"SubSlice":[{"Value":"s1","Value2":""},{"Value":"s2","Value2":""}],` + + `"SubSliceNil":null,` + + + `"SubPtrSlice":[{"Value":"p1","Value2":""},{"Value":"p2","Value2":""}],` + + `"SubPtrSliceNil":null,` + + + `"SubA1":{"Value":"test3","Value2":"v3"},` + + `"SubA2":{"Value":"test4","Value2":"v4"},` + + + `"Anonymous":{"V":"bla","I":5},` + + `"Anonymous1":{"V":"bla1"},` + + + `"AnonymousSlice":[{"V":1},{"V":2}],` + + `"AnonymousPtrSlice":[{"V":3},{"V":4}],` + + + `"Slice":["test5","test6"],` + + + // Embedded fields go last. + `"V":"subp",` + + `"Value":"test"` + + "}" + +type OmitEmpty struct { + // NOTE: first field is empty to test comma printing. + + StrE, StrNE string `json:",omitempty"` + PtrE, PtrNE *string `json:",omitempty"` + + IntNE int `json:"intField,omitempty"` + IntE int `json:",omitempty"` + + // NOTE: omitempty has no effect on non-pointer struct fields. + SubE, SubNE SubStruct `json:",omitempty"` + SubPE, SubPNE *SubStruct `json:",omitempty"` +} + +var omitEmptyValue = OmitEmpty{ + StrNE: "str", + PtrNE: &str, + IntNE: 6, + SubNE: SubStruct{Value: "1", Value2: "2"}, + SubPNE: &SubStruct{Value: "3", Value2: "4"}, +} + +var omitEmptyString = "{" + + `"StrNE":"str",` + + `"PtrNE":"bla",` + + `"intField":6,` + + `"SubE":{"Value":"","Value2":""},` + + `"SubNE":{"Value":"1","Value2":"2"},` + + `"SubPNE":{"Value":"3","Value2":"4"}` + + "}" + +type Opts struct { + StrNull opt.String + StrEmpty opt.String + Str opt.String + StrOmitempty opt.String `json:",omitempty"` + + IntNull opt.Int + IntZero opt.Int + Int opt.Int +} + +var optsValue = Opts{ + StrEmpty: opt.OString(""), + Str: opt.OString("test"), + + IntZero: opt.OInt(0), + Int: opt.OInt(5), +} + +var optsString = `{` + + `"StrNull":null,` + + `"StrEmpty":"",` + + `"Str":"test",` + + `"IntNull":null,` + + `"IntZero":0,` + + `"Int":5` + + `}` + +type Raw struct { + Field easyjson.RawMessage + Field2 string +} + +var rawValue = Raw{ + Field: []byte(`{"a" : "b"}`), + Field2: "test", +} + +var rawString = `{` + + `"Field":{"a" : "b"},` + + `"Field2":"test"` + + `}` + +type StdMarshaler struct { + T time.Time + IP net.IP +} + +var stdMarshalerValue = StdMarshaler{ + T: time.Date(2016, 01, 02, 14, 15, 10, 0, time.UTC), + IP: net.IPv4(192, 168, 0, 1), +} +var stdMarshalerString = `{` + + `"T":"2016-01-02T14:15:10Z",` + + `"IP":"192.168.0.1"` + + `}` + +type UserMarshaler struct { + V vMarshaler + T tMarshaler +} + +type vMarshaler net.IP + +func (v vMarshaler) MarshalJSON() ([]byte, error) { + return []byte(`"0::0"`), nil +} + +func (v *vMarshaler) UnmarshalJSON([]byte) error { + *v = vMarshaler(net.IPv6zero) + return nil +} + +type tMarshaler net.IP + +func (v tMarshaler) MarshalText() ([]byte, error) { + return []byte(`[0::0]`), nil +} + +func (v *tMarshaler) UnmarshalText([]byte) error { + *v = tMarshaler(net.IPv6zero) + return nil +} + +var userMarshalerValue = UserMarshaler{ + V: vMarshaler(net.IPv6zero), + T: tMarshaler(net.IPv6zero), +} +var userMarshalerString = `{` + + `"V":"0::0",` + + `"T":"[0::0]"` + + `}` + +type unexportedStruct struct { + Value string +} + +var unexportedStructValue = unexportedStruct{"test"} +var unexportedStructString = `{"Value":"test"}` + +type ExcludedField struct { + Process bool `json:"process"` + DoNotProcess bool `json:"-"` + DoNotProcess1 bool `json:"-"` +} + +var excludedFieldValue = ExcludedField{ + Process: true, + DoNotProcess: false, + DoNotProcess1: false, +} +var excludedFieldString = `{"process":true}` + +type Slices struct { + ByteSlice []byte + EmptyByteSlice []byte + NilByteSlice []byte + IntSlice []int + EmptyIntSlice []int + NilIntSlice []int +} + +var sliceValue = Slices{ + ByteSlice: []byte("abc"), + EmptyByteSlice: []byte{}, + NilByteSlice: []byte(nil), + IntSlice: []int{1, 2, 3, 4, 5}, + EmptyIntSlice: []int{}, + NilIntSlice: []int(nil), +} + +var sliceString = `{` + + `"ByteSlice":"YWJj",` + + `"EmptyByteSlice":"",` + + `"NilByteSlice":null,` + + `"IntSlice":[1,2,3,4,5],` + + `"EmptyIntSlice":[],` + + `"NilIntSlice":null` + + `}` + +type Arrays struct { + ByteArray [3]byte + EmptyByteArray [0]byte + IntArray [5]int + EmptyIntArray [0]int +} + +var arrayValue = Arrays{ + ByteArray: [3]byte{'a', 'b', 'c'}, + EmptyByteArray: [0]byte{}, + IntArray: [5]int{1, 2, 3, 4, 5}, + EmptyIntArray: [0]int{}, +} + +var arrayString = `{` + + `"ByteArray":"YWJj",` + + `"EmptyByteArray":"",` + + `"IntArray":[1,2,3,4,5],` + + `"EmptyIntArray":[]` + + `}` + +var arrayOverflowString = `{` + + `"ByteArray":"YWJjbnNk",` + + `"EmptyByteArray":"YWJj",` + + `"IntArray":[1,2,3,4,5,6],` + + `"EmptyIntArray":[7,8]` + + `}` + +var arrayUnderflowValue = Arrays{ + ByteArray: [3]byte{'x', 0, 0}, + EmptyByteArray: [0]byte{}, + IntArray: [5]int{1, 2, 0, 0, 0}, + EmptyIntArray: [0]int{}, +} + +var arrayUnderflowString = `{` + + `"ByteArray":"eA==",` + + `"IntArray":[1,2]` + + `}` + +type Str string + +type Maps struct { + Map map[string]string + InterfaceMap map[string]interface{} + NilMap map[string]string + + CustomMap map[Str]Str +} + +var mapsValue = Maps{ + Map: map[string]string{"A": "b"}, // only one item since map iteration is randomized + InterfaceMap: map[string]interface{}{"G": float64(1)}, + + CustomMap: map[Str]Str{"c": "d"}, +} + +var mapsString = `{` + + `"Map":{"A":"b"},` + + `"InterfaceMap":{"G":1},` + + `"NilMap":null,` + + `"CustomMap":{"c":"d"}` + + `}` + +type NamedSlice []Str +type NamedMap map[Str]Str + +type DeepNest struct { + SliceMap map[Str][]Str + SliceMap1 map[Str][]Str + SliceMap2 map[Str][]Str + NamedSliceMap map[Str]NamedSlice + NamedMapMap map[Str]NamedMap + MapSlice []map[Str]Str + NamedSliceSlice []NamedSlice + NamedMapSlice []NamedMap + NamedStringSlice []NamedString +} + +var deepNestValue = DeepNest{ + SliceMap: map[Str][]Str{ + "testSliceMap": []Str{ + "0", + "1", + }, + }, + SliceMap1: map[Str][]Str{ + "testSliceMap1": []Str(nil), + }, + SliceMap2: map[Str][]Str{ + "testSliceMap2": []Str{}, + }, + NamedSliceMap: map[Str]NamedSlice{ + "testNamedSliceMap": NamedSlice{ + "2", + "3", + }, + }, + NamedMapMap: map[Str]NamedMap{ + "testNamedMapMap": NamedMap{ + "key1": "value1", + }, + }, + MapSlice: []map[Str]Str{ + map[Str]Str{ + "testMapSlice": "someValue", + }, + }, + NamedSliceSlice: []NamedSlice{ + NamedSlice{ + "someValue1", + "someValue2", + }, + NamedSlice{ + "someValue3", + "someValue4", + }, + }, + NamedMapSlice: []NamedMap{ + NamedMap{ + "key2": "value2", + }, + NamedMap{ + "key3": "value3", + }, + }, + NamedStringSlice: []NamedString{ + "value4", "value5", + }, +} + +var deepNestString = `{` + + `"SliceMap":{` + + `"testSliceMap":["0","1"]` + + `},` + + `"SliceMap1":{` + + `"testSliceMap1":null` + + `},` + + `"SliceMap2":{` + + `"testSliceMap2":[]` + + `},` + + `"NamedSliceMap":{` + + `"testNamedSliceMap":["2","3"]` + + `},` + + `"NamedMapMap":{` + + `"testNamedMapMap":{"key1":"value1"}` + + `},` + + `"MapSlice":[` + + `{"testMapSlice":"someValue"}` + + `],` + + `"NamedSliceSlice":[` + + `["someValue1","someValue2"],` + + `["someValue3","someValue4"]` + + `],` + + `"NamedMapSlice":[` + + `{"key2":"value2"},` + + `{"key3":"value3"}` + + `],` + + `"NamedStringSlice":["value4","value5"]` + + `}` + +//easyjson:json +type Ints []int + +var IntsValue = Ints{1, 2, 3, 4, 5} + +var IntsString = `[1,2,3,4,5]` + +//easyjson:json +type MapStringString map[string]string + +var mapStringStringValue = MapStringString{"a": "b"} + +var mapStringStringString = `{"a":"b"}` + +type RequiredOptionalStruct struct { + FirstName string `json:"first_name,required"` + Lastname string `json:"last_name"` +} + +//easyjson:json +type EncodingFlagsTestMap struct { + F map[string]string +} + +//easyjson:json +type EncodingFlagsTestSlice struct { + F []string +} + +type StructWithInterface struct { + Field1 int `json:"f1"` + Field2 interface{} `json:"f2"` + Field3 string `json:"f3"` +} + +type EmbeddedStruct struct { + Field1 int `json:"f1"` + Field2 string `json:"f2"` +} + +var structWithInterfaceString = `{"f1":1,"f2":{"f1":11,"f2":"22"},"f3":"3"}` +var structWithInterfaceValueFilled = StructWithInterface{1, &EmbeddedStruct{11, "22"}, "3"} + +//easyjson:json +type MapIntString map[int]string + +var mapIntStringValue = MapIntString{3: "hi"} +var mapIntStringValueString = `{"3":"hi"}` + +//easyjson:json +type MapInt32String map[int32]string + +var mapInt32StringValue = MapInt32String{-354634382: "life"} +var mapInt32StringValueString = `{"-354634382":"life"}` + +//easyjson:json +type MapInt64String map[int64]string + +var mapInt64StringValue = MapInt64String{-3546343826724305832: "life"} +var mapInt64StringValueString = `{"-3546343826724305832":"life"}` + +//easyjson:json +type MapUintString map[uint]string + +var mapUintStringValue = MapUintString{42: "life"} +var mapUintStringValueString = `{"42":"life"}` + +//easyjson:json +type MapUint32String map[uint32]string + +var mapUint32StringValue = MapUint32String{354634382: "life"} +var mapUint32StringValueString = `{"354634382":"life"}` + +//easyjson:json +type MapUint64String map[uint64]string + +var mapUint64StringValue = MapUint64String{3546343826724305832: "life"} +var mapUint64StringValueString = `{"3546343826724305832":"life"}` + +//easyjson:json +type MapUintptrString map[uintptr]string + +var mapUintptrStringValue = MapUintptrString{272679208: "obj"} +var mapUintptrStringValueString = `{"272679208":"obj"}` + +type MyInt int + +//easyjson:json +type MapMyIntString map[MyInt]string + +var mapMyIntStringValue = MapMyIntString{MyInt(42): "life"} +var mapMyIntStringValueString = `{"42":"life"}` + +//easyjson:json +type IntKeyedMapStruct struct { + Foo MapMyIntString `json:"foo"` + Bar map[int16]MapUint32String `json:"bar"` +} + +var intKeyedMapStructValue = IntKeyedMapStruct{ + Foo: mapMyIntStringValue, + Bar: map[int16]MapUint32String{32: mapUint32StringValue}, +} +var intKeyedMapStructValueString = `{` + + `"foo":{"42":"life"},` + + `"bar":{"32":{"354634382":"life"}}` + + `}` diff --git a/vendor/github.com/mailru/easyjson/tests/errors.go b/vendor/github.com/mailru/easyjson/tests/errors.go new file mode 100644 index 000000000..14360fcc2 --- /dev/null +++ b/vendor/github.com/mailru/easyjson/tests/errors.go @@ -0,0 +1,26 @@ +package tests + +//easyjson:json +type ErrorIntSlice []int + +//easyjson:json +type ErrorBoolSlice []bool + +//easyjson:json +type ErrorUintSlice []uint + +//easyjson:json +type ErrorStruct struct { + Int int `json:"int"` + String string `json:"string"` + Slice []int `json:"slice"` + IntSlice []int `json:"int_slice"` +} + +type ErrorNestedStruct struct { + ErrorStruct ErrorStruct `json:"error_struct"` + Int int `json:"int"` +} + +//easyjson:json +type ErrorIntMap map[uint32]string diff --git a/vendor/github.com/mailru/easyjson/tests/errors_test.go b/vendor/github.com/mailru/easyjson/tests/errors_test.go new file mode 100644 index 000000000..40fa33544 --- /dev/null +++ b/vendor/github.com/mailru/easyjson/tests/errors_test.go @@ -0,0 +1,285 @@ +package tests + +import ( + "testing" + + "github.com/mailru/easyjson/jlexer" +) + +func TestMultipleErrorsInt(t *testing.T) { + for i, test := range []struct { + Data []byte + Offsets []int + }{ + { + Data: []byte(`[1, 2, 3, "4", "5"]`), + Offsets: []int{10, 15}, + }, + { + Data: []byte(`[1, {"2":"3"}, 3, "4"]`), + Offsets: []int{4, 18}, + }, + { + Data: []byte(`[1, "2", "3", "4", "5", "6"]`), + Offsets: []int{4, 9, 14, 19, 24}, + }, + { + Data: []byte(`[1, 2, 3, 4, "5"]`), + Offsets: []int{13}, + }, + { + Data: []byte(`[{"1": "2"}]`), + Offsets: []int{1}, + }, + } { + l := jlexer.Lexer{ + Data: test.Data, + UseMultipleErrors: true, + } + + var v ErrorIntSlice + + v.UnmarshalEasyJSON(&l) + + errors := l.GetNonFatalErrors() + + if len(errors) != len(test.Offsets) { + t.Errorf("[%d] TestMultipleErrorsInt(): errornum: want: %d, got %d", i, len(test.Offsets), len(errors)) + return + } + + for ii, e := range errors { + if e.Offset != test.Offsets[ii] { + t.Errorf("[%d] TestMultipleErrorsInt(): offset[%d]: want %d, got %d", i, ii, test.Offsets[ii], e.Offset) + } + } + } +} + +func TestMultipleErrorsBool(t *testing.T) { + for i, test := range []struct { + Data []byte + Offsets []int + }{ + { + Data: []byte(`[true, false, true, false]`), + }, + { + Data: []byte(`["test", "value", "lol", "1"]`), + Offsets: []int{1, 9, 18, 25}, + }, + { + Data: []byte(`[true, 42, {"a":"b", "c":"d"}, false]`), + Offsets: []int{7, 11}, + }, + } { + l := jlexer.Lexer{ + Data: test.Data, + UseMultipleErrors: true, + } + + var v ErrorBoolSlice + v.UnmarshalEasyJSON(&l) + + errors := l.GetNonFatalErrors() + + if len(errors) != len(test.Offsets) { + t.Errorf("[%d] TestMultipleErrorsBool(): errornum: want: %d, got %d", i, len(test.Offsets), len(errors)) + return + } + for ii, e := range errors { + if e.Offset != test.Offsets[ii] { + t.Errorf("[%d] TestMultipleErrorsBool(): offset[%d]: want %d, got %d", i, ii, test.Offsets[ii], e.Offset) + } + } + } +} + +func TestMultipleErrorsUint(t *testing.T) { + for i, test := range []struct { + Data []byte + Offsets []int + }{ + { + Data: []byte(`[42, 42, 42]`), + }, + { + Data: []byte(`[17, "42", 32]`), + Offsets: []int{5}, + }, + { + Data: []byte(`["zz", "zz"]`), + Offsets: []int{1, 7}, + }, + { + Data: []byte(`[{}, 42]`), + Offsets: []int{1}, + }, + } { + l := jlexer.Lexer{ + Data: test.Data, + UseMultipleErrors: true, + } + + var v ErrorUintSlice + v.UnmarshalEasyJSON(&l) + + errors := l.GetNonFatalErrors() + + if len(errors) != len(test.Offsets) { + t.Errorf("[%d] TestMultipleErrorsUint(): errornum: want: %d, got %d", i, len(test.Offsets), len(errors)) + return + } + for ii, e := range errors { + if e.Offset != test.Offsets[ii] { + t.Errorf("[%d] TestMultipleErrorsUint(): offset[%d]: want %d, got %d", i, ii, test.Offsets[ii], e.Offset) + } + } + } +} + +func TestMultipleErrorsStruct(t *testing.T) { + for i, test := range []struct { + Data []byte + Offsets []int + }{ + { + Data: []byte(`{"string": "test", "slice":[42, 42, 42], "int_slice":[1, 2, 3]}`), + }, + { + Data: []byte(`{"string": {"test": "test"}, "slice":[42, 42, 42], "int_slice":["1", 2, 3]}`), + Offsets: []int{11, 64}, + }, + { + Data: []byte(`{"slice": [42, 42], "string": {"test": "test"}, "int_slice":["1", "2", 3]}`), + Offsets: []int{30, 61, 66}, + }, + { + Data: []byte(`{"string": "test", "slice": {}}`), + Offsets: []int{28}, + }, + { + Data: []byte(`{"slice":5, "string" : "test"}`), + Offsets: []int{9}, + }, + { + Data: []byte(`{"slice" : "test", "string" : "test"}`), + Offsets: []int{11}, + }, + { + Data: []byte(`{"slice": "", "string" : {}, "int":{}}`), + Offsets: []int{10, 25, 35}, + }, + } { + l := jlexer.Lexer{ + Data: test.Data, + UseMultipleErrors: true, + } + var v ErrorStruct + v.UnmarshalEasyJSON(&l) + + errors := l.GetNonFatalErrors() + + if len(errors) != len(test.Offsets) { + t.Errorf("[%d] TestMultipleErrorsStruct(): errornum: want: %d, got %d", i, len(test.Offsets), len(errors)) + return + } + for ii, e := range errors { + if e.Offset != test.Offsets[ii] { + t.Errorf("[%d] TestMultipleErrorsStruct(): offset[%d]: want %d, got %d", i, ii, test.Offsets[ii], e.Offset) + } + } + } +} + +func TestMultipleErrorsNestedStruct(t *testing.T) { + for i, test := range []struct { + Data []byte + Offsets []int + }{ + { + Data: []byte(`{"error_struct":{}}`), + }, + { + Data: []byte(`{"error_struct":5}`), + Offsets: []int{16}, + }, + { + Data: []byte(`{"error_struct":[]}`), + Offsets: []int{16}, + }, + { + Data: []byte(`{"error_struct":{"int":{}}}`), + Offsets: []int{23}, + }, + { + Data: []byte(`{"error_struct":{"int_slice":{}}, "int":4}`), + Offsets: []int{29}, + }, + { + Data: []byte(`{"error_struct":{"int_slice":["1", 2, "3"]}, "int":[]}`), + Offsets: []int{30, 38, 51}, + }, + } { + l := jlexer.Lexer{ + Data: test.Data, + UseMultipleErrors: true, + } + var v ErrorNestedStruct + v.UnmarshalEasyJSON(&l) + + errors := l.GetNonFatalErrors() + + if len(errors) != len(test.Offsets) { + t.Errorf("[%d] TestMultipleErrorsNestedStruct(): errornum: want: %d, got %d", i, len(test.Offsets), len(errors)) + return + } + for ii, e := range errors { + if e.Offset != test.Offsets[ii] { + t.Errorf("[%d] TestMultipleErrorsNestedStruct(): offset[%d]: want %d, got %d", i, ii, test.Offsets[ii], e.Offset) + } + } + } +} + +func TestMultipleErrorsIntMap(t *testing.T) { + for i, test := range []struct { + Data []byte + Offsets []int + }{ + { + Data: []byte(`{"a":"NumErr"}`), + Offsets: []int{1}, + }, + { + Data: []byte(`{"":"ErrSyntax"}`), + Offsets: []int{1}, + }, + { + Data: []byte(`{"a":"NumErr","33147483647":"ErrRange","-1":"ErrRange"}`), + Offsets: []int{1, 14, 39}, + }, + } { + l := jlexer.Lexer{ + Data: test.Data, + UseMultipleErrors: true, + } + + var v ErrorIntMap + + v.UnmarshalEasyJSON(&l) + + errors := l.GetNonFatalErrors() + + if len(errors) != len(test.Offsets) { + t.Errorf("[%d] TestMultipleErrorsInt(): errornum: want: %d, got %d", i, len(test.Offsets), len(errors)) + return + } + + for ii, e := range errors { + if e.Offset != test.Offsets[ii] { + t.Errorf("[%d] TestMultipleErrorsInt(): offset[%d]: want %d, got %d", i, ii, test.Offsets[ii], e.Offset) + } + } + } +} diff --git a/vendor/github.com/mailru/easyjson/tests/named_type.go b/vendor/github.com/mailru/easyjson/tests/named_type.go new file mode 100644 index 000000000..0ff8dfeb3 --- /dev/null +++ b/vendor/github.com/mailru/easyjson/tests/named_type.go @@ -0,0 +1,22 @@ +package tests + +//easyjson:json +type NamedType struct { + Inner struct { + // easyjson is mistakenly naming the type of this field 'tests.MyString' in the generated output + // something about a named type inside an anonmymous type is triggering this bug + Field MyString `tag:"value"` + Field2 int "tag:\"value with ` in it\"" + } +} + +type MyString string + +var namedTypeValue NamedType + +func init() { + namedTypeValue.Inner.Field = "test" + namedTypeValue.Inner.Field2 = 123 +} + +var namedTypeValueString = `{"Inner":{"Field":"test","Field2":123}}` diff --git a/vendor/github.com/mailru/easyjson/tests/nested_easy.go b/vendor/github.com/mailru/easyjson/tests/nested_easy.go new file mode 100644 index 000000000..6309a49f9 --- /dev/null +++ b/vendor/github.com/mailru/easyjson/tests/nested_easy.go @@ -0,0 +1,25 @@ +package tests + +import ( + "github.com/mailru/easyjson" + "github.com/mailru/easyjson/jwriter" +) + +//easyjson:json +type NestedInterfaces struct { + Value interface{} + Slice []interface{} + Map map[string]interface{} +} + +type NestedEasyMarshaler struct { + EasilyMarshaled bool +} + +var _ easyjson.Marshaler = &NestedEasyMarshaler{} + +func (i *NestedEasyMarshaler) MarshalEasyJSON(w *jwriter.Writer) { + // We use this method only to indicate that easyjson.Marshaler + // interface was really used while encoding. + i.EasilyMarshaled = true +}
\ No newline at end of file diff --git a/vendor/github.com/mailru/easyjson/tests/nothing.go b/vendor/github.com/mailru/easyjson/tests/nothing.go new file mode 100644 index 000000000..35334f5f5 --- /dev/null +++ b/vendor/github.com/mailru/easyjson/tests/nothing.go @@ -0,0 +1,3 @@ +package tests + +// No structs in this file diff --git a/vendor/github.com/mailru/easyjson/tests/omitempty.go b/vendor/github.com/mailru/easyjson/tests/omitempty.go new file mode 100644 index 000000000..ede5eb95a --- /dev/null +++ b/vendor/github.com/mailru/easyjson/tests/omitempty.go @@ -0,0 +1,12 @@ +package tests + +//easyjson:json +type OmitEmptyDefault struct { + Field string + Str string + Str1 string `json:"s,!omitempty"` + Str2 string `json:",!omitempty"` +} + +var omitEmptyDefaultValue = OmitEmptyDefault{Field: "test"} +var omitEmptyDefaultString = `{"Field":"test","s":"","Str2":""}` diff --git a/vendor/github.com/mailru/easyjson/tests/opt_test.go b/vendor/github.com/mailru/easyjson/tests/opt_test.go new file mode 100644 index 000000000..bdd32aa4a --- /dev/null +++ b/vendor/github.com/mailru/easyjson/tests/opt_test.go @@ -0,0 +1,70 @@ +package tests + +import ( + "math" + "reflect" + "testing" + + "encoding/json" + + "github.com/mailru/easyjson/opt" +) + +// This struct type must NOT have a generated marshaler +type OptsVanilla struct { + Int opt.Int + Uint opt.Uint + + Int8 opt.Int8 + Int16 opt.Int16 + Int32 opt.Int32 + Int64 opt.Int64 + + Uint8 opt.Uint8 + Uint16 opt.Uint16 + Uint32 opt.Uint32 + Uint64 opt.Uint64 + + Float32 opt.Float32 + Float64 opt.Float64 + + Bool opt.Bool + String opt.String +} + +var optsVanillaValue = OptsVanilla{ + Int: opt.OInt(-123), + Uint: opt.OUint(123), + + Int8: opt.OInt8(math.MaxInt8), + Int16: opt.OInt16(math.MaxInt16), + Int32: opt.OInt32(math.MaxInt32), + Int64: opt.OInt64(math.MaxInt64), + + Uint8: opt.OUint8(math.MaxUint8), + Uint16: opt.OUint16(math.MaxUint16), + Uint32: opt.OUint32(math.MaxUint32), + Uint64: opt.OUint64(math.MaxUint64), + + Float32: opt.OFloat32(math.MaxFloat32), + Float64: opt.OFloat64(math.MaxFloat64), + + Bool: opt.OBool(true), + String: opt.OString("foo"), +} + +func TestOptsVanilla(t *testing.T) { + data, err := json.Marshal(optsVanillaValue) + if err != nil { + t.Errorf("Failed to marshal vanilla opts: %v", err) + } + + var ov OptsVanilla + if err := json.Unmarshal(data, &ov); err != nil { + t.Errorf("Failed to unmarshal vanilla opts: %v", err) + } + + if !reflect.DeepEqual(optsVanillaValue, ov) { + t.Errorf("Vanilla opts unmarshal returned invalid value %+v, want %+v", ov, optsVanillaValue) + } +} diff --git a/vendor/github.com/mailru/easyjson/tests/required_test.go b/vendor/github.com/mailru/easyjson/tests/required_test.go new file mode 100644 index 000000000..8cc743d8c --- /dev/null +++ b/vendor/github.com/mailru/easyjson/tests/required_test.go @@ -0,0 +1,28 @@ +package tests + +import ( + "fmt" + "testing" +) + +func TestRequiredField(t *testing.T) { + cases := []struct{ json, errorMessage string }{ + {`{"first_name":"Foo", "last_name": "Bar"}`, ""}, + {`{"last_name":"Bar"}`, "key 'first_name' is required"}, + {"{}", "key 'first_name' is required"}, + } + + for _, tc := range cases { + var v RequiredOptionalStruct + err := v.UnmarshalJSON([]byte(tc.json)) + if tc.errorMessage == "" { + if err != nil { + t.Errorf("%s. UnmarshalJSON didn`t expect error: %v", tc.json, err) + } + } else { + if fmt.Sprintf("%v", err) != tc.errorMessage { + t.Errorf("%s. UnmarshalJSON expected error: %v. got: %v", tc.json, tc.errorMessage, err) + } + } + } +} diff --git a/vendor/github.com/mailru/easyjson/tests/snake.go b/vendor/github.com/mailru/easyjson/tests/snake.go new file mode 100644 index 000000000..9b64f8612 --- /dev/null +++ b/vendor/github.com/mailru/easyjson/tests/snake.go @@ -0,0 +1,10 @@ +package tests + +//easyjson:json +type SnakeStruct struct { + WeirdHTTPStuff bool + CustomNamedField string `json:"cUsToM"` +} + +var snakeStructValue SnakeStruct +var snakeStructString = `{"weird_http_stuff":false,"cUsToM":""}` |