Working auth and photo json endpoint
Signed-off-by: Kris Nóva <kris@nivenly.com>
This commit is contained in:
parent
ef275f97f4
commit
e4323b6047
2032 changed files with 821464 additions and 52 deletions
7
vendor/github.com/ugorji/go/codec/0_importpath.go
generated
vendored
Normal file
7
vendor/github.com/ugorji/go/codec/0_importpath.go
generated
vendored
Normal file
|
@ -0,0 +1,7 @@
|
|||
// Copyright (c) 2012-2018 Ugorji Nwoke. All rights reserved.
|
||||
// Use of this source code is governed by a MIT license found in the LICENSE file.
|
||||
|
||||
package codec // import "github.com/ugorji/go/codec"
|
||||
|
||||
// This establishes that this package must be imported as github.com/ugorji/go/codec.
|
||||
// It makes forking easier, and plays well with pre-module releases of go.
|
22
vendor/github.com/ugorji/go/codec/LICENSE
generated
vendored
Normal file
22
vendor/github.com/ugorji/go/codec/LICENSE
generated
vendored
Normal file
|
@ -0,0 +1,22 @@
|
|||
The MIT License (MIT)
|
||||
|
||||
Copyright (c) 2012-2020 Ugorji Nwoke.
|
||||
All rights reserved.
|
||||
|
||||
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.
|
283
vendor/github.com/ugorji/go/codec/README.md
generated
vendored
Normal file
283
vendor/github.com/ugorji/go/codec/README.md
generated
vendored
Normal file
|
@ -0,0 +1,283 @@
|
|||
# Package Documentation for github.com/ugorji/go/codec
|
||||
|
||||
Package codec provides a High Performance, Feature-Rich Idiomatic Go 1.4+
|
||||
codec/encoding library for binc, msgpack, cbor, json.
|
||||
|
||||
Supported Serialization formats are:
|
||||
|
||||
- msgpack: https://github.com/msgpack/msgpack
|
||||
- binc: http://github.com/ugorji/binc
|
||||
- cbor: http://cbor.io http://tools.ietf.org/html/rfc7049
|
||||
- json: http://json.org http://tools.ietf.org/html/rfc7159
|
||||
- simple:
|
||||
|
||||
This package will carefully use 'package unsafe' for performance reasons in
|
||||
specific places. You can build without unsafe use by passing the safe or
|
||||
appengine tag i.e. 'go install -tags=safe ...'.
|
||||
|
||||
This library works with both the standard `gc` and the `gccgo` compilers.
|
||||
|
||||
For detailed usage information, read the primer at
|
||||
http://ugorji.net/blog/go-codec-primer .
|
||||
|
||||
The idiomatic Go support is as seen in other encoding packages in the
|
||||
standard library (ie json, xml, gob, etc).
|
||||
|
||||
Rich Feature Set includes:
|
||||
|
||||
- Simple but extremely powerful and feature-rich API
|
||||
- Support for go 1.4 and above, while selectively using newer APIs for later releases
|
||||
- Excellent code coverage ( > 90% )
|
||||
- Very High Performance.
|
||||
Our extensive benchmarks show us outperforming Gob, Json, Bson, etc by 2-4X.
|
||||
- Careful selected use of 'unsafe' for targeted performance gains.
|
||||
- 100% safe mode supported, where 'unsafe' is not used at all.
|
||||
- Lock-free (sans mutex) concurrency for scaling to 100's of cores
|
||||
- In-place updates during decode, with option to zero value in maps and slices prior to decode
|
||||
- Coerce types where appropriate
|
||||
e.g. decode an int in the stream into a float, decode numbers from formatted strings, etc
|
||||
- Corner Cases:
|
||||
Overflows, nil maps/slices, nil values in streams are handled correctly
|
||||
- Standard field renaming via tags
|
||||
- Support for omitting empty fields during an encoding
|
||||
- Encoding from any value and decoding into pointer to any value
|
||||
(struct, slice, map, primitives, pointers, interface{}, etc)
|
||||
- Extensions to support efficient encoding/decoding of any named types
|
||||
- Support encoding.(Binary|Text)(M|Unm)arshaler interfaces
|
||||
- Support IsZero() bool to determine if a value is a zero value.
|
||||
Analogous to time.Time.IsZero() bool.
|
||||
- Decoding without a schema (into a interface{}).
|
||||
Includes Options to configure what specific map or slice type to use
|
||||
when decoding an encoded list or map into a nil interface{}
|
||||
- Mapping a non-interface type to an interface, so we can decode appropriately
|
||||
into any interface type with a correctly configured non-interface value.
|
||||
- Encode a struct as an array, and decode struct from an array in the data stream
|
||||
- Option to encode struct keys as numbers (instead of strings)
|
||||
(to support structured streams with fields encoded as numeric codes)
|
||||
- Comprehensive support for anonymous fields
|
||||
- Fast (no-reflection) encoding/decoding of common maps and slices
|
||||
- Code-generation for faster performance, supported in go 1.6+
|
||||
- Support binary (e.g. messagepack, cbor) and text (e.g. json) formats
|
||||
- Support indefinite-length formats to enable true streaming
|
||||
(for formats which support it e.g. json, cbor)
|
||||
- Support canonical encoding, where a value is ALWAYS encoded as same sequence of bytes.
|
||||
This mostly applies to maps, where iteration order is non-deterministic.
|
||||
- NIL in data stream decoded as zero value
|
||||
- Never silently skip data when decoding.
|
||||
User decides whether to return an error or silently skip data when keys or indexes
|
||||
in the data stream do not map to fields in the struct.
|
||||
- Detect and error when encoding a cyclic reference (instead of stack overflow shutdown)
|
||||
- Encode/Decode from/to chan types (for iterative streaming support)
|
||||
- Drop-in replacement for encoding/json. `json:` key in struct tag supported.
|
||||
- Provides a RPC Server and Client Codec for net/rpc communication protocol.
|
||||
- Handle unique idiosyncrasies of codecs e.g.
|
||||
- For messagepack, configure how ambiguities in handling raw bytes are resolved
|
||||
- For messagepack, provide rpc server/client codec to support
|
||||
msgpack-rpc protocol defined at:
|
||||
https://github.com/msgpack-rpc/msgpack-rpc/blob/master/spec.md
|
||||
|
||||
|
||||
## Extension Support
|
||||
|
||||
Users can register a function to handle the encoding or decoding of their
|
||||
custom types.
|
||||
|
||||
There are no restrictions on what the custom type can be. Some examples:
|
||||
|
||||
```go
|
||||
type BisSet []int
|
||||
type BitSet64 uint64
|
||||
type UUID string
|
||||
type MyStructWithUnexportedFields struct { a int; b bool; c []int; }
|
||||
type GifImage struct { ... }
|
||||
```
|
||||
|
||||
As an illustration, MyStructWithUnexportedFields would normally be encoded
|
||||
as an empty map because it has no exported fields, while UUID would be
|
||||
encoded as a string. However, with extension support, you can encode any of
|
||||
these however you like.
|
||||
|
||||
There is also seamless support provided for registering an extension (with a
|
||||
tag) but letting the encoding mechanism default to the standard way.
|
||||
|
||||
|
||||
## Custom Encoding and Decoding
|
||||
|
||||
This package maintains symmetry in the encoding and decoding halfs. We
|
||||
determine how to encode or decode by walking this decision tree
|
||||
|
||||
- is there an extension registered for the type?
|
||||
- is type a codec.Selfer?
|
||||
- is format binary, and is type a encoding.BinaryMarshaler and BinaryUnmarshaler?
|
||||
- is format specifically json, and is type a encoding/json.Marshaler and Unmarshaler?
|
||||
- is format text-based, and type an encoding.TextMarshaler and TextUnmarshaler?
|
||||
- else we use a pair of functions based on the "kind" of the type e.g. map, slice, int64, etc
|
||||
|
||||
This symmetry is important to reduce chances of issues happening because the
|
||||
encoding and decoding sides are out of sync e.g. decoded via very specific
|
||||
encoding.TextUnmarshaler but encoded via kind-specific generalized mode.
|
||||
|
||||
Consequently, if a type only defines one-half of the symmetry (e.g. it
|
||||
implements UnmarshalJSON() but not MarshalJSON() ), then that type doesn't
|
||||
satisfy the check and we will continue walking down the decision tree.
|
||||
|
||||
|
||||
## RPC
|
||||
|
||||
RPC Client and Server Codecs are implemented, so the codecs can be used with
|
||||
the standard net/rpc package.
|
||||
|
||||
|
||||
## Usage
|
||||
|
||||
The Handle is SAFE for concurrent READ, but NOT SAFE for concurrent
|
||||
modification.
|
||||
|
||||
The Encoder and Decoder are NOT safe for concurrent use.
|
||||
|
||||
Consequently, the usage model is basically:
|
||||
|
||||
- Create and initialize the Handle before any use.
|
||||
Once created, DO NOT modify it.
|
||||
- Multiple Encoders or Decoders can now use the Handle concurrently.
|
||||
They only read information off the Handle (never write).
|
||||
- However, each Encoder or Decoder MUST not be used concurrently
|
||||
- To re-use an Encoder/Decoder, call Reset(...) on it first.
|
||||
This allows you use state maintained on the Encoder/Decoder.
|
||||
|
||||
Sample usage model:
|
||||
|
||||
```go
|
||||
// create and configure Handle
|
||||
var (
|
||||
bh codec.BincHandle
|
||||
mh codec.MsgpackHandle
|
||||
ch codec.CborHandle
|
||||
)
|
||||
|
||||
mh.MapType = reflect.TypeOf(map[string]interface{}(nil))
|
||||
|
||||
// configure extensions
|
||||
// e.g. for msgpack, define functions and enable Time support for tag 1
|
||||
// mh.SetExt(reflect.TypeOf(time.Time{}), 1, myExt)
|
||||
|
||||
// create and use decoder/encoder
|
||||
var (
|
||||
r io.Reader
|
||||
w io.Writer
|
||||
b []byte
|
||||
h = &bh // or mh to use msgpack
|
||||
)
|
||||
|
||||
dec = codec.NewDecoder(r, h)
|
||||
dec = codec.NewDecoderBytes(b, h)
|
||||
err = dec.Decode(&v)
|
||||
|
||||
enc = codec.NewEncoder(w, h)
|
||||
enc = codec.NewEncoderBytes(&b, h)
|
||||
err = enc.Encode(v)
|
||||
|
||||
//RPC Server
|
||||
go func() {
|
||||
for {
|
||||
conn, err := listener.Accept()
|
||||
rpcCodec := codec.GoRpc.ServerCodec(conn, h)
|
||||
//OR rpcCodec := codec.MsgpackSpecRpc.ServerCodec(conn, h)
|
||||
rpc.ServeCodec(rpcCodec)
|
||||
}
|
||||
}()
|
||||
|
||||
//RPC Communication (client side)
|
||||
conn, err = net.Dial("tcp", "localhost:5555")
|
||||
rpcCodec := codec.GoRpc.ClientCodec(conn, h)
|
||||
//OR rpcCodec := codec.MsgpackSpecRpc.ClientCodec(conn, h)
|
||||
client := rpc.NewClientWithCodec(rpcCodec)
|
||||
```
|
||||
|
||||
|
||||
## Running Tests
|
||||
|
||||
To run tests, use the following:
|
||||
|
||||
```
|
||||
go test
|
||||
```
|
||||
|
||||
To run the full suite of tests, use the following:
|
||||
|
||||
```
|
||||
go test -tags alltests -run Suite
|
||||
```
|
||||
|
||||
You can run the tag 'safe' to run tests or build in safe mode. e.g.
|
||||
|
||||
```
|
||||
go test -tags safe -run Json
|
||||
go test -tags "alltests safe" -run Suite
|
||||
```
|
||||
|
||||
## Running Benchmarks
|
||||
|
||||
```
|
||||
cd bench
|
||||
go test -bench . -benchmem -benchtime 1s
|
||||
```
|
||||
|
||||
Please see http://github.com/ugorji/go-codec-bench .
|
||||
|
||||
|
||||
## Caveats
|
||||
|
||||
Struct fields matching the following are ignored during encoding and
|
||||
decoding
|
||||
|
||||
- struct tag value set to -
|
||||
- func, complex numbers, unsafe pointers
|
||||
- unexported and not embedded
|
||||
- unexported and embedded and not struct kind
|
||||
- unexported and embedded pointers (from go1.10)
|
||||
|
||||
Every other field in a struct will be encoded/decoded.
|
||||
|
||||
Embedded fields are encoded as if they exist in the top-level struct, with
|
||||
some caveats. See Encode documentation.
|
||||
|
||||
## Exported Package API
|
||||
|
||||
```go
|
||||
const CborStreamBytes byte = 0x5f ...
|
||||
const GenVersion = 21
|
||||
var SelfExt = &extFailWrapper{}
|
||||
var GoRpc goRpc
|
||||
var MsgpackSpecRpc msgpackSpecRpc
|
||||
func GenHelper() (g genHelper)
|
||||
type BasicHandle struct{ ... }
|
||||
type BincHandle struct{ ... }
|
||||
type BytesExt interface{ ... }
|
||||
type CborHandle struct{ ... }
|
||||
type DecodeOptions struct{ ... }
|
||||
type Decoder struct{ ... }
|
||||
func NewDecoder(r io.Reader, h Handle) *Decoder
|
||||
func NewDecoderBytes(in []byte, h Handle) *Decoder
|
||||
func NewDecoderString(s string, h Handle) *Decoder
|
||||
type EncodeOptions struct{ ... }
|
||||
type Encoder struct{ ... }
|
||||
func NewEncoder(w io.Writer, h Handle) *Encoder
|
||||
func NewEncoderBytes(out *[]byte, h Handle) *Encoder
|
||||
type Ext interface{ ... }
|
||||
type Handle interface{ ... }
|
||||
type InterfaceExt interface{ ... }
|
||||
type JsonHandle struct{ ... }
|
||||
type MapBySlice interface{ ... }
|
||||
type MissingFielder interface{ ... }
|
||||
type MsgpackHandle struct{ ... }
|
||||
type MsgpackSpecRpcMultiArgs []interface{}
|
||||
type RPCOptions struct{ ... }
|
||||
type Raw []byte
|
||||
type RawExt struct{ ... }
|
||||
type Rpc interface{ ... }
|
||||
type Selfer interface{ ... }
|
||||
type SimpleHandle struct{ ... }
|
||||
type TypeInfos struct{ ... }
|
||||
func NewTypeInfos(tags []string) *TypeInfos
|
||||
```
|
1291
vendor/github.com/ugorji/go/codec/binc.go
generated
vendored
Normal file
1291
vendor/github.com/ugorji/go/codec/binc.go
generated
vendored
Normal file
File diff suppressed because it is too large
Load diff
350
vendor/github.com/ugorji/go/codec/build.sh
generated
vendored
Normal file
350
vendor/github.com/ugorji/go/codec/build.sh
generated
vendored
Normal file
|
@ -0,0 +1,350 @@
|
|||
#!/bin/bash
|
||||
|
||||
# Run all the different permutations of all the tests and other things
|
||||
# This helps ensure that nothing gets broken.
|
||||
|
||||
_tests() {
|
||||
local vet="" # TODO: make it off
|
||||
local gover=$( ${gocmd} version | cut -f 3 -d ' ' )
|
||||
[[ $( ${gocmd} version ) == *"gccgo"* ]] && zcover=0
|
||||
case $gover in
|
||||
go1.[7-9]*|go1.1[0-9]*|go2.*|devel*) true ;;
|
||||
*) return 1
|
||||
esac
|
||||
# note that codecgen requires fastpath, so you cannot do "codecgen notfastpath"
|
||||
# we test the following permutations: fastpath/unsafe, !fastpath/!unsafe, codecgen/unsafe
|
||||
## local a=( "" "safe" "notfastpath safe" "codecgen" )
|
||||
echo "TestCodecSuite: (fastpath/unsafe), (!fastpath/!unsafe), (codecgen/unsafe)"
|
||||
local a=( "" "notfastpath safe" "codecgen" )
|
||||
local b=()
|
||||
local c=()
|
||||
for i in "${a[@]}"
|
||||
do
|
||||
local i2=${i:-default}
|
||||
[[ "$zwait" == "1" ]] && echo ">>>> TAGS: 'alltests $i'; RUN: 'TestCodecSuite'"
|
||||
[[ "$zcover" == "1" ]] && c=( -coverprofile "${i2// /-}.cov.out" )
|
||||
true &&
|
||||
${gocmd} vet -printfuncs "errorf" "$@" &&
|
||||
${gocmd} test ${zargs[*]} ${ztestargs[*]} -vet "$vet" -tags "alltests $i" -run "TestCodecSuite" "${c[@]}" "$@" &
|
||||
b+=("${i2// /-}.cov.out")
|
||||
[[ "$zwait" == "1" ]] && wait
|
||||
|
||||
# if [[ "$?" != 0 ]]; then return 1; fi
|
||||
done
|
||||
if [[ "$zextra" == "1" ]]; then
|
||||
[[ "$zwait" == "1" ]] && echo ">>>> TAGS: 'notfastpath x'; RUN: 'Test.*X$'"
|
||||
[[ "$zcover" == "1" ]] && c=( -coverprofile "x.cov.out" )
|
||||
${gocmd} test ${zargs[*]} ${ztestargs[*]} -vet "$vet" -tags "notfastpath x" -run 'Test.*X$' "${c[@]}" &
|
||||
b+=("x.cov.out")
|
||||
[[ "$zwait" == "1" ]] && wait
|
||||
fi
|
||||
wait
|
||||
# go tool cover is not supported for gccgo.
|
||||
[[ "$zcover" == "1" ]] &&
|
||||
command -v gocovmerge &&
|
||||
gocovmerge "${b[@]}" > __merge.cov.out &&
|
||||
${gocmd} tool cover -html=__merge.cov.out
|
||||
}
|
||||
|
||||
# is a generation needed?
|
||||
_ng() {
|
||||
local a="$1"
|
||||
if [[ ! -e "$a" ]]; then echo 1; return; fi
|
||||
for i in `ls -1 *.go.tmpl gen.go values_test.go`
|
||||
do
|
||||
if [[ "$a" -ot "$i" ]]; then echo 1; return; fi
|
||||
done
|
||||
}
|
||||
|
||||
_prependbt() {
|
||||
cat > ${2} <<EOF
|
||||
// +build generated
|
||||
|
||||
EOF
|
||||
cat ${1} >> ${2}
|
||||
rm -f ${1}
|
||||
}
|
||||
|
||||
# _build generates fast-path.go and gen-helper.go.
|
||||
_build() {
|
||||
if ! [[ "${zforce}" || $(_ng "fast-path.generated.go") || $(_ng "gen-helper.generated.go") || $(_ng "gen.generated.go") ]]; then return 0; fi
|
||||
|
||||
if [ "${zbak}" ]; then
|
||||
_zts=`date '+%m%d%Y_%H%M%S'`
|
||||
_gg=".generated.go"
|
||||
[ -e "gen-helper${_gg}" ] && mv gen-helper${_gg} gen-helper${_gg}__${_zts}.bak
|
||||
[ -e "fast-path${_gg}" ] && mv fast-path${_gg} fast-path${_gg}__${_zts}.bak
|
||||
[ -e "gen${_gg}" ] && mv gen${_gg} gen${_gg}__${_zts}.bak
|
||||
fi
|
||||
rm -f gen-helper.generated.go fast-path.generated.go gen.generated.go \
|
||||
*safe.generated.go *_generated_test.go *.generated_ffjson_expose.go
|
||||
|
||||
cat > gen.generated.go <<EOF
|
||||
// +build codecgen.exec
|
||||
|
||||
// Copyright (c) 2012-2020 Ugorji Nwoke. All rights reserved.
|
||||
// Use of this source code is governed by a MIT license found in the LICENSE file.
|
||||
|
||||
package codec
|
||||
|
||||
// DO NOT EDIT. THIS FILE IS AUTO-GENERATED FROM gen-dec-(map|array).go.tmpl
|
||||
|
||||
const genDecMapTmpl = \`
|
||||
EOF
|
||||
cat >> gen.generated.go < gen-dec-map.go.tmpl
|
||||
cat >> gen.generated.go <<EOF
|
||||
\`
|
||||
|
||||
const genDecListTmpl = \`
|
||||
EOF
|
||||
cat >> gen.generated.go < gen-dec-array.go.tmpl
|
||||
cat >> gen.generated.go <<EOF
|
||||
\`
|
||||
|
||||
const genEncChanTmpl = \`
|
||||
EOF
|
||||
cat >> gen.generated.go < gen-enc-chan.go.tmpl
|
||||
cat >> gen.generated.go <<EOF
|
||||
\`
|
||||
EOF
|
||||
cat > gen-from-tmpl.codec.generated.go <<EOF
|
||||
package codec
|
||||
func GenRunTmpl2Go(in, out string) { genRunTmpl2Go(in, out) }
|
||||
func GenRunSortTmpl2Go(in, out string) { genRunSortTmpl2Go(in, out) }
|
||||
EOF
|
||||
|
||||
# stub xxxRv and xxxRvSlice creation, before you create it
|
||||
cat > gen-from-tmpl.sort-slice-stubs.generated.go <<EOF
|
||||
// +build codecgen.sort_slice
|
||||
|
||||
package codec
|
||||
|
||||
import "reflect"
|
||||
import "time"
|
||||
|
||||
EOF
|
||||
|
||||
for i in string bool uint64 int64 float64 bytes time; do
|
||||
local i2=$i
|
||||
case $i in
|
||||
'time' ) i2="time.Time";;
|
||||
'bytes' ) i2="[]byte";;
|
||||
esac
|
||||
|
||||
cat >> gen-from-tmpl.sort-slice-stubs.generated.go <<EOF
|
||||
type ${i}Rv struct { v ${i2}; r reflect.Value }
|
||||
|
||||
type ${i}RvSlice []${i}Rv
|
||||
|
||||
func (${i}RvSlice) Len() int { return 0 }
|
||||
func (${i}RvSlice) Less(i, j int) bool { return false }
|
||||
func (${i}RvSlice) Swap(i, j int) {}
|
||||
|
||||
EOF
|
||||
done
|
||||
|
||||
sed -e 's+// __DO_NOT_REMOVE__NEEDED_FOR_REPLACING__IMPORT_PATH__FOR_CODEC_BENCH__+import . "github.com/ugorji/go/codec"+' \
|
||||
shared_test.go > bench/shared_test.go
|
||||
|
||||
# explicitly return 0 if this passes, else return 1
|
||||
local btags="notfastpath safe codecgen.exec"
|
||||
rm -f sort-slice.generated.go fast-path.generated.go gen-helper.generated.go mammoth_generated_test.go mammoth2_generated_test.go
|
||||
|
||||
cat > gen-from-tmpl.sort-slice.generated.go <<EOF
|
||||
// +build ignore
|
||||
|
||||
package main
|
||||
|
||||
import "${zpkg}"
|
||||
|
||||
func main() {
|
||||
codec.GenRunSortTmpl2Go("sort-slice.go.tmpl", "sort-slice.generated.go")
|
||||
}
|
||||
EOF
|
||||
|
||||
${gocmd} run -tags "$btags codecgen.sort_slice" gen-from-tmpl.sort-slice.generated.go || return 1
|
||||
rm -f gen-from-tmpl.sort-slice.generated.go
|
||||
|
||||
cat > gen-from-tmpl.generated.go <<EOF
|
||||
// +build ignore
|
||||
|
||||
package main
|
||||
|
||||
import "${zpkg}"
|
||||
|
||||
func main() {
|
||||
codec.GenRunTmpl2Go("fast-path.go.tmpl", "fast-path.generated.go")
|
||||
codec.GenRunTmpl2Go("gen-helper.go.tmpl", "gen-helper.generated.go")
|
||||
codec.GenRunTmpl2Go("mammoth-test.go.tmpl", "mammoth_generated_test.go")
|
||||
codec.GenRunTmpl2Go("mammoth2-test.go.tmpl", "mammoth2_generated_test.go")
|
||||
}
|
||||
EOF
|
||||
|
||||
${gocmd} run -tags "$btags" gen-from-tmpl.generated.go || return 1
|
||||
rm -f gen-from-tmpl.generated.go
|
||||
|
||||
rm -f gen-from-tmpl.*generated.go
|
||||
return 0
|
||||
}
|
||||
|
||||
_codegenerators() {
|
||||
local c5="_generated_test.go"
|
||||
local c7="$PWD/codecgen"
|
||||
local c8="$c7/__codecgen"
|
||||
local c9="codecgen-scratch.go"
|
||||
|
||||
if ! [[ $zforce || $(_ng "values_codecgen${c5}") ]]; then return 0; fi
|
||||
|
||||
# Note: ensure you run the codecgen for this codebase/directory i.e. ./codecgen/codecgen
|
||||
true &&
|
||||
echo "codecgen ... " &&
|
||||
if [[ $zforce || ! -f "$c8" || "$c7/gen.go" -nt "$c8" ]]; then
|
||||
echo "rebuilding codecgen ... " && ( cd codecgen && ${gocmd} build -o $c8 ${zargs[*]} . )
|
||||
fi &&
|
||||
$c8 -rt 'codecgen' -t 'codecgen generated' -o "values_codecgen${c5}" -d 19780 "$zfin" "$zfin2" &&
|
||||
cp mammoth2_generated_test.go $c9 &&
|
||||
$c8 -t 'codecgen,!notfastpath generated,!notfastpath' -o "mammoth2_codecgen${c5}" -d 19781 "mammoth2_generated_test.go" &&
|
||||
rm -f $c9 &&
|
||||
echo "generators done!"
|
||||
}
|
||||
|
||||
_prebuild() {
|
||||
echo "prebuild: zforce: $zforce"
|
||||
local d="$PWD"
|
||||
local zfin="test_values.generated.go"
|
||||
local zfin2="test_values_flex.generated.go"
|
||||
local zpkg="github.com/ugorji/go/codec"
|
||||
local returncode=1
|
||||
|
||||
# zpkg=${d##*/src/}
|
||||
# zgobase=${d%%/src/*}
|
||||
# rm -f *_generated_test.go
|
||||
rm -f codecgen-*.go &&
|
||||
_build &&
|
||||
cp $d/values_test.go $d/$zfin &&
|
||||
cp $d/values_flex_test.go $d/$zfin2 &&
|
||||
_codegenerators &&
|
||||
if [[ "$(type -t _codegenerators_external )" = "function" ]]; then _codegenerators_external ; fi &&
|
||||
if [[ $zforce ]]; then ${gocmd} install ${zargs[*]} .; fi &&
|
||||
returncode=0 &&
|
||||
echo "prebuild done successfully"
|
||||
rm -f $d/$zfin $d/$zfin2
|
||||
return $returncode
|
||||
# unset zfin zfin2 zpkg
|
||||
}
|
||||
|
||||
_make() {
|
||||
local makeforce=${zforce}
|
||||
zforce=1
|
||||
(cd codecgen && ${gocmd} install ${zargs[*]} .) && _prebuild && ${gocmd} install ${zargs[*]} .
|
||||
zforce=${makeforce}
|
||||
}
|
||||
|
||||
_clean() {
|
||||
rm -f \
|
||||
gen-from-tmpl.*generated.go \
|
||||
codecgen-*.go \
|
||||
test_values.generated.go test_values_flex.generated.go
|
||||
}
|
||||
|
||||
_release() {
|
||||
local reply
|
||||
read -p "Pre-release validation takes a few minutes and MUST be run from within GOPATH/src. Confirm y/n? " -n 1 -r reply
|
||||
echo
|
||||
if [[ ! $reply =~ ^[Yy]$ ]]; then return 1; fi
|
||||
|
||||
# expects GOROOT, GOROOT_BOOTSTRAP to have been set.
|
||||
if [[ -z "${GOROOT// }" || -z "${GOROOT_BOOTSTRAP// }" ]]; then return 1; fi
|
||||
# (cd $GOROOT && git checkout -f master && git pull && git reset --hard)
|
||||
(cd $GOROOT && git pull)
|
||||
local f=`pwd`/make.release.out
|
||||
cat > $f <<EOF
|
||||
========== `date` ===========
|
||||
EOF
|
||||
# # go 1.6 and below kept giving memory errors on Mac OS X during SDK build or go run execution,
|
||||
# # that is fine, as we only explicitly test the last 3 releases and tip (2 years).
|
||||
local makeforce=${zforce}
|
||||
zforce=1
|
||||
for i in 1.10 1.11 1.12 master
|
||||
do
|
||||
echo "*********** $i ***********" >>$f
|
||||
if [[ "$i" != "master" ]]; then i="release-branch.go$i"; fi
|
||||
(false ||
|
||||
(echo "===== BUILDING GO SDK for branch: $i ... =====" &&
|
||||
cd $GOROOT &&
|
||||
git checkout -f $i && git reset --hard && git clean -f . &&
|
||||
cd src && ./make.bash >>$f 2>&1 && sleep 1 ) ) &&
|
||||
echo "===== GO SDK BUILD DONE =====" &&
|
||||
_prebuild &&
|
||||
echo "===== PREBUILD DONE with exit: $? =====" &&
|
||||
_tests "$@"
|
||||
if [[ "$?" != 0 ]]; then return 1; fi
|
||||
done
|
||||
zforce=${makeforce}
|
||||
echo "++++++++ RELEASE TEST SUITES ALL PASSED ++++++++"
|
||||
}
|
||||
|
||||
_usage() {
|
||||
# hidden args:
|
||||
# -pf [p=prebuild (f=force)]
|
||||
|
||||
cat <<EOF
|
||||
primary usage: $0
|
||||
-[tesow m n l d] -> [t=tests (e=extra, s=short, o=cover, w=wait), m=make, n=inlining diagnostics, l=mid-stack inlining, d=race detector]
|
||||
-v -> v=verbose
|
||||
EOF
|
||||
if [[ "$(type -t _usage_run)" = "function" ]]; then _usage_run ; fi
|
||||
}
|
||||
|
||||
_main() {
|
||||
if [[ -z "$1" ]]; then _usage; return 1; fi
|
||||
local x # determines the main action to run in this build
|
||||
local zforce # force
|
||||
local zcover # generate cover profile and show in browser when done
|
||||
local zwait # run tests in sequence, not parallel ie wait for one to finish before starting another
|
||||
local zextra # means run extra (python based tests, etc) during testing
|
||||
|
||||
local ztestargs=()
|
||||
local zargs=()
|
||||
local zverbose=()
|
||||
local zbenchflags=""
|
||||
|
||||
local gocmd=${MYGOCMD:-go}
|
||||
|
||||
OPTIND=1
|
||||
while getopts ":cetmnrgpfvlyzdsowxb:" flag
|
||||
do
|
||||
case "x$flag" in
|
||||
'xo') zcover=1 ;;
|
||||
'xe') zextra=1 ;;
|
||||
'xw') zwait=1 ;;
|
||||
'xf') zforce=1 ;;
|
||||
'xs') ztestargs+=("-short") ;;
|
||||
'xv') zverbose+=(1) ;;
|
||||
'xl') zargs+=("-gcflags"); zargs+=("-l=4") ;;
|
||||
'xn') zargs+=("-gcflags"); zargs+=("-m=2") ;;
|
||||
'xd') zargs+=("-race") ;;
|
||||
'xb') x='b'; zbenchflags=${OPTARG} ;;
|
||||
x\?) _usage; return 1 ;;
|
||||
*) x=$flag ;;
|
||||
esac
|
||||
done
|
||||
shift $((OPTIND-1))
|
||||
# echo ">>>> _main: extra args: $@"
|
||||
case "x$x" in
|
||||
'xt') _tests "$@" ;;
|
||||
'xm') _make "$@" ;;
|
||||
'xr') _release "$@" ;;
|
||||
'xg') _go ;;
|
||||
'xp') _prebuild "$@" ;;
|
||||
'xc') _clean "$@" ;;
|
||||
'xx') _analyze_checks "$@" ;;
|
||||
'xy') _analyze_debug_types "$@" ;;
|
||||
'xz') _analyze_do_inlining_and_more "$@" ;;
|
||||
'xb') _bench "$@" ;;
|
||||
esac
|
||||
# unset zforce zargs zbenchflags
|
||||
}
|
||||
|
||||
[ "." = `dirname $0` ] && _main "$@"
|
||||
|
951
vendor/github.com/ugorji/go/codec/cbor.go
generated
vendored
Normal file
951
vendor/github.com/ugorji/go/codec/cbor.go
generated
vendored
Normal file
|
@ -0,0 +1,951 @@
|
|||
// Copyright (c) 2012-2020 Ugorji Nwoke. All rights reserved.
|
||||
// Use of this source code is governed by a MIT license found in the LICENSE file.
|
||||
|
||||
package codec
|
||||
|
||||
import (
|
||||
"math"
|
||||
"time"
|
||||
)
|
||||
|
||||
// major
|
||||
const (
|
||||
cborMajorUint byte = iota
|
||||
cborMajorNegInt
|
||||
cborMajorBytes
|
||||
cborMajorString
|
||||
cborMajorArray
|
||||
cborMajorMap
|
||||
cborMajorTag
|
||||
cborMajorSimpleOrFloat
|
||||
)
|
||||
|
||||
// simple
|
||||
const (
|
||||
cborBdFalse byte = 0xf4 + iota
|
||||
cborBdTrue
|
||||
cborBdNil
|
||||
cborBdUndefined
|
||||
cborBdExt
|
||||
cborBdFloat16
|
||||
cborBdFloat32
|
||||
cborBdFloat64
|
||||
)
|
||||
|
||||
// indefinite
|
||||
const (
|
||||
cborBdIndefiniteBytes byte = 0x5f
|
||||
cborBdIndefiniteString byte = 0x7f
|
||||
cborBdIndefiniteArray byte = 0x9f
|
||||
cborBdIndefiniteMap byte = 0xbf
|
||||
cborBdBreak byte = 0xff
|
||||
)
|
||||
|
||||
// These define some in-stream descriptors for
|
||||
// manual encoding e.g. when doing explicit indefinite-length
|
||||
const (
|
||||
CborStreamBytes byte = 0x5f
|
||||
CborStreamString byte = 0x7f
|
||||
CborStreamArray byte = 0x9f
|
||||
CborStreamMap byte = 0xbf
|
||||
CborStreamBreak byte = 0xff
|
||||
)
|
||||
|
||||
// base values
|
||||
const (
|
||||
cborBaseUint byte = 0x00
|
||||
cborBaseNegInt byte = 0x20
|
||||
cborBaseBytes byte = 0x40
|
||||
cborBaseString byte = 0x60
|
||||
cborBaseArray byte = 0x80
|
||||
cborBaseMap byte = 0xa0
|
||||
cborBaseTag byte = 0xc0
|
||||
cborBaseSimple byte = 0xe0
|
||||
)
|
||||
|
||||
// const (
|
||||
// cborSelfDesrTag byte = 0xd9
|
||||
// cborSelfDesrTag2 byte = 0xd9
|
||||
// cborSelfDesrTag3 byte = 0xf7
|
||||
// )
|
||||
|
||||
var (
|
||||
cbordescSimpleNames = map[byte]string{
|
||||
cborBdNil: "nil",
|
||||
cborBdFalse: "false",
|
||||
cborBdTrue: "true",
|
||||
cborBdFloat16: "float",
|
||||
cborBdFloat32: "float",
|
||||
cborBdFloat64: "float",
|
||||
cborBdBreak: "break",
|
||||
}
|
||||
cbordescIndefNames = map[byte]string{
|
||||
cborBdIndefiniteBytes: "bytes*",
|
||||
cborBdIndefiniteString: "string*",
|
||||
cborBdIndefiniteArray: "array*",
|
||||
cborBdIndefiniteMap: "map*",
|
||||
}
|
||||
cbordescMajorNames = map[byte]string{
|
||||
cborMajorUint: "(u)int",
|
||||
cborMajorNegInt: "int",
|
||||
cborMajorBytes: "bytes",
|
||||
cborMajorString: "string",
|
||||
cborMajorArray: "array",
|
||||
cborMajorMap: "map",
|
||||
cborMajorTag: "tag",
|
||||
cborMajorSimpleOrFloat: "simple",
|
||||
}
|
||||
)
|
||||
|
||||
func cbordesc(bd byte) (s string) {
|
||||
bm := bd >> 5
|
||||
if bm == cborMajorSimpleOrFloat {
|
||||
s = cbordescSimpleNames[bd]
|
||||
} else {
|
||||
s = cbordescMajorNames[bm]
|
||||
if s == "" {
|
||||
s = cbordescIndefNames[bd]
|
||||
}
|
||||
}
|
||||
if s == "" {
|
||||
s = "unknown"
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
// -------------------
|
||||
|
||||
type cborEncDriver struct {
|
||||
noBuiltInTypes
|
||||
encDriverNoopContainerWriter
|
||||
h *CborHandle
|
||||
// x [8]byte
|
||||
|
||||
e Encoder
|
||||
}
|
||||
|
||||
func (e *cborEncDriver) encoder() *Encoder {
|
||||
return &e.e
|
||||
}
|
||||
|
||||
func (e *cborEncDriver) EncodeNil() {
|
||||
e.e.encWr.writen1(cborBdNil)
|
||||
}
|
||||
|
||||
func (e *cborEncDriver) EncodeBool(b bool) {
|
||||
if b {
|
||||
e.e.encWr.writen1(cborBdTrue)
|
||||
} else {
|
||||
e.e.encWr.writen1(cborBdFalse)
|
||||
}
|
||||
}
|
||||
|
||||
func (e *cborEncDriver) EncodeFloat32(f float32) {
|
||||
b := math.Float32bits(f)
|
||||
if e.h.OptimumSize {
|
||||
if h := floatToHalfFloatBits(b); halfFloatToFloatBits(h) == b {
|
||||
e.e.encWr.writen1(cborBdFloat16)
|
||||
bigen.writeUint16(e.e.w(), h)
|
||||
return
|
||||
}
|
||||
}
|
||||
e.e.encWr.writen1(cborBdFloat32)
|
||||
bigen.writeUint32(e.e.w(), b)
|
||||
}
|
||||
|
||||
func (e *cborEncDriver) EncodeFloat64(f float64) {
|
||||
if e.h.OptimumSize {
|
||||
if f32 := float32(f); float64(f32) == f {
|
||||
e.EncodeFloat32(f32)
|
||||
return
|
||||
}
|
||||
}
|
||||
e.e.encWr.writen1(cborBdFloat64)
|
||||
bigen.writeUint64(e.e.w(), math.Float64bits(f))
|
||||
}
|
||||
|
||||
func (e *cborEncDriver) encUint(v uint64, bd byte) {
|
||||
if v <= 0x17 {
|
||||
e.e.encWr.writen1(byte(v) + bd)
|
||||
} else if v <= math.MaxUint8 {
|
||||
e.e.encWr.writen2(bd+0x18, uint8(v))
|
||||
} else if v <= math.MaxUint16 {
|
||||
e.e.encWr.writen1(bd + 0x19)
|
||||
bigen.writeUint16(e.e.w(), uint16(v))
|
||||
} else if v <= math.MaxUint32 {
|
||||
e.e.encWr.writen1(bd + 0x1a)
|
||||
bigen.writeUint32(e.e.w(), uint32(v))
|
||||
} else { // if v <= math.MaxUint64 {
|
||||
e.e.encWr.writen1(bd + 0x1b)
|
||||
bigen.writeUint64(e.e.w(), v)
|
||||
}
|
||||
}
|
||||
|
||||
func (e *cborEncDriver) EncodeInt(v int64) {
|
||||
if v < 0 {
|
||||
e.encUint(uint64(-1-v), cborBaseNegInt)
|
||||
} else {
|
||||
e.encUint(uint64(v), cborBaseUint)
|
||||
}
|
||||
}
|
||||
|
||||
func (e *cborEncDriver) EncodeUint(v uint64) {
|
||||
e.encUint(v, cborBaseUint)
|
||||
}
|
||||
|
||||
func (e *cborEncDriver) encLen(bd byte, length int) {
|
||||
e.encUint(uint64(length), bd)
|
||||
}
|
||||
|
||||
func (e *cborEncDriver) EncodeTime(t time.Time) {
|
||||
if t.IsZero() {
|
||||
e.EncodeNil()
|
||||
} else if e.h.TimeRFC3339 {
|
||||
e.encUint(0, cborBaseTag)
|
||||
e.encStringBytesS(cborBaseString, t.Format(time.RFC3339Nano))
|
||||
} else {
|
||||
e.encUint(1, cborBaseTag)
|
||||
t = t.UTC().Round(time.Microsecond)
|
||||
sec, nsec := t.Unix(), uint64(t.Nanosecond())
|
||||
if nsec == 0 {
|
||||
e.EncodeInt(sec)
|
||||
} else {
|
||||
e.EncodeFloat64(float64(sec) + float64(nsec)/1e9)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func (e *cborEncDriver) EncodeExt(rv interface{}, xtag uint64, ext Ext) {
|
||||
e.encUint(uint64(xtag), cborBaseTag)
|
||||
if ext == SelfExt {
|
||||
rv2 := baseRV(rv)
|
||||
e.e.encodeValue(rv2, e.h.fnNoExt(rvType(rv2)))
|
||||
} else if v := ext.ConvertExt(rv); v == nil {
|
||||
e.EncodeNil()
|
||||
} else {
|
||||
e.e.encode(v)
|
||||
}
|
||||
}
|
||||
|
||||
func (e *cborEncDriver) EncodeRawExt(re *RawExt) {
|
||||
e.encUint(uint64(re.Tag), cborBaseTag)
|
||||
// only encodes re.Value (never re.Data)
|
||||
if re.Value != nil {
|
||||
e.e.encode(re.Value)
|
||||
} else {
|
||||
e.EncodeNil()
|
||||
}
|
||||
}
|
||||
|
||||
func (e *cborEncDriver) WriteArrayStart(length int) {
|
||||
if e.h.IndefiniteLength {
|
||||
e.e.encWr.writen1(cborBdIndefiniteArray)
|
||||
} else {
|
||||
e.encLen(cborBaseArray, length)
|
||||
}
|
||||
}
|
||||
|
||||
func (e *cborEncDriver) WriteMapStart(length int) {
|
||||
if e.h.IndefiniteLength {
|
||||
e.e.encWr.writen1(cborBdIndefiniteMap)
|
||||
} else {
|
||||
e.encLen(cborBaseMap, length)
|
||||
}
|
||||
}
|
||||
|
||||
func (e *cborEncDriver) WriteMapEnd() {
|
||||
if e.h.IndefiniteLength {
|
||||
e.e.encWr.writen1(cborBdBreak)
|
||||
}
|
||||
}
|
||||
|
||||
func (e *cborEncDriver) WriteArrayEnd() {
|
||||
if e.h.IndefiniteLength {
|
||||
e.e.encWr.writen1(cborBdBreak)
|
||||
}
|
||||
}
|
||||
|
||||
func (e *cborEncDriver) EncodeString(v string) {
|
||||
if e.h.StringToRaw {
|
||||
e.EncodeStringBytesRaw(bytesView(v))
|
||||
return
|
||||
}
|
||||
e.encStringBytesS(cborBaseString, v)
|
||||
}
|
||||
|
||||
func (e *cborEncDriver) EncodeStringBytesRaw(v []byte) {
|
||||
if v == nil {
|
||||
e.EncodeNil()
|
||||
} else {
|
||||
e.encStringBytesS(cborBaseBytes, stringView(v))
|
||||
}
|
||||
}
|
||||
|
||||
func (e *cborEncDriver) encStringBytesS(bb byte, v string) {
|
||||
if e.h.IndefiniteLength {
|
||||
if bb == cborBaseBytes {
|
||||
e.e.encWr.writen1(cborBdIndefiniteBytes)
|
||||
} else {
|
||||
e.e.encWr.writen1(cborBdIndefiniteString)
|
||||
}
|
||||
var vlen uint = uint(len(v))
|
||||
blen := vlen / 4
|
||||
if blen == 0 {
|
||||
blen = 64
|
||||
} else if blen > 1024 {
|
||||
blen = 1024
|
||||
}
|
||||
for i := uint(0); i < vlen; {
|
||||
var v2 string
|
||||
i2 := i + blen
|
||||
if i2 >= i && i2 < vlen {
|
||||
v2 = v[i:i2]
|
||||
} else {
|
||||
v2 = v[i:]
|
||||
}
|
||||
e.encLen(bb, len(v2))
|
||||
e.e.encWr.writestr(v2)
|
||||
i = i2
|
||||
}
|
||||
e.e.encWr.writen1(cborBdBreak)
|
||||
} else {
|
||||
e.encLen(bb, len(v))
|
||||
e.e.encWr.writestr(v)
|
||||
}
|
||||
}
|
||||
|
||||
// ----------------------
|
||||
|
||||
type cborDecDriver struct {
|
||||
decDriverNoopContainerReader
|
||||
h *CborHandle
|
||||
bdRead bool
|
||||
bd byte
|
||||
st bool // skip tags
|
||||
_ bool // found nil
|
||||
noBuiltInTypes
|
||||
d Decoder
|
||||
}
|
||||
|
||||
func (d *cborDecDriver) decoder() *Decoder {
|
||||
return &d.d
|
||||
}
|
||||
|
||||
func (d *cborDecDriver) readNextBd() {
|
||||
d.bd = d.d.decRd.readn1()
|
||||
d.bdRead = true
|
||||
}
|
||||
|
||||
func (d *cborDecDriver) advanceNil() (null bool) {
|
||||
if !d.bdRead {
|
||||
d.readNextBd()
|
||||
}
|
||||
if d.bd == cborBdNil || d.bd == cborBdUndefined {
|
||||
d.bdRead = false
|
||||
return true // null = true
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func (d *cborDecDriver) TryNil() bool {
|
||||
return d.advanceNil()
|
||||
}
|
||||
|
||||
// skipTags is called to skip any tags in the stream.
|
||||
//
|
||||
// Since any value can be tagged, then we should call skipTags
|
||||
// before any value is decoded.
|
||||
//
|
||||
// By definition, skipTags should not be called before
|
||||
// checking for break, or nil or undefined.
|
||||
func (d *cborDecDriver) skipTags() {
|
||||
for d.bd>>5 == cborMajorTag {
|
||||
d.decUint()
|
||||
d.bd = d.d.decRd.readn1()
|
||||
}
|
||||
}
|
||||
|
||||
func (d *cborDecDriver) ContainerType() (vt valueType) {
|
||||
if !d.bdRead {
|
||||
d.readNextBd()
|
||||
}
|
||||
if d.st {
|
||||
d.skipTags()
|
||||
}
|
||||
if d.bd == cborBdNil {
|
||||
d.bdRead = false // always consume nil after seeing it in container type
|
||||
return valueTypeNil
|
||||
}
|
||||
major := d.bd >> 5
|
||||
if major == cborMajorBytes {
|
||||
return valueTypeBytes
|
||||
} else if major == cborMajorString {
|
||||
return valueTypeString
|
||||
} else if major == cborMajorArray {
|
||||
return valueTypeArray
|
||||
} else if major == cborMajorMap {
|
||||
return valueTypeMap
|
||||
}
|
||||
return valueTypeUnset
|
||||
}
|
||||
|
||||
func (d *cborDecDriver) CheckBreak() (v bool) {
|
||||
if !d.bdRead {
|
||||
d.readNextBd()
|
||||
}
|
||||
if d.bd == cborBdBreak {
|
||||
d.bdRead = false
|
||||
v = true
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func (d *cborDecDriver) decUint() (ui uint64) {
|
||||
v := d.bd & 0x1f
|
||||
if v <= 0x17 {
|
||||
ui = uint64(v)
|
||||
} else if v == 0x18 {
|
||||
ui = uint64(d.d.decRd.readn1())
|
||||
} else if v == 0x19 {
|
||||
ui = uint64(bigen.Uint16(d.d.decRd.readn2()))
|
||||
} else if v == 0x1a {
|
||||
ui = uint64(bigen.Uint32(d.d.decRd.readn4()))
|
||||
} else if v == 0x1b {
|
||||
ui = uint64(bigen.Uint64(d.d.decRd.readn8()))
|
||||
} else {
|
||||
d.d.errorf("invalid descriptor decoding uint: %x/%s", d.bd, cbordesc(d.bd))
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func (d *cborDecDriver) decCheckInteger() (neg bool) {
|
||||
if d.st {
|
||||
d.skipTags()
|
||||
}
|
||||
major := d.bd >> 5
|
||||
if major == cborMajorUint {
|
||||
} else if major == cborMajorNegInt {
|
||||
neg = true
|
||||
} else {
|
||||
d.d.errorf("invalid integer %x (%s); got major %v, expected %v or %v",
|
||||
d.bd, cbordesc(d.bd), major, cborMajorUint, cborMajorNegInt)
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func cborDecInt64(ui uint64, neg bool) (i int64) {
|
||||
if neg {
|
||||
i = -(chkOvf.SignedIntV(ui + 1))
|
||||
} else {
|
||||
i = chkOvf.SignedIntV(ui)
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func (d *cborDecDriver) decLen() int {
|
||||
return int(d.decUint())
|
||||
}
|
||||
|
||||
func (d *cborDecDriver) decAppendIndefiniteBytes(bs []byte) []byte {
|
||||
d.bdRead = false
|
||||
for !d.CheckBreak() {
|
||||
if major := d.bd >> 5; major != cborMajorBytes && major != cborMajorString {
|
||||
d.d.errorf("invalid indefinite string/bytes %x (%s); got major %v, expected %v or %v",
|
||||
d.bd, cbordesc(d.bd), major, cborMajorBytes, cborMajorString)
|
||||
}
|
||||
n := uint(d.decLen())
|
||||
oldLen := uint(len(bs))
|
||||
newLen := oldLen + n
|
||||
if newLen > uint(cap(bs)) {
|
||||
bs2 := make([]byte, newLen, 2*uint(cap(bs))+n)
|
||||
copy(bs2, bs)
|
||||
bs = bs2
|
||||
} else {
|
||||
bs = bs[:newLen]
|
||||
}
|
||||
d.d.decRd.readb(bs[oldLen:newLen])
|
||||
d.bdRead = false
|
||||
}
|
||||
d.bdRead = false
|
||||
return bs
|
||||
}
|
||||
|
||||
func (d *cborDecDriver) DecodeInt64() (i int64) {
|
||||
if d.advanceNil() {
|
||||
return
|
||||
}
|
||||
neg := d.decCheckInteger()
|
||||
ui := d.decUint()
|
||||
d.bdRead = false
|
||||
return cborDecInt64(ui, neg)
|
||||
}
|
||||
|
||||
func (d *cborDecDriver) DecodeUint64() (ui uint64) {
|
||||
if d.advanceNil() {
|
||||
return
|
||||
}
|
||||
if d.decCheckInteger() {
|
||||
d.d.errorf("cannot assign negative signed value to unsigned type")
|
||||
}
|
||||
ui = d.decUint()
|
||||
d.bdRead = false
|
||||
return
|
||||
}
|
||||
|
||||
func (d *cborDecDriver) DecodeFloat64() (f float64) {
|
||||
if d.advanceNil() {
|
||||
return
|
||||
}
|
||||
if d.st {
|
||||
d.skipTags()
|
||||
}
|
||||
switch d.bd {
|
||||
case cborBdFloat16:
|
||||
f = float64(math.Float32frombits(halfFloatToFloatBits(bigen.Uint16(d.d.decRd.readn2()))))
|
||||
case cborBdFloat32:
|
||||
f = float64(math.Float32frombits(bigen.Uint32(d.d.decRd.readn4())))
|
||||
case cborBdFloat64:
|
||||
f = math.Float64frombits(bigen.Uint64(d.d.decRd.readn8()))
|
||||
default:
|
||||
major := d.bd >> 5
|
||||
if major == cborMajorUint {
|
||||
f = float64(cborDecInt64(d.decUint(), false))
|
||||
} else if major == cborMajorNegInt {
|
||||
f = float64(cborDecInt64(d.decUint(), true))
|
||||
} else {
|
||||
d.d.errorf("invalid float descriptor; got %d/%s, expected float16/32/64 or (-)int", d.bd, cbordesc(d.bd))
|
||||
}
|
||||
}
|
||||
d.bdRead = false
|
||||
return
|
||||
}
|
||||
|
||||
// bool can be decoded from bool only (single byte).
|
||||
func (d *cborDecDriver) DecodeBool() (b bool) {
|
||||
if d.advanceNil() {
|
||||
return
|
||||
}
|
||||
if d.st {
|
||||
d.skipTags()
|
||||
}
|
||||
if d.bd == cborBdTrue {
|
||||
b = true
|
||||
} else if d.bd == cborBdFalse {
|
||||
} else {
|
||||
d.d.errorf("not bool - %s %x/%s", msgBadDesc, d.bd, cbordesc(d.bd))
|
||||
}
|
||||
d.bdRead = false
|
||||
return
|
||||
}
|
||||
|
||||
func (d *cborDecDriver) ReadMapStart() (length int) {
|
||||
if d.advanceNil() {
|
||||
return containerLenNil
|
||||
}
|
||||
if d.st {
|
||||
d.skipTags()
|
||||
}
|
||||
d.bdRead = false
|
||||
if d.bd == cborBdIndefiniteMap {
|
||||
return containerLenUnknown
|
||||
}
|
||||
if d.bd>>5 != cborMajorMap {
|
||||
d.d.errorf("error reading map; got major type: %x, expected %x/%s", d.bd>>5, cborMajorMap, cbordesc(d.bd))
|
||||
}
|
||||
return d.decLen()
|
||||
}
|
||||
|
||||
func (d *cborDecDriver) ReadArrayStart() (length int) {
|
||||
if d.advanceNil() {
|
||||
return containerLenNil
|
||||
}
|
||||
if d.st {
|
||||
d.skipTags()
|
||||
}
|
||||
d.bdRead = false
|
||||
if d.bd == cborBdIndefiniteArray {
|
||||
return containerLenUnknown
|
||||
}
|
||||
if d.bd>>5 != cborMajorArray {
|
||||
d.d.errorf("invalid array; got major type: %x, expect: %x/%s", d.bd>>5, cborMajorArray, cbordesc(d.bd))
|
||||
}
|
||||
return d.decLen()
|
||||
}
|
||||
|
||||
func (d *cborDecDriver) DecodeBytes(bs []byte) (bsOut []byte) {
|
||||
d.d.decByteState = decByteStateNone
|
||||
if d.advanceNil() {
|
||||
return
|
||||
}
|
||||
if d.st {
|
||||
d.skipTags()
|
||||
}
|
||||
if d.bd == cborBdIndefiniteBytes || d.bd == cborBdIndefiniteString {
|
||||
d.bdRead = false
|
||||
if bs == nil {
|
||||
d.d.decByteState = decByteStateReuseBuf
|
||||
return d.decAppendIndefiniteBytes(d.d.b[:0])
|
||||
}
|
||||
return d.decAppendIndefiniteBytes(bs[:0])
|
||||
}
|
||||
if d.bd == cborBdIndefiniteArray {
|
||||
d.bdRead = false
|
||||
if bs == nil {
|
||||
d.d.decByteState = decByteStateReuseBuf
|
||||
bs = d.d.b[:0]
|
||||
} else {
|
||||
bs = bs[:0]
|
||||
}
|
||||
for !d.CheckBreak() {
|
||||
bs = append(bs, uint8(chkOvf.UintV(d.DecodeUint64(), 8)))
|
||||
}
|
||||
return bs
|
||||
}
|
||||
if d.bd>>5 == cborMajorArray {
|
||||
d.bdRead = false
|
||||
if bs == nil {
|
||||
d.d.decByteState = decByteStateReuseBuf
|
||||
bs = d.d.b[:]
|
||||
}
|
||||
slen := d.decLen()
|
||||
var changed bool
|
||||
if bs, changed = usableByteSlice(bs, slen); changed {
|
||||
d.d.decByteState = decByteStateNone
|
||||
}
|
||||
for i := 0; i < len(bs); i++ {
|
||||
bs[i] = uint8(chkOvf.UintV(d.DecodeUint64(), 8))
|
||||
}
|
||||
return bs
|
||||
}
|
||||
clen := d.decLen()
|
||||
d.bdRead = false
|
||||
if d.d.zerocopy() {
|
||||
d.d.decByteState = decByteStateZerocopy
|
||||
return d.d.decRd.rb.readx(uint(clen))
|
||||
}
|
||||
if bs == nil {
|
||||
d.d.decByteState = decByteStateReuseBuf
|
||||
bs = d.d.b[:]
|
||||
}
|
||||
return decByteSlice(d.d.r(), clen, d.h.MaxInitLen, bs)
|
||||
}
|
||||
|
||||
func (d *cborDecDriver) DecodeStringAsBytes() (s []byte) {
|
||||
return d.DecodeBytes(nil)
|
||||
}
|
||||
|
||||
func (d *cborDecDriver) DecodeTime() (t time.Time) {
|
||||
if d.advanceNil() {
|
||||
return
|
||||
}
|
||||
if d.bd>>5 != cborMajorTag {
|
||||
d.d.errorf("error reading tag; expected major type: %x, got: %x", cborMajorTag, d.bd>>5)
|
||||
}
|
||||
xtag := d.decUint()
|
||||
d.bdRead = false
|
||||
return d.decodeTime(xtag)
|
||||
}
|
||||
|
||||
func (d *cborDecDriver) decodeTime(xtag uint64) (t time.Time) {
|
||||
switch xtag {
|
||||
case 0:
|
||||
var err error
|
||||
t, err = time.Parse(time.RFC3339, stringView(d.DecodeStringAsBytes()))
|
||||
d.d.onerror(err)
|
||||
case 1:
|
||||
f1, f2 := math.Modf(d.DecodeFloat64())
|
||||
t = time.Unix(int64(f1), int64(f2*1e9))
|
||||
default:
|
||||
d.d.errorf("invalid tag for time.Time - expecting 0 or 1, got 0x%x", xtag)
|
||||
}
|
||||
t = t.UTC().Round(time.Microsecond)
|
||||
return
|
||||
}
|
||||
|
||||
func (d *cborDecDriver) DecodeExt(rv interface{}, xtag uint64, ext Ext) {
|
||||
if d.advanceNil() {
|
||||
return
|
||||
}
|
||||
if d.bd>>5 != cborMajorTag {
|
||||
d.d.errorf("error reading tag; expected major type: %x, got: %x", cborMajorTag, d.bd>>5)
|
||||
}
|
||||
realxtag := d.decUint()
|
||||
d.bdRead = false
|
||||
if ext == nil {
|
||||
re := rv.(*RawExt)
|
||||
re.Tag = realxtag
|
||||
d.d.decode(&re.Value)
|
||||
} else if xtag != realxtag {
|
||||
d.d.errorf("Wrong extension tag. Got %b. Expecting: %v", realxtag, xtag)
|
||||
} else if ext == SelfExt {
|
||||
rv2 := baseRV(rv)
|
||||
d.d.decodeValue(rv2, d.h.fnNoExt(rvType(rv2)))
|
||||
} else {
|
||||
d.d.interfaceExtConvertAndDecode(rv, ext)
|
||||
}
|
||||
d.bdRead = false
|
||||
}
|
||||
|
||||
func (d *cborDecDriver) DecodeNaked() {
|
||||
if !d.bdRead {
|
||||
d.readNextBd()
|
||||
}
|
||||
|
||||
n := d.d.naked()
|
||||
var decodeFurther bool
|
||||
|
||||
switch d.bd >> 5 {
|
||||
case cborMajorUint:
|
||||
if d.h.SignedInteger {
|
||||
n.v = valueTypeInt
|
||||
n.i = d.DecodeInt64()
|
||||
} else {
|
||||
n.v = valueTypeUint
|
||||
n.u = d.DecodeUint64()
|
||||
}
|
||||
case cborMajorNegInt:
|
||||
n.v = valueTypeInt
|
||||
n.i = d.DecodeInt64()
|
||||
case cborMajorBytes:
|
||||
d.d.fauxUnionReadRawBytes(false)
|
||||
case cborMajorString:
|
||||
n.v = valueTypeString
|
||||
n.s = d.d.stringZC(d.DecodeStringAsBytes())
|
||||
case cborMajorArray:
|
||||
n.v = valueTypeArray
|
||||
decodeFurther = true
|
||||
case cborMajorMap:
|
||||
n.v = valueTypeMap
|
||||
decodeFurther = true
|
||||
case cborMajorTag:
|
||||
n.v = valueTypeExt
|
||||
n.u = d.decUint()
|
||||
n.l = nil
|
||||
if n.u == 0 || n.u == 1 {
|
||||
d.bdRead = false
|
||||
n.v = valueTypeTime
|
||||
n.t = d.decodeTime(n.u)
|
||||
} else if d.st && d.h.getExtForTag(n.u) == nil {
|
||||
// d.skipTags() // no need to call this - tags already skipped
|
||||
d.bdRead = false
|
||||
d.DecodeNaked()
|
||||
return // return when done (as true recursive function)
|
||||
}
|
||||
case cborMajorSimpleOrFloat:
|
||||
switch d.bd {
|
||||
case cborBdNil, cborBdUndefined:
|
||||
n.v = valueTypeNil
|
||||
case cborBdFalse:
|
||||
n.v = valueTypeBool
|
||||
n.b = false
|
||||
case cborBdTrue:
|
||||
n.v = valueTypeBool
|
||||
n.b = true
|
||||
case cborBdFloat16, cborBdFloat32, cborBdFloat64:
|
||||
n.v = valueTypeFloat
|
||||
n.f = d.DecodeFloat64()
|
||||
default:
|
||||
d.d.errorf("decodeNaked: Unrecognized d.bd: 0x%x", d.bd)
|
||||
}
|
||||
default: // should never happen
|
||||
d.d.errorf("decodeNaked: Unrecognized d.bd: 0x%x", d.bd)
|
||||
}
|
||||
if !decodeFurther {
|
||||
d.bdRead = false
|
||||
}
|
||||
}
|
||||
|
||||
func (d *cborDecDriver) uintBytes() (v []byte, ui uint64) {
|
||||
// this is only used by nextValueBytes, so it's ok to
|
||||
// use readx and bigenstd here.
|
||||
switch vv := d.bd & 0x1f; vv {
|
||||
case 0x18:
|
||||
v = d.d.decRd.readx(1)
|
||||
ui = uint64(v[0])
|
||||
case 0x19:
|
||||
v = d.d.decRd.readx(2)
|
||||
ui = uint64(bigenstd.Uint16(v))
|
||||
case 0x1a:
|
||||
v = d.d.decRd.readx(4)
|
||||
ui = uint64(bigenstd.Uint32(v))
|
||||
case 0x1b:
|
||||
v = d.d.decRd.readx(8)
|
||||
ui = uint64(bigenstd.Uint64(v))
|
||||
default:
|
||||
if vv > 0x1b {
|
||||
d.d.errorf("invalid descriptor decoding uint: %x/%s", d.bd, cbordesc(d.bd))
|
||||
}
|
||||
ui = uint64(vv)
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func (d *cborDecDriver) nextValueBytes(start []byte) (v []byte) {
|
||||
if !d.bdRead {
|
||||
d.readNextBd()
|
||||
}
|
||||
v = append(start, d.bd)
|
||||
v = d.nextValueBytesBdReadR(v)
|
||||
d.bdRead = false
|
||||
return
|
||||
}
|
||||
|
||||
func (d *cborDecDriver) nextValueBytesR(v0 []byte) (v []byte) {
|
||||
d.readNextBd()
|
||||
v = append(v0, d.bd)
|
||||
return d.nextValueBytesBdReadR(v)
|
||||
}
|
||||
|
||||
func (d *cborDecDriver) nextValueBytesBdReadR(v0 []byte) (v []byte) {
|
||||
v = v0
|
||||
var bs []byte
|
||||
var ui uint64
|
||||
|
||||
switch d.bd >> 5 {
|
||||
case cborMajorUint, cborMajorNegInt:
|
||||
bs, _ = d.uintBytes()
|
||||
v = append(v, bs...)
|
||||
case cborMajorString, cborMajorBytes:
|
||||
if d.bd == cborBdIndefiniteBytes || d.bd == cborBdIndefiniteString {
|
||||
for {
|
||||
d.readNextBd()
|
||||
v = append(v, d.bd)
|
||||
if d.bd == cborBdBreak {
|
||||
break
|
||||
}
|
||||
bs, ui = d.uintBytes()
|
||||
v = append(v, bs...)
|
||||
v = append(v, d.d.decRd.readx(uint(ui))...)
|
||||
}
|
||||
} else {
|
||||
bs, ui = d.uintBytes()
|
||||
v = append(v, bs...)
|
||||
v = append(v, d.d.decRd.readx(uint(ui))...)
|
||||
}
|
||||
case cborMajorArray:
|
||||
if d.bd == cborBdIndefiniteArray {
|
||||
for {
|
||||
d.readNextBd()
|
||||
v = append(v, d.bd)
|
||||
if d.bd == cborBdBreak {
|
||||
break
|
||||
}
|
||||
v = d.nextValueBytesBdReadR(v)
|
||||
}
|
||||
} else {
|
||||
bs, ui = d.uintBytes()
|
||||
v = append(v, bs...)
|
||||
for i := uint64(0); i < ui; i++ {
|
||||
v = d.nextValueBytesR(v)
|
||||
}
|
||||
}
|
||||
case cborMajorMap:
|
||||
if d.bd == cborBdIndefiniteMap {
|
||||
for {
|
||||
d.readNextBd()
|
||||
v = append(v, d.bd)
|
||||
if d.bd == cborBdBreak {
|
||||
break
|
||||
}
|
||||
v = d.nextValueBytesBdReadR(v)
|
||||
v = d.nextValueBytesR(v)
|
||||
}
|
||||
} else {
|
||||
bs, ui = d.uintBytes()
|
||||
v = append(v, bs...)
|
||||
for i := uint64(0); i < ui; i++ {
|
||||
v = d.nextValueBytesR(v)
|
||||
v = d.nextValueBytesR(v)
|
||||
}
|
||||
}
|
||||
case cborMajorTag:
|
||||
bs, _ = d.uintBytes()
|
||||
v = append(v, bs...)
|
||||
v = d.nextValueBytesR(v)
|
||||
case cborMajorSimpleOrFloat:
|
||||
switch d.bd {
|
||||
case cborBdNil, cborBdUndefined, cborBdFalse, cborBdTrue: // pass
|
||||
case cborBdFloat16:
|
||||
v = append(v, d.d.decRd.readx(2)...)
|
||||
case cborBdFloat32:
|
||||
v = append(v, d.d.decRd.readx(4)...)
|
||||
case cborBdFloat64:
|
||||
v = append(v, d.d.decRd.readx(8)...)
|
||||
default:
|
||||
d.d.errorf("nextValueBytes: Unrecognized d.bd: 0x%x", d.bd)
|
||||
}
|
||||
default: // should never happen
|
||||
d.d.errorf("nextValueBytes: Unrecognized d.bd: 0x%x", d.bd)
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
// -------------------------
|
||||
|
||||
// CborHandle is a Handle for the CBOR encoding format,
|
||||
// defined at http://tools.ietf.org/html/rfc7049 and documented further at http://cbor.io .
|
||||
//
|
||||
// CBOR is comprehensively supported, including support for:
|
||||
// - indefinite-length arrays/maps/bytes/strings
|
||||
// - (extension) tags in range 0..0xffff (0 .. 65535)
|
||||
// - half, single and double-precision floats
|
||||
// - all numbers (1, 2, 4 and 8-byte signed and unsigned integers)
|
||||
// - nil, true, false, ...
|
||||
// - arrays and maps, bytes and text strings
|
||||
//
|
||||
// None of the optional extensions (with tags) defined in the spec are supported out-of-the-box.
|
||||
// Users can implement them as needed (using SetExt), including spec-documented ones:
|
||||
// - timestamp, BigNum, BigFloat, Decimals,
|
||||
// - Encoded Text (e.g. URL, regexp, base64, MIME Message), etc.
|
||||
type CborHandle struct {
|
||||
binaryEncodingType
|
||||
// noElemSeparators
|
||||
BasicHandle
|
||||
|
||||
// IndefiniteLength=true, means that we encode using indefinitelength
|
||||
IndefiniteLength bool
|
||||
|
||||
// TimeRFC3339 says to encode time.Time using RFC3339 format.
|
||||
// If unset, we encode time.Time using seconds past epoch.
|
||||
TimeRFC3339 bool
|
||||
|
||||
// SkipUnexpectedTags says to skip over any tags for which extensions are
|
||||
// not defined. This is in keeping with the cbor spec on "Optional Tagging of Items".
|
||||
//
|
||||
// Furthermore, this allows the skipping over of the Self Describing Tag 0xd9d9f7.
|
||||
SkipUnexpectedTags bool
|
||||
}
|
||||
|
||||
// Name returns the name of the handle: cbor
|
||||
func (h *CborHandle) Name() string { return "cbor" }
|
||||
|
||||
func (h *CborHandle) desc(bd byte) string { return cbordesc(bd) }
|
||||
|
||||
func (h *CborHandle) newEncDriver() encDriver {
|
||||
var e = &cborEncDriver{h: h}
|
||||
e.e.e = e
|
||||
e.e.init(h)
|
||||
e.reset()
|
||||
return e
|
||||
}
|
||||
|
||||
func (h *CborHandle) newDecDriver() decDriver {
|
||||
d := &cborDecDriver{h: h, st: h.SkipUnexpectedTags}
|
||||
d.d.d = d
|
||||
d.d.cbor = true
|
||||
d.d.init(h)
|
||||
d.reset()
|
||||
return d
|
||||
}
|
||||
|
||||
func (e *cborEncDriver) reset() {
|
||||
}
|
||||
|
||||
func (d *cborDecDriver) reset() {
|
||||
d.bd = 0
|
||||
d.bdRead = false
|
||||
d.st = d.h.SkipUnexpectedTags
|
||||
}
|
||||
|
||||
var _ decDriver = (*cborDecDriver)(nil)
|
||||
var _ encDriver = (*cborEncDriver)(nil)
|
13
vendor/github.com/ugorji/go/codec/codecgen.go
generated
vendored
Normal file
13
vendor/github.com/ugorji/go/codec/codecgen.go
generated
vendored
Normal file
|
@ -0,0 +1,13 @@
|
|||
// +build codecgen generated
|
||||
|
||||
package codec
|
||||
|
||||
// this file sets the codecgen variable to true
|
||||
// when the build tag codecgen is set.
|
||||
//
|
||||
// some tests depend on knowing whether in the context of codecgen or not.
|
||||
// For example, some tests should be skipped during codecgen e.g. missing fields tests.
|
||||
|
||||
func init() {
|
||||
codecgen = true
|
||||
}
|
454
vendor/github.com/ugorji/go/codec/decimal.go
generated
vendored
Normal file
454
vendor/github.com/ugorji/go/codec/decimal.go
generated
vendored
Normal file
|
@ -0,0 +1,454 @@
|
|||
// Copyright (c) 2012-2020 Ugorji Nwoke. All rights reserved.
|
||||
// Use of this source code is governed by a MIT license found in the LICENSE file.
|
||||
|
||||
package codec
|
||||
|
||||
import (
|
||||
"strconv"
|
||||
)
|
||||
|
||||
// Per go spec, floats are represented in memory as
|
||||
// IEEE single or double precision floating point values.
|
||||
//
|
||||
// We also looked at the source for stdlib math/modf.go,
|
||||
// reviewed https://github.com/chewxy/math32
|
||||
// and read wikipedia documents describing the formats.
|
||||
//
|
||||
// It became clear that we could easily look at the bits to determine
|
||||
// whether any fraction exists.
|
||||
|
||||
func parseFloat32(b []byte) (f float32, err error) {
|
||||
return parseFloat32_custom(b)
|
||||
}
|
||||
|
||||
func parseFloat64(b []byte) (f float64, err error) {
|
||||
return parseFloat64_custom(b)
|
||||
}
|
||||
|
||||
func parseFloat32_strconv(b []byte) (f float32, err error) {
|
||||
f64, err := strconv.ParseFloat(stringView(b), 32)
|
||||
f = float32(f64)
|
||||
return
|
||||
}
|
||||
|
||||
func parseFloat64_strconv(b []byte) (f float64, err error) {
|
||||
return strconv.ParseFloat(stringView(b), 64)
|
||||
}
|
||||
|
||||
// ------ parseFloat custom below --------
|
||||
|
||||
// JSON really supports decimal numbers in base 10 notation, with exponent support.
|
||||
//
|
||||
// We assume the following:
|
||||
// - a lot of floating point numbers in json files will have defined precision
|
||||
// (in terms of number of digits after decimal point), etc.
|
||||
// - these (referenced above) can be written in exact format.
|
||||
//
|
||||
// strconv.ParseFloat has some unnecessary overhead which we can do without
|
||||
// for the common case:
|
||||
//
|
||||
// - expensive char-by-char check to see if underscores are in right place
|
||||
// - testing for and skipping underscores
|
||||
// - check if the string matches ignorecase +/- inf, +/- infinity, nan
|
||||
// - support for base 16 (0xFFFF...)
|
||||
//
|
||||
// The functions below will try a fast-path for floats which can be decoded
|
||||
// without any loss of precision, meaning they:
|
||||
//
|
||||
// - fits within the significand bits of the 32-bits or 64-bits
|
||||
// - exponent fits within the exponent value
|
||||
// - there is no truncation (any extra numbers are all trailing zeros)
|
||||
//
|
||||
// To figure out what the values are for maxMantDigits, use this idea below:
|
||||
//
|
||||
// 2^23 = 838 8608 (between 10^ 6 and 10^ 7) (significand bits of uint32)
|
||||
// 2^32 = 42 9496 7296 (between 10^ 9 and 10^10) (full uint32)
|
||||
// 2^52 = 4503 5996 2737 0496 (between 10^15 and 10^16) (significand bits of uint64)
|
||||
// 2^64 = 1844 6744 0737 0955 1616 (between 10^19 and 10^20) (full uint64)
|
||||
//
|
||||
// Note: we only allow for up to what can comfortably fit into the significand
|
||||
// ignoring the exponent, and we only try to parse iff significand fits.
|
||||
|
||||
const (
|
||||
fMaxMultiplierForExactPow10_64 = 1e15
|
||||
fMaxMultiplierForExactPow10_32 = 1e7
|
||||
|
||||
fUint64Cutoff = (1<<64-1)/10 + 1
|
||||
// fUint32Cutoff = (1<<32-1)/10 + 1
|
||||
|
||||
fBase = 10
|
||||
)
|
||||
|
||||
const (
|
||||
thousand = 1000
|
||||
million = thousand * thousand
|
||||
billion = thousand * million
|
||||
trillion = thousand * billion
|
||||
quadrillion = thousand * trillion
|
||||
quintillion = thousand * quadrillion
|
||||
)
|
||||
|
||||
// Exact powers of 10.
|
||||
var uint64pow10 = [...]uint64{
|
||||
1, 10, 100,
|
||||
1 * thousand, 10 * thousand, 100 * thousand,
|
||||
1 * million, 10 * million, 100 * million,
|
||||
1 * billion, 10 * billion, 100 * billion,
|
||||
1 * trillion, 10 * trillion, 100 * trillion,
|
||||
1 * quadrillion, 10 * quadrillion, 100 * quadrillion,
|
||||
1 * quintillion, 10 * quintillion,
|
||||
}
|
||||
var float64pow10 = [...]float64{
|
||||
1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9,
|
||||
1e10, 1e11, 1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19,
|
||||
1e20, 1e21, 1e22,
|
||||
}
|
||||
var float32pow10 = [...]float32{
|
||||
1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9, 1e10,
|
||||
}
|
||||
|
||||
type floatinfo struct {
|
||||
mantbits uint8
|
||||
|
||||
// expbits uint8 // (unused)
|
||||
// bias int16 // (unused)
|
||||
|
||||
is32bit bool
|
||||
exactPow10 int8 // Exact powers of ten are <= 10^N (32: 10, 64: 22)
|
||||
|
||||
exactInts int8 // Exact integers are <= 10^N (for non-float, set to 0)
|
||||
|
||||
// maxMantDigits int8 // 10^19 fits in uint64, while 10^9 fits in uint32
|
||||
|
||||
mantCutoffIsUint64Cutoff bool
|
||||
|
||||
mantCutoff uint64
|
||||
}
|
||||
|
||||
var fi32 = floatinfo{23, true, 10, 7, false, 1<<23 - 1}
|
||||
var fi64 = floatinfo{52, false, 22, 15, false, 1<<52 - 1}
|
||||
|
||||
var fi64u = floatinfo{0, false, 19, 0, true, fUint64Cutoff}
|
||||
var fi64i = floatinfo{0, false, 19, 0, true, fUint64Cutoff}
|
||||
|
||||
func strconvParseErr(b []byte, fn string) error {
|
||||
return &strconv.NumError{
|
||||
Func: fn,
|
||||
Err: strconv.ErrSyntax,
|
||||
Num: string(b),
|
||||
}
|
||||
}
|
||||
|
||||
func parseFloat32_reader(r readFloatResult) (f float32, fail bool) {
|
||||
f = float32(r.mantissa)
|
||||
if r.exp == 0 {
|
||||
} else if r.exp < 0 { // int / 10^k
|
||||
f /= float32pow10[uint8(-r.exp)]
|
||||
} else { // exp > 0
|
||||
if r.exp > fi32.exactPow10 {
|
||||
f *= float32pow10[r.exp-fi32.exactPow10]
|
||||
if f > fMaxMultiplierForExactPow10_32 { // exponent too large - outside range
|
||||
fail = true
|
||||
return // ok = false
|
||||
}
|
||||
f *= float32pow10[fi32.exactPow10]
|
||||
} else {
|
||||
f *= float32pow10[uint8(r.exp)]
|
||||
}
|
||||
}
|
||||
if r.neg {
|
||||
f = -f
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func parseFloat32_custom(b []byte) (f float32, err error) {
|
||||
r := readFloat(b, fi32)
|
||||
if r.bad {
|
||||
return 0, strconvParseErr(b, "ParseFloat")
|
||||
}
|
||||
if r.ok {
|
||||
f, r.bad = parseFloat32_reader(r)
|
||||
if !r.bad {
|
||||
return
|
||||
}
|
||||
}
|
||||
return parseFloat32_strconv(b)
|
||||
}
|
||||
|
||||
func parseFloat64_reader(r readFloatResult) (f float64, fail bool) {
|
||||
f = float64(r.mantissa)
|
||||
if r.exp == 0 {
|
||||
} else if r.exp < 0 { // int / 10^k
|
||||
f /= float64pow10[-uint8(r.exp)]
|
||||
} else { // exp > 0
|
||||
if r.exp > fi64.exactPow10 {
|
||||
f *= float64pow10[r.exp-fi64.exactPow10]
|
||||
if f > fMaxMultiplierForExactPow10_64 { // exponent too large - outside range
|
||||
fail = true
|
||||
return
|
||||
}
|
||||
f *= float64pow10[fi64.exactPow10]
|
||||
} else {
|
||||
f *= float64pow10[uint8(r.exp)]
|
||||
}
|
||||
}
|
||||
if r.neg {
|
||||
f = -f
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func parseFloat64_custom(b []byte) (f float64, err error) {
|
||||
r := readFloat(b, fi64)
|
||||
if r.bad {
|
||||
return 0, strconvParseErr(b, "ParseFloat")
|
||||
}
|
||||
if r.ok {
|
||||
f, r.bad = parseFloat64_reader(r)
|
||||
if !r.bad {
|
||||
return
|
||||
}
|
||||
}
|
||||
return parseFloat64_strconv(b)
|
||||
}
|
||||
|
||||
func parseUint64_simple(b []byte) (n uint64, ok bool) {
|
||||
var i int
|
||||
var n1 uint64
|
||||
var c uint8
|
||||
LOOP:
|
||||
if i < len(b) {
|
||||
c = b[i]
|
||||
// unsigned integers don't overflow well on multiplication, so check cutoff here
|
||||
// e.g. (maxUint64-5)*10 doesn't overflow well ...
|
||||
// if n >= fUint64Cutoff || !isDigitChar(b[i]) { // if c < '0' || c > '9' {
|
||||
if n >= fUint64Cutoff || c < '0' || c > '9' {
|
||||
return
|
||||
} else if c == '0' {
|
||||
n *= fBase
|
||||
} else {
|
||||
n1 = n
|
||||
n = n*fBase + uint64(c-'0')
|
||||
if n < n1 {
|
||||
return
|
||||
}
|
||||
}
|
||||
i++
|
||||
goto LOOP
|
||||
}
|
||||
ok = true
|
||||
return
|
||||
}
|
||||
|
||||
func parseUint64_reader(r readFloatResult) (f uint64, fail bool) {
|
||||
f = r.mantissa
|
||||
if r.exp == 0 {
|
||||
} else if r.exp < 0 { // int / 10^k
|
||||
if f%uint64pow10[uint8(-r.exp)] != 0 {
|
||||
fail = true
|
||||
} else {
|
||||
f /= uint64pow10[uint8(-r.exp)]
|
||||
}
|
||||
} else { // exp > 0
|
||||
f *= uint64pow10[uint8(r.exp)]
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func parseInt64_reader(r readFloatResult) (v int64, fail bool) {
|
||||
if r.exp == 0 {
|
||||
} else if r.exp < 0 { // int / 10^k
|
||||
if r.mantissa%uint64pow10[uint8(-r.exp)] != 0 {
|
||||
// fail = true
|
||||
return 0, true
|
||||
}
|
||||
r.mantissa /= uint64pow10[uint8(-r.exp)]
|
||||
} else { // exp > 0
|
||||
r.mantissa *= uint64pow10[uint8(r.exp)]
|
||||
}
|
||||
if chkOvf.Uint2Int(r.mantissa, r.neg) {
|
||||
fail = true
|
||||
} else if r.neg {
|
||||
v = -int64(r.mantissa)
|
||||
} else {
|
||||
v = int64(r.mantissa)
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
// parseNumber will return an integer if only composed of [-]?[0-9]+
|
||||
// Else it will return a float.
|
||||
func parseNumber(b []byte, z *fauxUnion, preferSignedInt bool) (err error) {
|
||||
var ok, neg bool
|
||||
var f uint64
|
||||
|
||||
if len(b) == 0 {
|
||||
return
|
||||
}
|
||||
|
||||
if b[0] == '-' {
|
||||
neg = true
|
||||
f, ok = parseUint64_simple(b[1:])
|
||||
} else {
|
||||
f, ok = parseUint64_simple(b)
|
||||
}
|
||||
|
||||
if ok {
|
||||
if neg {
|
||||
z.v = valueTypeInt
|
||||
if chkOvf.Uint2Int(f, neg) {
|
||||
return strconvParseErr(b, "ParseInt")
|
||||
}
|
||||
z.i = -int64(f)
|
||||
} else if preferSignedInt {
|
||||
z.v = valueTypeInt
|
||||
if chkOvf.Uint2Int(f, neg) {
|
||||
return strconvParseErr(b, "ParseInt")
|
||||
}
|
||||
z.i = int64(f)
|
||||
} else {
|
||||
z.v = valueTypeUint
|
||||
z.u = f
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
z.v = valueTypeFloat
|
||||
z.f, err = parseFloat64_custom(b)
|
||||
return
|
||||
}
|
||||
|
||||
type readFloatResult struct {
|
||||
mantissa uint64
|
||||
exp int8
|
||||
neg, sawdot, sawexp, trunc, bad bool
|
||||
ok bool
|
||||
_ byte // padding
|
||||
}
|
||||
|
||||
func readFloat(s []byte, y floatinfo) (r readFloatResult) {
|
||||
var i uint // uint, so that we eliminate bounds checking
|
||||
var slen = uint(len(s))
|
||||
if slen == 0 {
|
||||
// read an empty string as the zero value
|
||||
// r.bad = true
|
||||
r.ok = true
|
||||
return
|
||||
}
|
||||
|
||||
if s[0] == '-' {
|
||||
r.neg = true
|
||||
i++
|
||||
}
|
||||
|
||||
// we considered punting early if string has length > maxMantDigits, but this doesn't account
|
||||
// for trailing 0's e.g. 700000000000000000000 can be encoded exactly as it is 7e20
|
||||
|
||||
var nd, ndMant, dp int8
|
||||
var xu uint64
|
||||
|
||||
LOOP:
|
||||
for ; i < slen; i++ {
|
||||
switch s[i] {
|
||||
case '.':
|
||||
if r.sawdot {
|
||||
r.bad = true
|
||||
return
|
||||
}
|
||||
r.sawdot = true
|
||||
dp = nd
|
||||
case 'e', 'E':
|
||||
r.sawexp = true
|
||||
break LOOP
|
||||
case '0':
|
||||
if nd == 0 {
|
||||
dp--
|
||||
continue LOOP
|
||||
}
|
||||
nd++
|
||||
if r.mantissa < y.mantCutoff {
|
||||
r.mantissa *= fBase
|
||||
ndMant++
|
||||
}
|
||||
case '1', '2', '3', '4', '5', '6', '7', '8', '9':
|
||||
nd++
|
||||
if y.mantCutoffIsUint64Cutoff && r.mantissa < fUint64Cutoff {
|
||||
r.mantissa *= fBase
|
||||
xu = r.mantissa + uint64(s[i]-'0')
|
||||
if xu < r.mantissa {
|
||||
r.trunc = true
|
||||
return
|
||||
}
|
||||
r.mantissa = xu
|
||||
} else if r.mantissa < y.mantCutoff {
|
||||
// mantissa = (mantissa << 1) + (mantissa << 3) + uint64(c-'0')
|
||||
r.mantissa = r.mantissa*fBase + uint64(s[i]-'0')
|
||||
} else {
|
||||
r.trunc = true
|
||||
return
|
||||
}
|
||||
ndMant++
|
||||
default:
|
||||
r.bad = true
|
||||
return
|
||||
}
|
||||
}
|
||||
|
||||
if !r.sawdot {
|
||||
dp = nd
|
||||
}
|
||||
|
||||
if r.sawexp {
|
||||
i++
|
||||
if i < slen {
|
||||
var eneg bool
|
||||
if s[i] == '+' {
|
||||
i++
|
||||
} else if s[i] == '-' {
|
||||
i++
|
||||
eneg = true
|
||||
}
|
||||
if i < slen {
|
||||
// for exact match, exponent is 1 or 2 digits (float64: -22 to 37, float32: -1 to 17).
|
||||
// exit quick if exponent is more than 2 digits.
|
||||
if i+2 < slen {
|
||||
return
|
||||
}
|
||||
var e int8
|
||||
if s[i] < '0' || s[i] > '9' { // !isDigitChar(s[i]) { //
|
||||
r.bad = true
|
||||
return
|
||||
}
|
||||
e = int8(s[i] - '0')
|
||||
i++
|
||||
if i < slen {
|
||||
if s[i] < '0' || s[i] > '9' { // !isDigitChar(s[i]) { //
|
||||
r.bad = true
|
||||
return
|
||||
}
|
||||
e = e*fBase + int8(s[i]-'0') // (e << 1) + (e << 3) + int8(s[i]-'0')
|
||||
i++
|
||||
}
|
||||
if eneg {
|
||||
dp -= e
|
||||
} else {
|
||||
dp += e
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if r.mantissa != 0 {
|
||||
r.exp = dp - ndMant
|
||||
// do not set ok=true for cases we cannot handle
|
||||
if r.exp < -y.exactPow10 ||
|
||||
r.exp > y.exactInts+y.exactPow10 ||
|
||||
(y.mantbits != 0 && r.mantissa>>y.mantbits != 0) {
|
||||
return
|
||||
}
|
||||
}
|
||||
|
||||
r.ok = true
|
||||
return
|
||||
}
|
1988
vendor/github.com/ugorji/go/codec/decode.go
generated
vendored
Normal file
1988
vendor/github.com/ugorji/go/codec/decode.go
generated
vendored
Normal file
File diff suppressed because it is too large
Load diff
228
vendor/github.com/ugorji/go/codec/doc.go
generated
vendored
Normal file
228
vendor/github.com/ugorji/go/codec/doc.go
generated
vendored
Normal file
|
@ -0,0 +1,228 @@
|
|||
// Copyright (c) 2012-2020 Ugorji Nwoke. All rights reserved.
|
||||
// Use of this source code is governed by a MIT license found in the LICENSE file.
|
||||
|
||||
/*
|
||||
Package codec provides a
|
||||
High Performance, Feature-Rich Idiomatic Go 1.4+ codec/encoding library
|
||||
for binc, msgpack, cbor, json.
|
||||
|
||||
Supported Serialization formats are:
|
||||
|
||||
- msgpack: https://github.com/msgpack/msgpack
|
||||
- binc: http://github.com/ugorji/binc
|
||||
- cbor: http://cbor.io http://tools.ietf.org/html/rfc7049
|
||||
- json: http://json.org http://tools.ietf.org/html/rfc7159
|
||||
- simple:
|
||||
|
||||
This package will carefully use 'package unsafe' for performance reasons in specific places.
|
||||
You can build without unsafe use by passing the safe or appengine tag
|
||||
i.e. 'go install -tags=safe ...'.
|
||||
|
||||
This library works with both the standard `gc` and the `gccgo` compilers.
|
||||
|
||||
For detailed usage information, read the primer at http://ugorji.net/blog/go-codec-primer .
|
||||
|
||||
The idiomatic Go support is as seen in other encoding packages in
|
||||
the standard library (ie json, xml, gob, etc).
|
||||
|
||||
Rich Feature Set includes:
|
||||
|
||||
- Simple but extremely powerful and feature-rich API
|
||||
- Support for go 1.4 and above, while selectively using newer APIs for later releases
|
||||
- Excellent code coverage ( > 90% )
|
||||
- Very High Performance.
|
||||
Our extensive benchmarks show us outperforming Gob, Json, Bson, etc by 2-4X.
|
||||
- Careful selected use of 'unsafe' for targeted performance gains.
|
||||
- 100% safe mode supported, where 'unsafe' is not used at all.
|
||||
- Lock-free (sans mutex) concurrency for scaling to 100's of cores
|
||||
- In-place updates during decode, with option to zero value in maps and slices prior to decode
|
||||
- Coerce types where appropriate
|
||||
e.g. decode an int in the stream into a float, decode numbers from formatted strings, etc
|
||||
- Corner Cases:
|
||||
Overflows, nil maps/slices, nil values in streams are handled correctly
|
||||
- Standard field renaming via tags
|
||||
- Support for omitting empty fields during an encoding
|
||||
- Encoding from any value and decoding into pointer to any value
|
||||
(struct, slice, map, primitives, pointers, interface{}, etc)
|
||||
- Extensions to support efficient encoding/decoding of any named types
|
||||
- Support encoding.(Binary|Text)(M|Unm)arshaler interfaces
|
||||
- Support IsZero() bool to determine if a value is a zero value.
|
||||
Analogous to time.Time.IsZero() bool.
|
||||
- Decoding without a schema (into a interface{}).
|
||||
Includes Options to configure what specific map or slice type to use
|
||||
when decoding an encoded list or map into a nil interface{}
|
||||
- Mapping a non-interface type to an interface, so we can decode appropriately
|
||||
into any interface type with a correctly configured non-interface value.
|
||||
- Encode a struct as an array, and decode struct from an array in the data stream
|
||||
- Option to encode struct keys as numbers (instead of strings)
|
||||
(to support structured streams with fields encoded as numeric codes)
|
||||
- Comprehensive support for anonymous fields
|
||||
- Fast (no-reflection) encoding/decoding of common maps and slices
|
||||
- Code-generation for faster performance, supported in go 1.6+
|
||||
- Support binary (e.g. messagepack, cbor) and text (e.g. json) formats
|
||||
- Support indefinite-length formats to enable true streaming
|
||||
(for formats which support it e.g. json, cbor)
|
||||
- Support canonical encoding, where a value is ALWAYS encoded as same sequence of bytes.
|
||||
This mostly applies to maps, where iteration order is non-deterministic.
|
||||
- NIL in data stream decoded as zero value
|
||||
- Never silently skip data when decoding.
|
||||
User decides whether to return an error or silently skip data when keys or indexes
|
||||
in the data stream do not map to fields in the struct.
|
||||
- Detect and error when encoding a cyclic reference (instead of stack overflow shutdown)
|
||||
- Encode/Decode from/to chan types (for iterative streaming support)
|
||||
- Drop-in replacement for encoding/json. `json:` key in struct tag supported.
|
||||
- Provides a RPC Server and Client Codec for net/rpc communication protocol.
|
||||
- Handle unique idiosyncrasies of codecs e.g.
|
||||
- For messagepack, configure how ambiguities in handling raw bytes are resolved
|
||||
- For messagepack, provide rpc server/client codec to support
|
||||
msgpack-rpc protocol defined at:
|
||||
https://github.com/msgpack-rpc/msgpack-rpc/blob/master/spec.md
|
||||
|
||||
Extension Support
|
||||
|
||||
Users can register a function to handle the encoding or decoding of
|
||||
their custom types.
|
||||
|
||||
There are no restrictions on what the custom type can be. Some examples:
|
||||
|
||||
type BisSet []int
|
||||
type BitSet64 uint64
|
||||
type UUID string
|
||||
type MyStructWithUnexportedFields struct { a int; b bool; c []int; }
|
||||
type GifImage struct { ... }
|
||||
|
||||
As an illustration, MyStructWithUnexportedFields would normally be
|
||||
encoded as an empty map because it has no exported fields, while UUID
|
||||
would be encoded as a string. However, with extension support, you can
|
||||
encode any of these however you like.
|
||||
|
||||
There is also seamless support provided for registering an extension (with a tag)
|
||||
but letting the encoding mechanism default to the standard way.
|
||||
|
||||
Custom Encoding and Decoding
|
||||
|
||||
This package maintains symmetry in the encoding and decoding halfs.
|
||||
We determine how to encode or decode by walking this decision tree
|
||||
|
||||
- is there an extension registered for the type?
|
||||
- is type a codec.Selfer?
|
||||
- is format binary, and is type a encoding.BinaryMarshaler and BinaryUnmarshaler?
|
||||
- is format specifically json, and is type a encoding/json.Marshaler and Unmarshaler?
|
||||
- is format text-based, and type an encoding.TextMarshaler and TextUnmarshaler?
|
||||
- else we use a pair of functions based on the "kind" of the type e.g. map, slice, int64, etc
|
||||
|
||||
This symmetry is important to reduce chances of issues happening because the
|
||||
encoding and decoding sides are out of sync e.g. decoded via very specific
|
||||
encoding.TextUnmarshaler but encoded via kind-specific generalized mode.
|
||||
|
||||
Consequently, if a type only defines one-half of the symmetry
|
||||
(e.g. it implements UnmarshalJSON() but not MarshalJSON() ),
|
||||
then that type doesn't satisfy the check and we will continue walking down the
|
||||
decision tree.
|
||||
|
||||
RPC
|
||||
|
||||
RPC Client and Server Codecs are implemented, so the codecs can be used
|
||||
with the standard net/rpc package.
|
||||
|
||||
Usage
|
||||
|
||||
The Handle is SAFE for concurrent READ, but NOT SAFE for concurrent modification.
|
||||
|
||||
The Encoder and Decoder are NOT safe for concurrent use.
|
||||
|
||||
Consequently, the usage model is basically:
|
||||
|
||||
- Create and initialize the Handle before any use.
|
||||
Once created, DO NOT modify it.
|
||||
- Multiple Encoders or Decoders can now use the Handle concurrently.
|
||||
They only read information off the Handle (never write).
|
||||
- However, each Encoder or Decoder MUST not be used concurrently
|
||||
- To re-use an Encoder/Decoder, call Reset(...) on it first.
|
||||
This allows you use state maintained on the Encoder/Decoder.
|
||||
|
||||
Sample usage model:
|
||||
|
||||
// create and configure Handle
|
||||
var (
|
||||
bh codec.BincHandle
|
||||
mh codec.MsgpackHandle
|
||||
ch codec.CborHandle
|
||||
)
|
||||
|
||||
mh.MapType = reflect.TypeOf(map[string]interface{}(nil))
|
||||
|
||||
// configure extensions
|
||||
// e.g. for msgpack, define functions and enable Time support for tag 1
|
||||
// mh.SetExt(reflect.TypeOf(time.Time{}), 1, myExt)
|
||||
|
||||
// create and use decoder/encoder
|
||||
var (
|
||||
r io.Reader
|
||||
w io.Writer
|
||||
b []byte
|
||||
h = &bh // or mh to use msgpack
|
||||
)
|
||||
|
||||
dec = codec.NewDecoder(r, h)
|
||||
dec = codec.NewDecoderBytes(b, h)
|
||||
err = dec.Decode(&v)
|
||||
|
||||
enc = codec.NewEncoder(w, h)
|
||||
enc = codec.NewEncoderBytes(&b, h)
|
||||
err = enc.Encode(v)
|
||||
|
||||
//RPC Server
|
||||
go func() {
|
||||
for {
|
||||
conn, err := listener.Accept()
|
||||
rpcCodec := codec.GoRpc.ServerCodec(conn, h)
|
||||
//OR rpcCodec := codec.MsgpackSpecRpc.ServerCodec(conn, h)
|
||||
rpc.ServeCodec(rpcCodec)
|
||||
}
|
||||
}()
|
||||
|
||||
//RPC Communication (client side)
|
||||
conn, err = net.Dial("tcp", "localhost:5555")
|
||||
rpcCodec := codec.GoRpc.ClientCodec(conn, h)
|
||||
//OR rpcCodec := codec.MsgpackSpecRpc.ClientCodec(conn, h)
|
||||
client := rpc.NewClientWithCodec(rpcCodec)
|
||||
|
||||
Running Tests
|
||||
|
||||
To run tests, use the following:
|
||||
|
||||
go test
|
||||
|
||||
To run the full suite of tests, use the following:
|
||||
|
||||
go test -tags alltests -run Suite
|
||||
|
||||
You can run the tag 'safe' to run tests or build in safe mode. e.g.
|
||||
|
||||
go test -tags safe -run Json
|
||||
go test -tags "alltests safe" -run Suite
|
||||
|
||||
Running Benchmarks
|
||||
|
||||
cd bench
|
||||
go test -bench . -benchmem -benchtime 1s
|
||||
|
||||
Please see http://github.com/ugorji/go-codec-bench .
|
||||
|
||||
Caveats
|
||||
|
||||
Struct fields matching the following are ignored during encoding and decoding
|
||||
- struct tag value set to -
|
||||
- func, complex numbers, unsafe pointers
|
||||
- unexported and not embedded
|
||||
- unexported and embedded and not struct kind
|
||||
- unexported and embedded pointers (from go1.10)
|
||||
|
||||
Every other field in a struct will be encoded/decoded.
|
||||
|
||||
Embedded fields are encoded as if they exist in the top-level struct,
|
||||
with some caveats. See Encode documentation.
|
||||
|
||||
*/
|
||||
package codec
|
1317
vendor/github.com/ugorji/go/codec/encode.go
generated
vendored
Normal file
1317
vendor/github.com/ugorji/go/codec/encode.go
generated
vendored
Normal file
File diff suppressed because it is too large
Load diff
5643
vendor/github.com/ugorji/go/codec/fast-path.generated.go
generated
vendored
Normal file
5643
vendor/github.com/ugorji/go/codec/fast-path.generated.go
generated
vendored
Normal file
File diff suppressed because it is too large
Load diff
505
vendor/github.com/ugorji/go/codec/fast-path.go.tmpl
generated
vendored
Normal file
505
vendor/github.com/ugorji/go/codec/fast-path.go.tmpl
generated
vendored
Normal file
|
@ -0,0 +1,505 @@
|
|||
// +build !notfastpath
|
||||
|
||||
// Copyright (c) 2012-2020 Ugorji Nwoke. All rights reserved.
|
||||
// Use of this source code is governed by a MIT license found in the LICENSE file.
|
||||
|
||||
// Code generated from fast-path.go.tmpl - DO NOT EDIT.
|
||||
|
||||
package codec
|
||||
|
||||
// Fast path functions try to create a fast path encode or decode implementation
|
||||
// for common maps and slices.
|
||||
//
|
||||
// We define the functions and register them in this single file
|
||||
// so as not to pollute the encode.go and decode.go, and create a dependency in there.
|
||||
// This file can be omitted without causing a build failure.
|
||||
//
|
||||
// The advantage of fast paths is:
|
||||
// - Many calls bypass reflection altogether
|
||||
//
|
||||
// Currently support
|
||||
// - slice of all builtin types (numeric, bool, string, []byte)
|
||||
// - maps of builtin types to builtin or interface{} type, EXCEPT FOR
|
||||
// keys of type uintptr, int8/16/32, uint16/32, float32/64, bool, interface{}
|
||||
// AND values of type type int8/16/32, uint16/32
|
||||
// This should provide adequate "typical" implementations.
|
||||
//
|
||||
// Note that fast track decode functions must handle values for which an address cannot be obtained.
|
||||
// For example:
|
||||
// m2 := map[string]int{}
|
||||
// p2 := []interface{}{m2}
|
||||
// // decoding into p2 will bomb if fast track functions do not treat like unaddressable.
|
||||
//
|
||||
|
||||
{{/*
|
||||
fastpathEncMapStringUint64R (called by fastpath...switch)
|
||||
EncMapStringUint64V (called by codecgen)
|
||||
|
||||
fastpathEncSliceBoolR: (called by fastpath...switch) (checks f.ti.mbs and calls one of them below)
|
||||
EncSliceBoolV (also called by codecgen)
|
||||
EncAsMapSliceBoolV (delegate when mapbyslice=true)
|
||||
|
||||
fastpathDecSliceIntfR (called by fastpath...switch) (calls Y or N below depending on if it can be updated)
|
||||
DecSliceIntfX (called by codecgen) (calls Y below)
|
||||
DecSliceIntfY (delegate when slice CAN be updated)
|
||||
DecSliceIntfN (delegate when slice CANNOT be updated e.g. from array or non-addressable slice)
|
||||
|
||||
fastpathDecMap...R (called by fastpath...switch) (calls L or X? below)
|
||||
DecMap...X (called by codecgen)
|
||||
DecMap...L (delegated to by both above)
|
||||
*/ -}}
|
||||
|
||||
import (
|
||||
"reflect"
|
||||
"sort"
|
||||
)
|
||||
|
||||
const fastpathEnabled = true
|
||||
|
||||
{{/*
|
||||
const fastpathMapBySliceErrMsg = "mapBySlice requires even slice length, but got %v"
|
||||
*/ -}}
|
||||
|
||||
type fastpathT struct {}
|
||||
|
||||
var fastpathTV fastpathT
|
||||
|
||||
type fastpathE struct {
|
||||
{{/* rtid uintptr */ -}}
|
||||
rt reflect.Type
|
||||
encfn func(*Encoder, *codecFnInfo, reflect.Value)
|
||||
decfn func(*Decoder, *codecFnInfo, reflect.Value)
|
||||
}
|
||||
|
||||
type fastpathA [{{ .FastpathLen }}]fastpathE
|
||||
type fastpathARtid [{{ .FastpathLen }}]uintptr
|
||||
|
||||
var fastpathAv fastpathA
|
||||
var fastpathAvRtid fastpathARtid
|
||||
|
||||
type fastpathAslice struct{}
|
||||
|
||||
func (fastpathAslice) Len() int { return {{ .FastpathLen }} }
|
||||
func (fastpathAslice) Less(i, j int) bool {
|
||||
return fastpathAvRtid[uint(i)] < fastpathAvRtid[uint(j)]
|
||||
}
|
||||
func (fastpathAslice) Swap(i, j int) {
|
||||
fastpathAvRtid[uint(i)], fastpathAvRtid[uint(j)] = fastpathAvRtid[uint(j)], fastpathAvRtid[uint(i)]
|
||||
fastpathAv[uint(i)], fastpathAv[uint(j)] = fastpathAv[uint(j)], fastpathAv[uint(i)]
|
||||
}
|
||||
|
||||
func fastpathAvIndex(rtid uintptr) int {
|
||||
// use binary search to grab the index (adapted from sort/search.go)
|
||||
// Note: we use goto (instead of for loop) so this can be inlined.
|
||||
// h, i, j := 0, 0, {{ .FastpathLen }}
|
||||
var h, i uint
|
||||
var j uint = {{ .FastpathLen }}
|
||||
LOOP:
|
||||
if i < j {
|
||||
h = (i + j) >> 1 // avoid overflow when computing h // h = i + (j-i)/2
|
||||
if fastpathAvRtid[h] < rtid {
|
||||
i = h + 1
|
||||
} else {
|
||||
j = h
|
||||
}
|
||||
goto LOOP
|
||||
}
|
||||
if i < {{ .FastpathLen }} && fastpathAvRtid[i] == rtid {
|
||||
return int(i)
|
||||
}
|
||||
return -1
|
||||
}
|
||||
|
||||
|
||||
// due to possible initialization loop error, make fastpath in an init()
|
||||
func init() {
|
||||
var i uint = 0
|
||||
fn := func(v interface{},
|
||||
fe func(*Encoder, *codecFnInfo, reflect.Value),
|
||||
fd func(*Decoder, *codecFnInfo, reflect.Value)) {
|
||||
xrt := reflect.TypeOf(v)
|
||||
xptr := rt2id(xrt)
|
||||
fastpathAvRtid[i] = xptr
|
||||
fastpathAv[i] = fastpathE{xrt, fe, fd}
|
||||
i++
|
||||
}
|
||||
{{/* do not register []byte in fast-path */}}
|
||||
{{range .Values}}{{if not .Primitive}}{{if not .MapKey }}{{if ne .Elem "uint8" -}}
|
||||
fn([]{{ .Elem }}(nil), (*Encoder).{{ .MethodNamePfx "fastpathEnc" false }}R, (*Decoder).{{ .MethodNamePfx "fastpathDec" false }}R)
|
||||
{{end}}{{end}}{{end}}{{end}}
|
||||
|
||||
{{range .Values}}{{if not .Primitive}}{{if .MapKey -}}
|
||||
fn(map[{{ .MapKey }}]{{ .Elem }}(nil), (*Encoder).{{ .MethodNamePfx "fastpathEnc" false }}R, (*Decoder).{{ .MethodNamePfx "fastpathDec" false }}R)
|
||||
{{end}}{{end}}{{end}}
|
||||
|
||||
sort.Sort(fastpathAslice{})
|
||||
}
|
||||
|
||||
// -- encode
|
||||
|
||||
// -- -- fast path type switch
|
||||
func fastpathEncodeTypeSwitch(iv interface{}, e *Encoder) bool {
|
||||
switch v := iv.(type) {
|
||||
{{range .Values}}{{if not .Primitive}}{{if not .MapKey }}{{if ne .Elem "uint8" -}}
|
||||
case []{{ .Elem }}:
|
||||
fastpathTV.{{ .MethodNamePfx "Enc" false }}V(v, e)
|
||||
case *[]{{ .Elem }}:
|
||||
if *v == nil {
|
||||
e.e.EncodeNil()
|
||||
} else {
|
||||
fastpathTV.{{ .MethodNamePfx "Enc" false }}V(*v, e)
|
||||
}
|
||||
{{end}}{{end}}{{end}}{{end -}}
|
||||
|
||||
{{range .Values}}{{if not .Primitive}}{{if .MapKey -}}
|
||||
case map[{{ .MapKey }}]{{ .Elem }}:
|
||||
fastpathTV.{{ .MethodNamePfx "Enc" false }}V(v, e)
|
||||
case *map[{{ .MapKey }}]{{ .Elem }}:
|
||||
if *v == nil {
|
||||
e.e.EncodeNil()
|
||||
} else {
|
||||
fastpathTV.{{ .MethodNamePfx "Enc" false }}V(*v, e)
|
||||
}
|
||||
{{end}}{{end}}{{end -}}
|
||||
|
||||
default:
|
||||
_ = v // workaround https://github.com/golang/go/issues/12927 seen in go1.4
|
||||
return false
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
// -- -- fast path functions
|
||||
{{range .Values}}{{if not .Primitive}}{{if not .MapKey -}}
|
||||
func (e *Encoder) {{ .MethodNamePfx "fastpathEnc" false }}R(f *codecFnInfo, rv reflect.Value) {
|
||||
if f.ti.mbs {
|
||||
fastpathTV.{{ .MethodNamePfx "EncAsMap" false }}V(rv2i(rv).([]{{ .Elem }}), e)
|
||||
} else {
|
||||
fastpathTV.{{ .MethodNamePfx "Enc" false }}V(rv2i(rv).([]{{ .Elem }}), e)
|
||||
}
|
||||
}
|
||||
func (fastpathT) {{ .MethodNamePfx "Enc" false }}V(v []{{ .Elem }}, e *Encoder) {
|
||||
{{/* if v == nil { e.e.EncodeNil(); return } */ -}}
|
||||
e.arrayStart(len(v))
|
||||
for j := range v {
|
||||
e.arrayElem()
|
||||
{{ encmd .Elem "v[j]"}}
|
||||
}
|
||||
e.arrayEnd()
|
||||
}
|
||||
func (fastpathT) {{ .MethodNamePfx "EncAsMap" false }}V(v []{{ .Elem }}, e *Encoder) {
|
||||
{{/* if v == nil { e.e.EncodeNil() } else */ -}}
|
||||
e.haltOnMbsOddLen(len(v))
|
||||
{{/*
|
||||
if len(v)&1 != 0 { // similar to &1==1 or %2 == 1
|
||||
e.errorf(fastpathMapBySliceErrMsg, len(v))
|
||||
}
|
||||
*/ -}}
|
||||
e.mapStart(len(v) >> 1) // e.mapStart(len(v) / 2)
|
||||
for j := range v {
|
||||
if j&1 == 0 { // if j%2 == 0 {
|
||||
e.mapElemKey()
|
||||
} else {
|
||||
e.mapElemValue()
|
||||
}
|
||||
{{ encmd .Elem "v[j]"}}
|
||||
}
|
||||
e.mapEnd()
|
||||
}
|
||||
{{end}}{{end}}{{end -}}
|
||||
|
||||
{{range .Values}}{{if not .Primitive}}{{if .MapKey -}}
|
||||
func (e *Encoder) {{ .MethodNamePfx "fastpathEnc" false }}R(f *codecFnInfo, rv reflect.Value) {
|
||||
fastpathTV.{{ .MethodNamePfx "Enc" false }}V(rv2i(rv).(map[{{ .MapKey }}]{{ .Elem }}), e)
|
||||
}
|
||||
func (fastpathT) {{ .MethodNamePfx "Enc" false }}V(v map[{{ .MapKey }}]{{ .Elem }}, e *Encoder) {
|
||||
{{/* if v == nil { e.e.EncodeNil(); return } */ -}}
|
||||
e.mapStart(len(v))
|
||||
if e.h.Canonical { {{/* need to figure out .NoCanonical */}}
|
||||
{{if eq .MapKey "interface{}"}}{{/* out of band */ -}}
|
||||
var mksv []byte = make([]byte, 0, len(v)*16) // temporary byte slice for the encoding
|
||||
e2 := NewEncoderBytes(&mksv, e.hh)
|
||||
v2 := make([]bytesIntf, len(v))
|
||||
var i, l uint {{/* put loop variables outside. seems currently needed for better perf */}}
|
||||
var vp *bytesIntf
|
||||
for k2 := range v {
|
||||
l = uint(len(mksv))
|
||||
e2.MustEncode(k2)
|
||||
vp = &v2[i]
|
||||
vp.v = mksv[l:]
|
||||
vp.i = k2
|
||||
i++
|
||||
}
|
||||
sort.Sort(bytesIntfSlice(v2))
|
||||
for j := range v2 {
|
||||
e.mapElemKey()
|
||||
e.asis(v2[j].v)
|
||||
e.mapElemValue()
|
||||
e.encode(v[v2[j].i])
|
||||
} {{else}}{{ $x := sorttype .MapKey true}}v2 := make([]{{ $x }}, len(v))
|
||||
var i uint
|
||||
for k := range v {
|
||||
v2[i] = {{if eq $x .MapKey}}k{{else}}{{ $x }}(k){{end}}
|
||||
i++
|
||||
}
|
||||
sort.Sort({{ sorttype .MapKey false}}(v2))
|
||||
for _, k2 := range v2 {
|
||||
e.mapElemKey()
|
||||
{{if eq .MapKey "string"}} e.e.EncodeString(k2) {{else}}{{ $y := printf "%s(k2)" .MapKey }}{{if eq $x .MapKey }}{{ $y = "k2" }}{{end}}{{ encmd .MapKey $y }}{{end}}
|
||||
e.mapElemValue()
|
||||
{{ $y := printf "v[%s(k2)]" .MapKey }}{{if eq $x .MapKey }}{{ $y = "v[k2]" }}{{end}}{{ encmd .Elem $y }}
|
||||
} {{end}}
|
||||
} else {
|
||||
for k2, v2 := range v {
|
||||
e.mapElemKey()
|
||||
{{if eq .MapKey "string"}} e.e.EncodeString(k2) {{else}}{{ encmd .MapKey "k2"}}{{end}}
|
||||
e.mapElemValue()
|
||||
{{ encmd .Elem "v2"}}
|
||||
}
|
||||
}
|
||||
e.mapEnd()
|
||||
}
|
||||
{{end}}{{end}}{{end -}}
|
||||
|
||||
// -- decode
|
||||
|
||||
// -- -- fast path type switch
|
||||
func fastpathDecodeTypeSwitch(iv interface{}, d *Decoder) bool {
|
||||
var changed bool
|
||||
var containerLen int
|
||||
switch v := iv.(type) {
|
||||
{{range .Values}}{{if not .Primitive}}{{if not .MapKey }}{{if ne .Elem "uint8" -}}
|
||||
case []{{ .Elem }}:
|
||||
fastpathTV.{{ .MethodNamePfx "Dec" false }}N(v, d)
|
||||
case *[]{{ .Elem }}:
|
||||
var v2 []{{ .Elem }}
|
||||
if v2, changed = fastpathTV.{{ .MethodNamePfx "Dec" false }}Y(*v, d); changed {
|
||||
*v = v2
|
||||
}
|
||||
{{end}}{{end}}{{end}}{{end -}}
|
||||
{{range .Values}}{{if not .Primitive}}{{if .MapKey }}{{/*
|
||||
// maps only change if nil, and in that case, there's no point copying
|
||||
*/ -}}
|
||||
case map[{{ .MapKey }}]{{ .Elem }}:
|
||||
containerLen = d.mapStart()
|
||||
if containerLen != containerLenNil {
|
||||
if containerLen != 0 {
|
||||
fastpathTV.{{ .MethodNamePfx "Dec" false }}L(v, containerLen, d)
|
||||
}
|
||||
d.mapEnd()
|
||||
}
|
||||
case *map[{{ .MapKey }}]{{ .Elem }}:
|
||||
{{/*
|
||||
containerLen = d.mapStart()
|
||||
if containerLen == 0 {
|
||||
d.mapEnd()
|
||||
} else if containerLen == containerLenNil {
|
||||
*v = nil
|
||||
} else {
|
||||
if *v == nil {
|
||||
*v = make(map[{{ .MapKey }}]{{ .Elem }}, decInferLen(containerLen, d.h.MaxInitLen, {{ .Size }}))
|
||||
}
|
||||
fastpathTV.{{ .MethodNamePfx "Dec" false }}L(*v, containerLen, d)
|
||||
}
|
||||
// consider delegating fully to X - encoding *map is uncommon, so ok to pay small function call cost
|
||||
*/ -}}
|
||||
fastpathTV.{{ .MethodNamePfx "Dec" false }}X(v, d)
|
||||
{{end}}{{end}}{{end -}}
|
||||
default:
|
||||
_ = v // workaround https://github.com/golang/go/issues/12927 seen in go1.4
|
||||
return false
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
func fastpathDecodeSetZeroTypeSwitch(iv interface{}) bool {
|
||||
switch v := iv.(type) {
|
||||
{{range .Values}}{{if not .Primitive}}{{if not .MapKey -}}
|
||||
case *[]{{ .Elem }}:
|
||||
*v = nil
|
||||
{{end}}{{end}}{{end}}
|
||||
{{range .Values}}{{if not .Primitive}}{{if .MapKey -}}
|
||||
case *map[{{ .MapKey }}]{{ .Elem }}:
|
||||
*v = nil
|
||||
{{end}}{{end}}{{end}}
|
||||
default:
|
||||
_ = v // workaround https://github.com/golang/go/issues/12927 seen in go1.4
|
||||
return false
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
// -- -- fast path functions
|
||||
{{range .Values}}{{if not .Primitive}}{{if not .MapKey -}}
|
||||
{{/*
|
||||
Slices can change if they
|
||||
- did not come from an array
|
||||
- are addressable (from a ptr)
|
||||
- are settable (e.g. contained in an interface{})
|
||||
*/}}
|
||||
func (d *Decoder) {{ .MethodNamePfx "fastpathDec" false }}R(f *codecFnInfo, rv reflect.Value) {
|
||||
if f.seq != seqTypeArray && rv.Kind() == reflect.Ptr {
|
||||
vp := rv2i(rv).(*[]{{ .Elem }})
|
||||
if v, changed := fastpathTV.{{ .MethodNamePfx "Dec" false }}Y(*vp, d); changed { *vp = v }
|
||||
} else {
|
||||
fastpathTV.{{ .MethodNamePfx "Dec" false }}N(rv2i(rv).([]{{ .Elem }}), d)
|
||||
}
|
||||
}
|
||||
func (f fastpathT) {{ .MethodNamePfx "Dec" false }}X(vp *[]{{ .Elem }}, d *Decoder) {
|
||||
if v, changed := f.{{ .MethodNamePfx "Dec" false }}Y(*vp, d); changed { *vp = v }
|
||||
}
|
||||
func (fastpathT) {{ .MethodNamePfx "Dec" false }}Y(v []{{ .Elem }}, d *Decoder) (_ []{{ .Elem }}, changed bool) {
|
||||
slh, containerLenS := d.decSliceHelperStart()
|
||||
if slh.IsNil {
|
||||
if v == nil { return }
|
||||
return nil, true
|
||||
}
|
||||
if containerLenS == 0 {
|
||||
if v == nil { v = []{{ .Elem }}{} } else if len(v) != 0 { v = v[:0] }
|
||||
slh.End()
|
||||
return v, true
|
||||
}
|
||||
hasLen := containerLenS > 0
|
||||
var xlen int
|
||||
if hasLen {
|
||||
if containerLenS > cap(v) {
|
||||
xlen = decInferLen(containerLenS, d.h.MaxInitLen, {{ .Size }})
|
||||
if xlen <= cap(v) {
|
||||
v = v[:uint(xlen)]
|
||||
} else {
|
||||
v = make([]{{ .Elem }}, uint(xlen))
|
||||
}
|
||||
changed = true
|
||||
} else if containerLenS != len(v) {
|
||||
v = v[:containerLenS]
|
||||
changed = true
|
||||
}
|
||||
}
|
||||
var j int
|
||||
for j = 0; (hasLen && j < containerLenS) || !(hasLen || d.checkBreak()); j++ {
|
||||
if j == 0 && len(v) == 0 { // means hasLen == false
|
||||
xlen = decDefSliceCap
|
||||
v = make([]{{ .Elem }}, uint(xlen))
|
||||
changed = true
|
||||
}
|
||||
{{/* // if indefinite, etc, then expand the slice if necessary */ -}}
|
||||
if j >= len(v) {
|
||||
v = append(v, {{ zerocmd .Elem }})
|
||||
changed = true
|
||||
}
|
||||
slh.ElemContainerState(j)
|
||||
{{ if eq .Elem "interface{}" }}d.decode(&v[uint(j)]){{ else }}v[uint(j)] = {{ decmd .Elem false }}{{ end }}
|
||||
}
|
||||
if j < len(v) {
|
||||
v = v[:uint(j)]
|
||||
changed = true
|
||||
} else if j == 0 && v == nil {
|
||||
v = []{{ .Elem }}{}
|
||||
changed = true
|
||||
}
|
||||
slh.End()
|
||||
return v, changed
|
||||
}
|
||||
func (fastpathT) {{ .MethodNamePfx "Dec" false }}N(v []{{ .Elem }}, d *Decoder) {
|
||||
slh, containerLenS := d.decSliceHelperStart()
|
||||
if slh.IsNil {
|
||||
return
|
||||
}
|
||||
if containerLenS == 0 {
|
||||
slh.End()
|
||||
return
|
||||
}
|
||||
hasLen := containerLenS > 0
|
||||
for j := 0; (hasLen && j < containerLenS) || !(hasLen || d.checkBreak()); j++ {
|
||||
{{/* // if indefinite, etc, then expand the slice if necessary */ -}}
|
||||
if j >= len(v) {
|
||||
decArrayCannotExpand(slh, hasLen, len(v), j, containerLenS)
|
||||
return
|
||||
}
|
||||
slh.ElemContainerState(j)
|
||||
{{ if eq .Elem "interface{}" -}}
|
||||
d.decode(&v[uint(j)])
|
||||
{{- else -}}
|
||||
v[uint(j)] = {{ decmd .Elem false }}
|
||||
{{- end }}
|
||||
}
|
||||
slh.End()
|
||||
}
|
||||
{{end}}{{end}}{{end -}}
|
||||
|
||||
{{range .Values}}{{if not .Primitive}}{{if .MapKey -}}
|
||||
{{/*
|
||||
Maps can change if they are
|
||||
- addressable (from a ptr)
|
||||
- settable (e.g. contained in an interface{})
|
||||
|
||||
Also, these methods are called by decodeValue directly, after handling a TryNil.
|
||||
Consequently, there's no need to check for containerLenNil here.
|
||||
*/ -}}
|
||||
func (d *Decoder) {{ .MethodNamePfx "fastpathDec" false }}R(f *codecFnInfo, rv reflect.Value) {
|
||||
containerLen := d.mapStart()
|
||||
{{/*
|
||||
if containerLen == containerLenNil {
|
||||
if rv.Kind() == reflect.Ptr {
|
||||
*(rv2i(rv).(*map[{{ .MapKey }}]{{ .Elem }})) = nil
|
||||
}
|
||||
return
|
||||
}
|
||||
*/ -}}
|
||||
if rv.Kind() == reflect.Ptr {
|
||||
vp, _ := rv2i(rv).(*map[{{ .MapKey }}]{{ .Elem }})
|
||||
if *vp == nil {
|
||||
*vp = make(map[{{ .MapKey }}]{{ .Elem }}, decInferLen(containerLen, d.h.MaxInitLen, {{ .Size }}))
|
||||
}
|
||||
if containerLen != 0 {
|
||||
fastpathTV.{{ .MethodNamePfx "Dec" false }}L(*vp, containerLen, d)
|
||||
}
|
||||
} else if containerLen != 0 {
|
||||
fastpathTV.{{ .MethodNamePfx "Dec" false }}L(rv2i(rv).(map[{{ .MapKey }}]{{ .Elem }}), containerLen, d)
|
||||
}
|
||||
d.mapEnd()
|
||||
}
|
||||
func (f fastpathT) {{ .MethodNamePfx "Dec" false }}X(vp *map[{{ .MapKey }}]{{ .Elem }}, d *Decoder) {
|
||||
containerLen := d.mapStart()
|
||||
if containerLen == containerLenNil {
|
||||
*vp = nil
|
||||
} else {
|
||||
if *vp == nil {
|
||||
*vp = make(map[{{ .MapKey }}]{{ .Elem }}, decInferLen(containerLen, d.h.MaxInitLen, {{ .Size }}))
|
||||
}
|
||||
if containerLen != 0 {
|
||||
f.{{ .MethodNamePfx "Dec" false }}L(*vp, containerLen, d)
|
||||
}
|
||||
d.mapEnd()
|
||||
}
|
||||
}
|
||||
func (fastpathT) {{ .MethodNamePfx "Dec" false }}L(v map[{{ .MapKey }}]{{ .Elem }}, containerLen int, d *Decoder) {
|
||||
{{/* No need to check if containerLen == containerLenNil, as that is checked by R and L above */ -}}
|
||||
{{if eq .Elem "interface{}" }}mapGet := v != nil && !d.h.MapValueReset && !d.h.InterfaceReset
|
||||
{{else if eq .Elem "bytes" "[]byte" }}mapGet := v != nil && !d.h.MapValueReset
|
||||
{{end -}}
|
||||
var mk {{ .MapKey }}
|
||||
var mv {{ .Elem }}
|
||||
hasLen := containerLen > 0
|
||||
for j := 0; (hasLen && j < containerLen) || !(hasLen || d.checkBreak()); j++ {
|
||||
d.mapElemKey()
|
||||
{{ if eq .MapKey "interface{}" }}mk = nil
|
||||
d.decode(&mk)
|
||||
if bv, bok := mk.([]byte); bok {
|
||||
mk = d.stringZC(bv) {{/* // maps cannot have []byte as key. switch to string. */}}
|
||||
}{{ else }}mk = {{ decmd .MapKey true }}{{ end }}
|
||||
d.mapElemValue()
|
||||
{{ if eq .Elem "interface{}" "[]byte" "bytes" -}}
|
||||
if mapGet { mv = v[mk] } else { mv = nil }
|
||||
{{ end -}}
|
||||
{{ if eq .Elem "interface{}" -}}
|
||||
d.decode(&mv)
|
||||
{{ else if eq .Elem "[]byte" "bytes" -}}
|
||||
mv = d.decodeBytesInto(mv)
|
||||
{{ else -}}
|
||||
mv = {{ decmd .Elem false }}
|
||||
{{ end -}}
|
||||
if v != nil { v[mk] = mv }
|
||||
}
|
||||
}
|
||||
{{end}}{{end}}{{end}}
|
43
vendor/github.com/ugorji/go/codec/fast-path.not.go
generated
vendored
Normal file
43
vendor/github.com/ugorji/go/codec/fast-path.not.go
generated
vendored
Normal file
|
@ -0,0 +1,43 @@
|
|||
// Copyright (c) 2012-2020 Ugorji Nwoke. All rights reserved.
|
||||
// Use of this source code is governed by a MIT license found in the LICENSE file.
|
||||
|
||||
// +build notfastpath
|
||||
|
||||
package codec
|
||||
|
||||
import "reflect"
|
||||
|
||||
const fastpathEnabled = false
|
||||
|
||||
// The generated fast-path code is very large, and adds a few seconds to the build time.
|
||||
// This causes test execution, execution of small tools which use codec, etc
|
||||
// to take a long time.
|
||||
//
|
||||
// To mitigate, we now support the notfastpath tag.
|
||||
// This tag disables fastpath during build, allowing for faster build, test execution,
|
||||
// short-program runs, etc.
|
||||
|
||||
func fastpathDecodeTypeSwitch(iv interface{}, d *Decoder) bool { return false }
|
||||
func fastpathEncodeTypeSwitch(iv interface{}, e *Encoder) bool { return false }
|
||||
|
||||
// func fastpathEncodeTypeSwitchSlice(iv interface{}, e *Encoder) bool { return false }
|
||||
// func fastpathEncodeTypeSwitchMap(iv interface{}, e *Encoder) bool { return false }
|
||||
|
||||
func fastpathDecodeSetZeroTypeSwitch(iv interface{}) bool { return false }
|
||||
|
||||
type fastpathT struct{}
|
||||
type fastpathE struct {
|
||||
rtid uintptr
|
||||
rt reflect.Type
|
||||
encfn func(*Encoder, *codecFnInfo, reflect.Value)
|
||||
decfn func(*Decoder, *codecFnInfo, reflect.Value)
|
||||
}
|
||||
type fastpathA [0]fastpathE
|
||||
|
||||
func fastpathAvIndex(rtid uintptr) int { return -1 }
|
||||
|
||||
var fastpathAv fastpathA
|
||||
var fastpathTV fastpathT
|
||||
|
||||
// ----
|
||||
type TestMammoth2Wrapper struct{} // to allow testMammoth work in notfastpath mode
|
90
vendor/github.com/ugorji/go/codec/gen-dec-array.go.tmpl
generated
vendored
Normal file
90
vendor/github.com/ugorji/go/codec/gen-dec-array.go.tmpl
generated
vendored
Normal file
|
@ -0,0 +1,90 @@
|
|||
{{var "v"}} := {{if not isArray}}*{{end}}{{ .Varname }}
|
||||
{{var "h"}}, {{var "l"}} := z.DecSliceHelperStart() {{/* // helper, containerLenS */}}
|
||||
{{if not isArray -}}
|
||||
var {{var "c"}} bool {{/* // changed */}}
|
||||
_ = {{var "c"}}
|
||||
if {{var "h"}}.IsNil {
|
||||
if {{var "v"}} != nil {
|
||||
{{var "v"}} = nil
|
||||
{{var "c"}} = true
|
||||
}
|
||||
} else {{end -}}
|
||||
if {{var "l"}} == 0 {
|
||||
{{if isSlice -}}
|
||||
if {{var "v"}} == nil {
|
||||
{{var "v"}} = []{{ .Typ }}{}
|
||||
{{var "c"}} = true
|
||||
} else if len({{var "v"}}) != 0 {
|
||||
{{var "v"}} = {{var "v"}}[:0]
|
||||
{{var "c"}} = true
|
||||
} {{else if isChan }}if {{var "v"}} == nil {
|
||||
{{var "v"}} = make({{ .CTyp }}, 0)
|
||||
{{var "c"}} = true
|
||||
}
|
||||
{{end -}}
|
||||
} else {
|
||||
{{var "hl"}} := {{var "l"}} > 0
|
||||
var {{var "rl"}} int
|
||||
_ = {{var "rl"}}
|
||||
{{if isSlice }} if {{var "hl"}} {
|
||||
if {{var "l"}} > cap({{var "v"}}) {
|
||||
{{var "rl"}} = z.DecInferLen({{var "l"}}, z.DecBasicHandle().MaxInitLen, {{ .Size }})
|
||||
if {{var "rl"}} <= cap({{var "v"}}) {
|
||||
{{var "v"}} = {{var "v"}}[:{{var "rl"}}]
|
||||
} else {
|
||||
{{var "v"}} = make([]{{ .Typ }}, {{var "rl"}})
|
||||
}
|
||||
{{var "c"}} = true
|
||||
} else if {{var "l"}} != len({{var "v"}}) {
|
||||
{{var "v"}} = {{var "v"}}[:{{var "l"}}]
|
||||
{{var "c"}} = true
|
||||
}
|
||||
}
|
||||
{{end -}}
|
||||
var {{var "j"}} int
|
||||
{{/* // var {{var "dn"}} bool */ -}}
|
||||
for {{var "j"}} = 0; ({{var "hl"}} && {{var "j"}} < {{var "l"}}) || !({{var "hl"}} || z.DecCheckBreak()); {{var "j"}}++ { // bounds-check-elimination
|
||||
{{if not isArray}} if {{var "j"}} == 0 && {{var "v"}} == nil {
|
||||
if {{var "hl"}} {
|
||||
{{var "rl"}} = z.DecInferLen({{var "l"}}, z.DecBasicHandle().MaxInitLen, {{ .Size }})
|
||||
} else {
|
||||
{{var "rl"}} = {{if isSlice}}8{{else if isChan}}64{{end}}
|
||||
}
|
||||
{{var "v"}} = make({{if isSlice}}[]{{ .Typ }}{{else if isChan}}{{.CTyp}}{{end}}, {{var "rl"}})
|
||||
{{var "c"}} = true
|
||||
}
|
||||
{{end -}}
|
||||
{{var "h"}}.ElemContainerState({{var "j"}})
|
||||
{{/* {{var "dn"}} = r.TryDecodeAsNil() */}}{{/* commented out, as decLineVar handles this already each time */ -}}
|
||||
{{if isChan}}{{ $x := printf "%[1]vvcx%[2]v" .TempVar .Rand }}var {{$x}} {{ .Typ }}
|
||||
{{ decLineVar $x -}}
|
||||
{{var "v"}} <- {{ $x }}
|
||||
{{else}}{{/* // if indefinite, etc, then expand the slice if necessary */ -}}
|
||||
var {{var "db"}} bool
|
||||
if {{var "j"}} >= len({{var "v"}}) {
|
||||
{{if isSlice }} {{var "v"}} = append({{var "v"}}, {{ zero }})
|
||||
{{var "c"}} = true
|
||||
{{else}} z.DecArrayCannotExpand(len(v), {{var "j"}}+1); {{var "db"}} = true
|
||||
{{end -}}
|
||||
}
|
||||
if {{var "db"}} {
|
||||
z.DecSwallow()
|
||||
} else {
|
||||
{{ $x := printf "%[1]vv%[2]v[%[1]vj%[2]v]" .TempVar .Rand }}{{ decLineVar $x -}}
|
||||
}
|
||||
{{end -}}
|
||||
}
|
||||
{{if isSlice}} if {{var "j"}} < len({{var "v"}}) {
|
||||
{{var "v"}} = {{var "v"}}[:{{var "j"}}]
|
||||
{{var "c"}} = true
|
||||
} else if {{var "j"}} == 0 && {{var "v"}} == nil {
|
||||
{{var "v"}} = make([]{{ .Typ }}, 0)
|
||||
{{var "c"}} = true
|
||||
}
|
||||
{{end -}}
|
||||
}
|
||||
{{var "h"}}.End()
|
||||
{{if not isArray }}if {{var "c"}} {
|
||||
*{{ .Varname }} = {{var "v"}}
|
||||
}
|
||||
{{end -}}
|
58
vendor/github.com/ugorji/go/codec/gen-dec-map.go.tmpl
generated
vendored
Normal file
58
vendor/github.com/ugorji/go/codec/gen-dec-map.go.tmpl
generated
vendored
Normal file
|
@ -0,0 +1,58 @@
|
|||
{{var "v"}} := *{{ .Varname }}
|
||||
{{var "l"}} := z.DecReadMapStart()
|
||||
if {{var "l"}} == codecSelferDecContainerLenNil{{xs}} {
|
||||
*{{ .Varname }} = nil
|
||||
} else {
|
||||
if {{var "v"}} == nil {
|
||||
{{var "rl"}} := z.DecInferLen({{var "l"}}, z.DecBasicHandle().MaxInitLen, {{ .Size }})
|
||||
{{var "v"}} = make(map[{{ .KTyp }}]{{ .Typ }}, {{var "rl"}})
|
||||
*{{ .Varname }} = {{var "v"}}
|
||||
}
|
||||
{{ $mk := var "mk" -}}
|
||||
var {{ $mk }} {{ .KTyp }}
|
||||
var {{var "mv"}} {{ .Typ }}
|
||||
var {{var "mg"}}, {{var "mdn"}} {{if decElemKindPtr}}, {{var "ms"}}, {{var "mok"}}{{end}} bool
|
||||
if z.DecBasicHandle().MapValueReset {
|
||||
{{if decElemKindPtr}}{{var "mg"}} = true
|
||||
{{else if decElemKindIntf}}if !z.DecBasicHandle().InterfaceReset { {{var "mg"}} = true }
|
||||
{{else if not decElemKindImmutable}}{{var "mg"}} = true
|
||||
{{end}} }
|
||||
if {{var "l"}} != 0 {
|
||||
{{var "hl"}} := {{var "l"}} > 0
|
||||
for {{var "j"}} := 0; ({{var "hl"}} && {{var "j"}} < {{var "l"}}) || !({{var "hl"}} || z.DecCheckBreak()); {{var "j"}}++ {
|
||||
z.DecReadMapElemKey()
|
||||
{{ if eq .KTyp "string" -}}
|
||||
{{ decLineVarK $mk -}}{{- /* decLineVarKStrZC $mk */ -}}
|
||||
{{ else -}}
|
||||
{{ decLineVarK $mk -}}
|
||||
{{ end -}}
|
||||
{{ if eq .KTyp "interface{}" }}{{/* // special case if a byte array. */ -}}
|
||||
if {{var "bv"}}, {{var "bok"}} := {{var "mk"}}.([]byte); {{var "bok"}} {
|
||||
{{var "mk"}} = z.DecStringZC({{var "bv"}})
|
||||
}
|
||||
{{ end -}}
|
||||
{{if decElemKindPtr -}}
|
||||
{{var "ms"}} = true
|
||||
{{end -}}
|
||||
if {{var "mg"}} {
|
||||
{{if decElemKindPtr -}}
|
||||
{{var "mv"}}, {{var "mok"}} = {{var "v"}}[{{ $mk }}]
|
||||
if {{var "mok"}} {
|
||||
{{var "ms"}} = false
|
||||
}
|
||||
{{else -}}
|
||||
{{var "mv"}} = {{var "v"}}[{{ $mk }}]
|
||||
{{end -}}
|
||||
} {{if not decElemKindImmutable}}else { {{var "mv"}} = {{decElemZero}} }{{end}}
|
||||
z.DecReadMapElemValue()
|
||||
{{var "mdn"}} = false
|
||||
{{ $x := printf "%vmv%v" .TempVar .Rand }}{{ $y := printf "%vmdn%v" .TempVar .Rand }}{{ decLineVar $x $y -}}
|
||||
if {{var "mdn"}} {
|
||||
{{var "v"}}[{{ $mk }}] = {{decElemZero}}
|
||||
} else {{if decElemKindPtr}} if {{var "ms"}} {{end}} {
|
||||
{{var "v"}}[{{ $mk }}] = {{var "mv"}}
|
||||
}
|
||||
}
|
||||
} // else len==0: leave as-is (do not clear map entries)
|
||||
z.DecReadMapEnd()
|
||||
}
|
27
vendor/github.com/ugorji/go/codec/gen-enc-chan.go.tmpl
generated
vendored
Normal file
27
vendor/github.com/ugorji/go/codec/gen-enc-chan.go.tmpl
generated
vendored
Normal file
|
@ -0,0 +1,27 @@
|
|||
{{.Label}}:
|
||||
switch timeout{{.Sfx}} := z.EncBasicHandle().ChanRecvTimeout; {
|
||||
case timeout{{.Sfx}} == 0: // only consume available
|
||||
for {
|
||||
select {
|
||||
case b{{.Sfx}} := <-{{.Chan}}:
|
||||
{{ .Slice }} = append({{.Slice}}, b{{.Sfx}})
|
||||
default:
|
||||
break {{.Label}}
|
||||
}
|
||||
}
|
||||
case timeout{{.Sfx}} > 0: // consume until timeout
|
||||
tt{{.Sfx}} := time.NewTimer(timeout{{.Sfx}})
|
||||
for {
|
||||
select {
|
||||
case b{{.Sfx}} := <-{{.Chan}}:
|
||||
{{.Slice}} = append({{.Slice}}, b{{.Sfx}})
|
||||
case <-tt{{.Sfx}}.C:
|
||||
// close(tt.C)
|
||||
break {{.Label}}
|
||||
}
|
||||
}
|
||||
default: // consume until close
|
||||
for b{{.Sfx}} := range {{.Chan}} {
|
||||
{{.Slice}} = append({{.Slice}}, b{{.Sfx}})
|
||||
}
|
||||
}
|
270
vendor/github.com/ugorji/go/codec/gen-helper.generated.go
generated
vendored
Normal file
270
vendor/github.com/ugorji/go/codec/gen-helper.generated.go
generated
vendored
Normal file
|
@ -0,0 +1,270 @@
|
|||
// comment this out // + build ignore
|
||||
|
||||
// Copyright (c) 2012-2020 Ugorji Nwoke. All rights reserved.
|
||||
// Use of this source code is governed by a MIT license found in the LICENSE file.
|
||||
|
||||
// Code generated from gen-helper.go.tmpl - DO NOT EDIT.
|
||||
|
||||
package codec
|
||||
|
||||
import "encoding"
|
||||
|
||||
// GenVersion is the current version of codecgen.
|
||||
const GenVersion = 21
|
||||
|
||||
// This file is used to generate helper code for codecgen.
|
||||
// The values here i.e. genHelper(En|De)coder are not to be used directly by
|
||||
// library users. They WILL change continuously and without notice.
|
||||
|
||||
// GenHelperEncoder is exported so that it can be used externally by codecgen.
|
||||
//
|
||||
// Library users: DO NOT USE IT DIRECTLY or INDIRECTLY. IT WILL CHANGE CONTINOUSLY WITHOUT NOTICE.
|
||||
func GenHelper() (g genHelper) { return }
|
||||
|
||||
type genHelper struct{}
|
||||
|
||||
func (genHelper) Encoder(e *Encoder) (ge genHelperEncoder, ee genHelperEncDriver) {
|
||||
ge = genHelperEncoder{e: e}
|
||||
ee = genHelperEncDriver{encDriver: e.e}
|
||||
return
|
||||
}
|
||||
|
||||
func (genHelper) Decoder(d *Decoder) (gd genHelperDecoder, dd genHelperDecDriver) {
|
||||
gd = genHelperDecoder{d: d}
|
||||
dd = genHelperDecDriver{decDriver: d.d}
|
||||
return
|
||||
}
|
||||
|
||||
type genHelperEncDriver struct {
|
||||
encDriver
|
||||
}
|
||||
|
||||
type genHelperDecDriver struct {
|
||||
decDriver
|
||||
}
|
||||
|
||||
// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
|
||||
type genHelperEncoder struct {
|
||||
M mustHdl
|
||||
F fastpathT
|
||||
e *Encoder
|
||||
}
|
||||
|
||||
// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
|
||||
type genHelperDecoder struct {
|
||||
C checkOverflow
|
||||
F fastpathT
|
||||
d *Decoder
|
||||
}
|
||||
|
||||
// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
|
||||
func (f genHelperEncoder) EncBasicHandle() *BasicHandle {
|
||||
return f.e.h
|
||||
}
|
||||
|
||||
// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
|
||||
func (f genHelperEncoder) EncBinary() bool {
|
||||
return f.e.be // f.e.hh.isBinaryEncoding()
|
||||
}
|
||||
|
||||
// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
|
||||
func (f genHelperEncoder) IsJSONHandle() bool {
|
||||
return f.e.js
|
||||
}
|
||||
|
||||
// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
|
||||
func (f genHelperEncoder) EncFallback(iv interface{}) {
|
||||
// f.e.encodeI(iv, false, false)
|
||||
f.e.encodeValue(rv4i(iv), nil)
|
||||
}
|
||||
|
||||
// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
|
||||
func (f genHelperEncoder) EncTextMarshal(iv encoding.TextMarshaler) {
|
||||
bs, fnerr := iv.MarshalText()
|
||||
f.e.marshalUtf8(bs, fnerr)
|
||||
}
|
||||
|
||||
// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
|
||||
func (f genHelperEncoder) EncJSONMarshal(iv jsonMarshaler) {
|
||||
bs, fnerr := iv.MarshalJSON()
|
||||
f.e.marshalAsis(bs, fnerr)
|
||||
}
|
||||
|
||||
// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
|
||||
func (f genHelperEncoder) EncBinaryMarshal(iv encoding.BinaryMarshaler) {
|
||||
bs, fnerr := iv.MarshalBinary()
|
||||
f.e.marshalRaw(bs, fnerr)
|
||||
}
|
||||
|
||||
// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
|
||||
func (f genHelperEncoder) EncRaw(iv Raw) { f.e.rawBytes(iv) }
|
||||
|
||||
// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
|
||||
func (f genHelperEncoder) Extension(v interface{}) (xfn *extTypeTagFn) {
|
||||
return f.e.h.getExtForI(v)
|
||||
}
|
||||
|
||||
// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
|
||||
func (f genHelperEncoder) EncExtension(v interface{}, xfFn *extTypeTagFn) {
|
||||
f.e.e.EncodeExt(v, xfFn.tag, xfFn.ext)
|
||||
}
|
||||
|
||||
// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
|
||||
func (f genHelperEncoder) WriteStr(s string) {
|
||||
f.e.w().writestr(s)
|
||||
}
|
||||
|
||||
// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
|
||||
func (f genHelperEncoder) EncWriteMapStart(length int) { f.e.mapStart(length) }
|
||||
|
||||
// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
|
||||
func (f genHelperEncoder) EncWriteMapEnd() { f.e.mapEnd() }
|
||||
|
||||
// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
|
||||
func (f genHelperEncoder) EncWriteArrayStart(length int) { f.e.arrayStart(length) }
|
||||
|
||||
// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
|
||||
func (f genHelperEncoder) EncWriteArrayEnd() { f.e.arrayEnd() }
|
||||
|
||||
// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
|
||||
func (f genHelperEncoder) EncWriteArrayElem() { f.e.arrayElem() }
|
||||
|
||||
// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
|
||||
func (f genHelperEncoder) EncWriteMapElemKey() { f.e.mapElemKey() }
|
||||
|
||||
// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
|
||||
func (f genHelperEncoder) EncWriteMapElemValue() { f.e.mapElemValue() }
|
||||
|
||||
// ---------------- DECODER FOLLOWS -----------------
|
||||
|
||||
// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
|
||||
func (f genHelperDecoder) DecBasicHandle() *BasicHandle {
|
||||
return f.d.h
|
||||
}
|
||||
|
||||
// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
|
||||
func (f genHelperDecoder) DecBinary() bool {
|
||||
return f.d.be // f.d.hh.isBinaryEncoding()
|
||||
}
|
||||
|
||||
// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
|
||||
func (f genHelperDecoder) DecSwallow() { f.d.swallow() }
|
||||
|
||||
// // FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
|
||||
// func (f genHelperDecoder) DecScratchBuffer() []byte {
|
||||
// return f.d.b[:]
|
||||
// }
|
||||
|
||||
// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
|
||||
func (f genHelperDecoder) DecScratchArrayBuffer() *[decScratchByteArrayLen]byte {
|
||||
return &f.d.b
|
||||
}
|
||||
|
||||
// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
|
||||
func (f genHelperDecoder) DecFallback(iv interface{}, chkPtr bool) {
|
||||
rv := rv4i(iv)
|
||||
if chkPtr && !isDecodeable(rv) {
|
||||
f.d.haltAsNotDecodeable(rv)
|
||||
}
|
||||
f.d.decodeValue(rv, nil)
|
||||
}
|
||||
|
||||
// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
|
||||
func (f genHelperDecoder) DecSliceHelperStart() (decSliceHelper, int) {
|
||||
return f.d.decSliceHelperStart()
|
||||
}
|
||||
|
||||
// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
|
||||
func (f genHelperDecoder) DecStructFieldNotFound(index int, name string) {
|
||||
f.d.structFieldNotFound(index, name)
|
||||
}
|
||||
|
||||
// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
|
||||
func (f genHelperDecoder) DecArrayCannotExpand(sliceLen, streamLen int) {
|
||||
f.d.arrayCannotExpand(sliceLen, streamLen)
|
||||
}
|
||||
|
||||
// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
|
||||
func (f genHelperDecoder) DecTextUnmarshal(tm encoding.TextUnmarshaler) {
|
||||
halt.onerror(tm.UnmarshalText(f.d.d.DecodeStringAsBytes()))
|
||||
}
|
||||
|
||||
// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
|
||||
func (f genHelperDecoder) DecJSONUnmarshal(tm jsonUnmarshaler) {
|
||||
// bs := f.dd.DecodeStringAsBytes()
|
||||
// grab the bytes to be read, as UnmarshalJSON needs the full JSON so as to unmarshal it itself.
|
||||
bs := f.d.blist.get(256)
|
||||
bs = f.d.d.nextValueBytes(bs)
|
||||
fnerr := tm.UnmarshalJSON(bs)
|
||||
f.d.blist.put(bs)
|
||||
halt.onerror(fnerr)
|
||||
}
|
||||
|
||||
// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
|
||||
func (f genHelperDecoder) DecBinaryUnmarshal(bm encoding.BinaryUnmarshaler) {
|
||||
halt.onerror(bm.UnmarshalBinary(f.d.d.DecodeBytes(nil)))
|
||||
}
|
||||
|
||||
// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
|
||||
func (f genHelperDecoder) DecRaw() []byte { return f.d.rawBytes() }
|
||||
|
||||
// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
|
||||
func (f genHelperDecoder) IsJSONHandle() bool {
|
||||
return f.d.js
|
||||
}
|
||||
|
||||
// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
|
||||
func (f genHelperDecoder) I2Rtid(v interface{}) uintptr {
|
||||
return i2rtid(v)
|
||||
}
|
||||
|
||||
// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
|
||||
func (f genHelperDecoder) Extension(v interface{}) (xfn *extTypeTagFn) {
|
||||
return f.d.h.getExtForI(v)
|
||||
}
|
||||
|
||||
// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
|
||||
func (f genHelperDecoder) DecExtension(v interface{}, xfFn *extTypeTagFn) {
|
||||
f.d.d.DecodeExt(v, xfFn.tag, xfFn.ext)
|
||||
}
|
||||
|
||||
// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
|
||||
func (f genHelperDecoder) DecInferLen(clen, maxlen, unit int) (rvlen int) {
|
||||
return decInferLen(clen, maxlen, unit)
|
||||
}
|
||||
|
||||
// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
|
||||
func (f genHelperDecoder) StringView(v []byte) string { return stringView(v) }
|
||||
|
||||
// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
|
||||
func (f genHelperDecoder) DecReadMapStart() int { return f.d.mapStart() }
|
||||
|
||||
// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
|
||||
func (f genHelperDecoder) DecReadMapEnd() { f.d.mapEnd() }
|
||||
|
||||
// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
|
||||
func (f genHelperDecoder) DecReadArrayStart() int { return f.d.arrayStart() }
|
||||
|
||||
// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
|
||||
func (f genHelperDecoder) DecReadArrayEnd() { f.d.arrayEnd() }
|
||||
|
||||
// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
|
||||
func (f genHelperDecoder) DecReadArrayElem() { f.d.arrayElem() }
|
||||
|
||||
// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
|
||||
func (f genHelperDecoder) DecReadMapElemKey() { f.d.mapElemKey() }
|
||||
|
||||
// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
|
||||
func (f genHelperDecoder) DecReadMapElemValue() { f.d.mapElemValue() }
|
||||
|
||||
// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
|
||||
func (f genHelperDecoder) DecDecodeFloat32() float32 { return f.d.decodeFloat32() }
|
||||
|
||||
// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
|
||||
func (f genHelperDecoder) DecCheckBreak() bool { return f.d.checkBreak() }
|
||||
|
||||
// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
|
||||
func (f genHelperDecoder) DecStringZC(v []byte) string { return f.d.stringZC(v) }
|
||||
|
||||
// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
|
||||
func (f genHelperDecoder) DecodeBytesInto(v []byte) []byte { return f.d.decodeBytesInto(v) }
|
242
vendor/github.com/ugorji/go/codec/gen-helper.go.tmpl
generated
vendored
Normal file
242
vendor/github.com/ugorji/go/codec/gen-helper.go.tmpl
generated
vendored
Normal file
|
@ -0,0 +1,242 @@
|
|||
// comment this out // + build ignore
|
||||
|
||||
// Copyright (c) 2012-2020 Ugorji Nwoke. All rights reserved.
|
||||
// Use of this source code is governed by a MIT license found in the LICENSE file.
|
||||
|
||||
// Code generated from gen-helper.go.tmpl - DO NOT EDIT.
|
||||
|
||||
package codec
|
||||
|
||||
import "encoding"
|
||||
|
||||
// GenVersion is the current version of codecgen.
|
||||
const GenVersion = {{ .Version }}
|
||||
|
||||
// This file is used to generate helper code for codecgen.
|
||||
// The values here i.e. genHelper(En|De)coder are not to be used directly by
|
||||
// library users. They WILL change continuously and without notice.
|
||||
|
||||
{{/*
|
||||
// To help enforce this, we create an unexported type with exported members.
|
||||
// The only way to get the type is via the one exported type that we control (somewhat).
|
||||
//
|
||||
// When static codecs are created for types, they will use this value
|
||||
// to perform encoding or decoding of primitives or known slice or map types.
|
||||
*/ -}}
|
||||
|
||||
// GenHelperEncoder is exported so that it can be used externally by codecgen.
|
||||
//
|
||||
// Library users: DO NOT USE IT DIRECTLY or INDIRECTLY. IT WILL CHANGE CONTINOUSLY WITHOUT NOTICE.
|
||||
func GenHelper() (g genHelper) { return }
|
||||
|
||||
type genHelper struct {}
|
||||
|
||||
func (genHelper) Encoder(e *Encoder) (ge genHelperEncoder, ee genHelperEncDriver) {
|
||||
ge = genHelperEncoder{e: e}
|
||||
ee = genHelperEncDriver{encDriver: e.e}
|
||||
return
|
||||
}
|
||||
|
||||
func (genHelper) Decoder(d *Decoder) (gd genHelperDecoder, dd genHelperDecDriver) {
|
||||
gd = genHelperDecoder{d: d}
|
||||
dd = genHelperDecDriver{decDriver: d.d}
|
||||
return
|
||||
}
|
||||
|
||||
type genHelperEncDriver struct {
|
||||
encDriver
|
||||
}
|
||||
|
||||
type genHelperDecDriver struct {
|
||||
decDriver
|
||||
}
|
||||
|
||||
// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
|
||||
type genHelperEncoder struct {
|
||||
M mustHdl
|
||||
F fastpathT
|
||||
e *Encoder
|
||||
}
|
||||
|
||||
// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
|
||||
type genHelperDecoder struct {
|
||||
C checkOverflow
|
||||
F fastpathT
|
||||
d *Decoder
|
||||
}
|
||||
|
||||
// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
|
||||
func (f genHelperEncoder) EncBasicHandle() *BasicHandle {
|
||||
return f.e.h
|
||||
}
|
||||
// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
|
||||
func (f genHelperEncoder) EncBinary() bool {
|
||||
return f.e.be // f.e.hh.isBinaryEncoding()
|
||||
}
|
||||
// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
|
||||
func (f genHelperEncoder) IsJSONHandle() bool {
|
||||
return f.e.js
|
||||
}
|
||||
// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
|
||||
func (f genHelperEncoder) EncFallback(iv interface{}) {
|
||||
// f.e.encodeI(iv, false, false)
|
||||
f.e.encodeValue(rv4i(iv), nil)
|
||||
}
|
||||
// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
|
||||
func (f genHelperEncoder) EncTextMarshal(iv encoding.TextMarshaler) {
|
||||
bs, fnerr := iv.MarshalText()
|
||||
f.e.marshalUtf8(bs, fnerr)
|
||||
}
|
||||
// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
|
||||
func (f genHelperEncoder) EncJSONMarshal(iv jsonMarshaler) {
|
||||
bs, fnerr := iv.MarshalJSON()
|
||||
f.e.marshalAsis(bs, fnerr)
|
||||
}
|
||||
// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
|
||||
func (f genHelperEncoder) EncBinaryMarshal(iv encoding.BinaryMarshaler) {
|
||||
bs, fnerr := iv.MarshalBinary()
|
||||
f.e.marshalRaw(bs, fnerr)
|
||||
}
|
||||
// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
|
||||
func (f genHelperEncoder) EncRaw(iv Raw) { f.e.rawBytes(iv) }
|
||||
|
||||
// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
|
||||
func (f genHelperEncoder) Extension(v interface{}) (xfn *extTypeTagFn) {
|
||||
return f.e.h.getExtForI(v)
|
||||
}
|
||||
// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
|
||||
func (f genHelperEncoder) EncExtension(v interface{}, xfFn *extTypeTagFn) {
|
||||
f.e.e.EncodeExt(v, xfFn.tag, xfFn.ext)
|
||||
}
|
||||
// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
|
||||
func (f genHelperEncoder) WriteStr(s string) {
|
||||
f.e.w().writestr(s)
|
||||
}
|
||||
{{/*
|
||||
// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
|
||||
func (f genHelperEncoder) BytesView(v string) []byte { return bytesView(v) }
|
||||
*/ -}}
|
||||
// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
|
||||
func (f genHelperEncoder) EncWriteMapStart(length int) { f.e.mapStart(length) }
|
||||
// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
|
||||
func (f genHelperEncoder) EncWriteMapEnd() { f.e.mapEnd() }
|
||||
// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
|
||||
func (f genHelperEncoder) EncWriteArrayStart(length int) { f.e.arrayStart(length) }
|
||||
// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
|
||||
func (f genHelperEncoder) EncWriteArrayEnd() { f.e.arrayEnd() }
|
||||
// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
|
||||
func (f genHelperEncoder) EncWriteArrayElem() { f.e.arrayElem() }
|
||||
// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
|
||||
func (f genHelperEncoder) EncWriteMapElemKey() { f.e.mapElemKey() }
|
||||
// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
|
||||
func (f genHelperEncoder) EncWriteMapElemValue() { f.e.mapElemValue() }
|
||||
|
||||
// ---------------- DECODER FOLLOWS -----------------
|
||||
|
||||
// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
|
||||
func (f genHelperDecoder) DecBasicHandle() *BasicHandle {
|
||||
return f.d.h
|
||||
}
|
||||
// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
|
||||
func (f genHelperDecoder) DecBinary() bool {
|
||||
return f.d.be // f.d.hh.isBinaryEncoding()
|
||||
}
|
||||
// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
|
||||
func (f genHelperDecoder) DecSwallow() { f.d.swallow() }
|
||||
|
||||
// // FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
|
||||
// func (f genHelperDecoder) DecScratchBuffer() []byte {
|
||||
// return f.d.b[:]
|
||||
// }
|
||||
|
||||
// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
|
||||
func (f genHelperDecoder) DecScratchArrayBuffer() *[decScratchByteArrayLen]byte {
|
||||
return &f.d.b
|
||||
}
|
||||
// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
|
||||
func (f genHelperDecoder) DecFallback(iv interface{}, chkPtr bool) {
|
||||
rv := rv4i(iv)
|
||||
if chkPtr && !isDecodeable(rv) {
|
||||
f.d.haltAsNotDecodeable(rv)
|
||||
}
|
||||
f.d.decodeValue(rv, nil)
|
||||
}
|
||||
// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
|
||||
func (f genHelperDecoder) DecSliceHelperStart() (decSliceHelper, int) {
|
||||
return f.d.decSliceHelperStart()
|
||||
}
|
||||
// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
|
||||
func (f genHelperDecoder) DecStructFieldNotFound(index int, name string) {
|
||||
f.d.structFieldNotFound(index, name)
|
||||
}
|
||||
// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
|
||||
func (f genHelperDecoder) DecArrayCannotExpand(sliceLen, streamLen int) {
|
||||
f.d.arrayCannotExpand(sliceLen, streamLen)
|
||||
}
|
||||
// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
|
||||
func (f genHelperDecoder) DecTextUnmarshal(tm encoding.TextUnmarshaler) {
|
||||
halt.onerror(tm.UnmarshalText(f.d.d.DecodeStringAsBytes()))
|
||||
}
|
||||
// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
|
||||
func (f genHelperDecoder) DecJSONUnmarshal(tm jsonUnmarshaler) {
|
||||
// bs := f.dd.DecodeStringAsBytes()
|
||||
// grab the bytes to be read, as UnmarshalJSON needs the full JSON so as to unmarshal it itself.
|
||||
bs := f.d.blist.get(256)
|
||||
bs = f.d.d.nextValueBytes(bs)
|
||||
fnerr := tm.UnmarshalJSON(bs)
|
||||
f.d.blist.put(bs)
|
||||
halt.onerror(fnerr)
|
||||
}
|
||||
// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
|
||||
func (f genHelperDecoder) DecBinaryUnmarshal(bm encoding.BinaryUnmarshaler) {
|
||||
halt.onerror(bm.UnmarshalBinary(f.d.d.DecodeBytes(nil)))
|
||||
}
|
||||
// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
|
||||
func (f genHelperDecoder) DecRaw() []byte { return f.d.rawBytes() }
|
||||
|
||||
// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
|
||||
func (f genHelperDecoder) IsJSONHandle() bool {
|
||||
return f.d.js
|
||||
}
|
||||
// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
|
||||
func (f genHelperDecoder) I2Rtid(v interface{}) uintptr {
|
||||
return i2rtid(v)
|
||||
}
|
||||
// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
|
||||
func (f genHelperDecoder) Extension(v interface{}) (xfn *extTypeTagFn) {
|
||||
return f.d.h.getExtForI(v)
|
||||
}
|
||||
// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
|
||||
func (f genHelperDecoder) DecExtension(v interface{}, xfFn *extTypeTagFn) {
|
||||
f.d.d.DecodeExt(v, xfFn.tag, xfFn.ext)
|
||||
}
|
||||
// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
|
||||
func (f genHelperDecoder) DecInferLen(clen, maxlen, unit int) (rvlen int) {
|
||||
return decInferLen(clen, maxlen, unit)
|
||||
}
|
||||
// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
|
||||
func (f genHelperDecoder) StringView(v []byte) string { return stringView(v) }
|
||||
|
||||
// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
|
||||
func (f genHelperDecoder) DecReadMapStart() int { return f.d.mapStart() }
|
||||
// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
|
||||
func (f genHelperDecoder) DecReadMapEnd() { f.d.mapEnd() }
|
||||
// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
|
||||
func (f genHelperDecoder) DecReadArrayStart() int { return f.d.arrayStart() }
|
||||
// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
|
||||
func (f genHelperDecoder) DecReadArrayEnd() { f.d.arrayEnd() }
|
||||
// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
|
||||
func (f genHelperDecoder) DecReadArrayElem() { f.d.arrayElem() }
|
||||
// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
|
||||
func (f genHelperDecoder) DecReadMapElemKey() { f.d.mapElemKey() }
|
||||
// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
|
||||
func (f genHelperDecoder) DecReadMapElemValue() { f.d.mapElemValue() }
|
||||
|
||||
// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
|
||||
func (f genHelperDecoder) DecDecodeFloat32() float32 { return f.d.decodeFloat32() }
|
||||
// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
|
||||
func (f genHelperDecoder) DecCheckBreak() bool { return f.d.checkBreak() }
|
||||
// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
|
||||
func (f genHelperDecoder) DecStringZC(v []byte) string { return f.d.stringZC(v) }
|
||||
// FOR USE BY CODECGEN ONLY. IT *WILL* CHANGE WITHOUT NOTICE. *DO NOT USE*
|
||||
func (f genHelperDecoder) DecodeBytesInto(v []byte) []byte { return f.d.decodeBytesInto(v) }
|
192
vendor/github.com/ugorji/go/codec/gen.generated.go
generated
vendored
Normal file
192
vendor/github.com/ugorji/go/codec/gen.generated.go
generated
vendored
Normal file
|
@ -0,0 +1,192 @@
|
|||
// +build codecgen.exec
|
||||
|
||||
// Copyright (c) 2012-2020 Ugorji Nwoke. All rights reserved.
|
||||
// Use of this source code is governed by a MIT license found in the LICENSE file.
|
||||
|
||||
package codec
|
||||
|
||||
// DO NOT EDIT. THIS FILE IS AUTO-GENERATED FROM gen-dec-(map|array).go.tmpl
|
||||
|
||||
const genDecMapTmpl = `
|
||||
{{var "v"}} := *{{ .Varname }}
|
||||
{{var "l"}} := z.DecReadMapStart()
|
||||
if {{var "l"}} == codecSelferDecContainerLenNil{{xs}} {
|
||||
*{{ .Varname }} = nil
|
||||
} else {
|
||||
if {{var "v"}} == nil {
|
||||
{{var "rl"}} := z.DecInferLen({{var "l"}}, z.DecBasicHandle().MaxInitLen, {{ .Size }})
|
||||
{{var "v"}} = make(map[{{ .KTyp }}]{{ .Typ }}, {{var "rl"}})
|
||||
*{{ .Varname }} = {{var "v"}}
|
||||
}
|
||||
{{ $mk := var "mk" -}}
|
||||
var {{ $mk }} {{ .KTyp }}
|
||||
var {{var "mv"}} {{ .Typ }}
|
||||
var {{var "mg"}}, {{var "mdn"}} {{if decElemKindPtr}}, {{var "ms"}}, {{var "mok"}}{{end}} bool
|
||||
if z.DecBasicHandle().MapValueReset {
|
||||
{{if decElemKindPtr}}{{var "mg"}} = true
|
||||
{{else if decElemKindIntf}}if !z.DecBasicHandle().InterfaceReset { {{var "mg"}} = true }
|
||||
{{else if not decElemKindImmutable}}{{var "mg"}} = true
|
||||
{{end}} }
|
||||
if {{var "l"}} != 0 {
|
||||
{{var "hl"}} := {{var "l"}} > 0
|
||||
for {{var "j"}} := 0; ({{var "hl"}} && {{var "j"}} < {{var "l"}}) || !({{var "hl"}} || z.DecCheckBreak()); {{var "j"}}++ {
|
||||
z.DecReadMapElemKey()
|
||||
{{ if eq .KTyp "string" -}}
|
||||
{{ decLineVarK $mk -}}{{- /* decLineVarKStrZC $mk */ -}}
|
||||
{{ else -}}
|
||||
{{ decLineVarK $mk -}}
|
||||
{{ end -}}
|
||||
{{ if eq .KTyp "interface{}" }}{{/* // special case if a byte array. */ -}}
|
||||
if {{var "bv"}}, {{var "bok"}} := {{var "mk"}}.([]byte); {{var "bok"}} {
|
||||
{{var "mk"}} = z.DecStringZC({{var "bv"}})
|
||||
}
|
||||
{{ end -}}
|
||||
{{if decElemKindPtr -}}
|
||||
{{var "ms"}} = true
|
||||
{{end -}}
|
||||
if {{var "mg"}} {
|
||||
{{if decElemKindPtr -}}
|
||||
{{var "mv"}}, {{var "mok"}} = {{var "v"}}[{{ $mk }}]
|
||||
if {{var "mok"}} {
|
||||
{{var "ms"}} = false
|
||||
}
|
||||
{{else -}}
|
||||
{{var "mv"}} = {{var "v"}}[{{ $mk }}]
|
||||
{{end -}}
|
||||
} {{if not decElemKindImmutable}}else { {{var "mv"}} = {{decElemZero}} }{{end}}
|
||||
z.DecReadMapElemValue()
|
||||
{{var "mdn"}} = false
|
||||
{{ $x := printf "%vmv%v" .TempVar .Rand }}{{ $y := printf "%vmdn%v" .TempVar .Rand }}{{ decLineVar $x $y -}}
|
||||
if {{var "mdn"}} {
|
||||
{{var "v"}}[{{ $mk }}] = {{decElemZero}}
|
||||
} else {{if decElemKindPtr}} if {{var "ms"}} {{end}} {
|
||||
{{var "v"}}[{{ $mk }}] = {{var "mv"}}
|
||||
}
|
||||
}
|
||||
} // else len==0: leave as-is (do not clear map entries)
|
||||
z.DecReadMapEnd()
|
||||
}
|
||||
`
|
||||
|
||||
const genDecListTmpl = `
|
||||
{{var "v"}} := {{if not isArray}}*{{end}}{{ .Varname }}
|
||||
{{var "h"}}, {{var "l"}} := z.DecSliceHelperStart() {{/* // helper, containerLenS */}}
|
||||
{{if not isArray -}}
|
||||
var {{var "c"}} bool {{/* // changed */}}
|
||||
_ = {{var "c"}}
|
||||
if {{var "h"}}.IsNil {
|
||||
if {{var "v"}} != nil {
|
||||
{{var "v"}} = nil
|
||||
{{var "c"}} = true
|
||||
}
|
||||
} else {{end -}}
|
||||
if {{var "l"}} == 0 {
|
||||
{{if isSlice -}}
|
||||
if {{var "v"}} == nil {
|
||||
{{var "v"}} = []{{ .Typ }}{}
|
||||
{{var "c"}} = true
|
||||
} else if len({{var "v"}}) != 0 {
|
||||
{{var "v"}} = {{var "v"}}[:0]
|
||||
{{var "c"}} = true
|
||||
} {{else if isChan }}if {{var "v"}} == nil {
|
||||
{{var "v"}} = make({{ .CTyp }}, 0)
|
||||
{{var "c"}} = true
|
||||
}
|
||||
{{end -}}
|
||||
} else {
|
||||
{{var "hl"}} := {{var "l"}} > 0
|
||||
var {{var "rl"}} int
|
||||
_ = {{var "rl"}}
|
||||
{{if isSlice }} if {{var "hl"}} {
|
||||
if {{var "l"}} > cap({{var "v"}}) {
|
||||
{{var "rl"}} = z.DecInferLen({{var "l"}}, z.DecBasicHandle().MaxInitLen, {{ .Size }})
|
||||
if {{var "rl"}} <= cap({{var "v"}}) {
|
||||
{{var "v"}} = {{var "v"}}[:{{var "rl"}}]
|
||||
} else {
|
||||
{{var "v"}} = make([]{{ .Typ }}, {{var "rl"}})
|
||||
}
|
||||
{{var "c"}} = true
|
||||
} else if {{var "l"}} != len({{var "v"}}) {
|
||||
{{var "v"}} = {{var "v"}}[:{{var "l"}}]
|
||||
{{var "c"}} = true
|
||||
}
|
||||
}
|
||||
{{end -}}
|
||||
var {{var "j"}} int
|
||||
{{/* // var {{var "dn"}} bool */ -}}
|
||||
for {{var "j"}} = 0; ({{var "hl"}} && {{var "j"}} < {{var "l"}}) || !({{var "hl"}} || z.DecCheckBreak()); {{var "j"}}++ { // bounds-check-elimination
|
||||
{{if not isArray}} if {{var "j"}} == 0 && {{var "v"}} == nil {
|
||||
if {{var "hl"}} {
|
||||
{{var "rl"}} = z.DecInferLen({{var "l"}}, z.DecBasicHandle().MaxInitLen, {{ .Size }})
|
||||
} else {
|
||||
{{var "rl"}} = {{if isSlice}}8{{else if isChan}}64{{end}}
|
||||
}
|
||||
{{var "v"}} = make({{if isSlice}}[]{{ .Typ }}{{else if isChan}}{{.CTyp}}{{end}}, {{var "rl"}})
|
||||
{{var "c"}} = true
|
||||
}
|
||||
{{end -}}
|
||||
{{var "h"}}.ElemContainerState({{var "j"}})
|
||||
{{/* {{var "dn"}} = r.TryDecodeAsNil() */}}{{/* commented out, as decLineVar handles this already each time */ -}}
|
||||
{{if isChan}}{{ $x := printf "%[1]vvcx%[2]v" .TempVar .Rand }}var {{$x}} {{ .Typ }}
|
||||
{{ decLineVar $x -}}
|
||||
{{var "v"}} <- {{ $x }}
|
||||
{{else}}{{/* // if indefinite, etc, then expand the slice if necessary */ -}}
|
||||
var {{var "db"}} bool
|
||||
if {{var "j"}} >= len({{var "v"}}) {
|
||||
{{if isSlice }} {{var "v"}} = append({{var "v"}}, {{ zero }})
|
||||
{{var "c"}} = true
|
||||
{{else}} z.DecArrayCannotExpand(len(v), {{var "j"}}+1); {{var "db"}} = true
|
||||
{{end -}}
|
||||
}
|
||||
if {{var "db"}} {
|
||||
z.DecSwallow()
|
||||
} else {
|
||||
{{ $x := printf "%[1]vv%[2]v[%[1]vj%[2]v]" .TempVar .Rand }}{{ decLineVar $x -}}
|
||||
}
|
||||
{{end -}}
|
||||
}
|
||||
{{if isSlice}} if {{var "j"}} < len({{var "v"}}) {
|
||||
{{var "v"}} = {{var "v"}}[:{{var "j"}}]
|
||||
{{var "c"}} = true
|
||||
} else if {{var "j"}} == 0 && {{var "v"}} == nil {
|
||||
{{var "v"}} = make([]{{ .Typ }}, 0)
|
||||
{{var "c"}} = true
|
||||
}
|
||||
{{end -}}
|
||||
}
|
||||
{{var "h"}}.End()
|
||||
{{if not isArray }}if {{var "c"}} {
|
||||
*{{ .Varname }} = {{var "v"}}
|
||||
}
|
||||
{{end -}}
|
||||
`
|
||||
|
||||
const genEncChanTmpl = `
|
||||
{{.Label}}:
|
||||
switch timeout{{.Sfx}} := z.EncBasicHandle().ChanRecvTimeout; {
|
||||
case timeout{{.Sfx}} == 0: // only consume available
|
||||
for {
|
||||
select {
|
||||
case b{{.Sfx}} := <-{{.Chan}}:
|
||||
{{ .Slice }} = append({{.Slice}}, b{{.Sfx}})
|
||||
default:
|
||||
break {{.Label}}
|
||||
}
|
||||
}
|
||||
case timeout{{.Sfx}} > 0: // consume until timeout
|
||||
tt{{.Sfx}} := time.NewTimer(timeout{{.Sfx}})
|
||||
for {
|
||||
select {
|
||||
case b{{.Sfx}} := <-{{.Chan}}:
|
||||
{{.Slice}} = append({{.Slice}}, b{{.Sfx}})
|
||||
case <-tt{{.Sfx}}.C:
|
||||
// close(tt.C)
|
||||
break {{.Label}}
|
||||
}
|
||||
}
|
||||
default: // consume until close
|
||||
for b{{.Sfx}} := range {{.Chan}} {
|
||||
{{.Slice}} = append({{.Slice}}, b{{.Sfx}})
|
||||
}
|
||||
}
|
||||
`
|
2643
vendor/github.com/ugorji/go/codec/gen.go
generated
vendored
Normal file
2643
vendor/github.com/ugorji/go/codec/gen.go
generated
vendored
Normal file
File diff suppressed because it is too large
Load diff
5
vendor/github.com/ugorji/go/codec/go.mod
generated
vendored
Normal file
5
vendor/github.com/ugorji/go/codec/go.mod
generated
vendored
Normal file
|
@ -0,0 +1,5 @@
|
|||
module github.com/ugorji/go/codec
|
||||
|
||||
go 1.11
|
||||
|
||||
require github.com/ugorji/go v1.2.3
|
14
vendor/github.com/ugorji/go/codec/goversion_arrayof_gte_go15.go
generated
vendored
Normal file
14
vendor/github.com/ugorji/go/codec/goversion_arrayof_gte_go15.go
generated
vendored
Normal file
|
@ -0,0 +1,14 @@
|
|||
// Copyright (c) 2012-2020 Ugorji Nwoke. All rights reserved.
|
||||
// Use of this source code is governed by a MIT license found in the LICENSE file.
|
||||
|
||||
// +build go1.5
|
||||
|
||||
package codec
|
||||
|
||||
import "reflect"
|
||||
|
||||
const reflectArrayOfSupported = true
|
||||
|
||||
func reflectArrayOf(count int, elem reflect.Type) reflect.Type {
|
||||
return reflect.ArrayOf(count, elem)
|
||||
}
|
19
vendor/github.com/ugorji/go/codec/goversion_arrayof_lt_go15.go
generated
vendored
Normal file
19
vendor/github.com/ugorji/go/codec/goversion_arrayof_lt_go15.go
generated
vendored
Normal file
|
@ -0,0 +1,19 @@
|
|||
// Copyright (c) 2012-2020 Ugorji Nwoke. All rights reserved.
|
||||
// Use of this source code is governed by a MIT license found in the LICENSE file.
|
||||
|
||||
// +build !go1.5
|
||||
|
||||
package codec
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"reflect"
|
||||
)
|
||||
|
||||
const reflectArrayOfSupported = false
|
||||
|
||||
var errNoReflectArrayOf = errors.New("codec: reflect.ArrayOf unsupported by this go version")
|
||||
|
||||
func reflectArrayOf(count int, elem reflect.Type) reflect.Type {
|
||||
panic(errNoReflectArrayOf)
|
||||
}
|
12
vendor/github.com/ugorji/go/codec/goversion_fmt_time_gte_go15.go
generated
vendored
Normal file
12
vendor/github.com/ugorji/go/codec/goversion_fmt_time_gte_go15.go
generated
vendored
Normal file
|
@ -0,0 +1,12 @@
|
|||
// Copyright (c) 2012-2020 Ugorji Nwoke. All rights reserved.
|
||||
// Use of this source code is governed by a MIT license found in the LICENSE file.
|
||||
|
||||
// +build go1.5
|
||||
|
||||
package codec
|
||||
|
||||
import "time"
|
||||
|
||||
func fmtTime(t time.Time, b []byte) []byte {
|
||||
return t.AppendFormat(b, time.RFC3339Nano)
|
||||
}
|
15
vendor/github.com/ugorji/go/codec/goversion_fmt_time_lt_go15.go
generated
vendored
Normal file
15
vendor/github.com/ugorji/go/codec/goversion_fmt_time_lt_go15.go
generated
vendored
Normal file
|
@ -0,0 +1,15 @@
|
|||
// Copyright (c) 2012-2020 Ugorji Nwoke. All rights reserved.
|
||||
// Use of this source code is governed by a MIT license found in the LICENSE file.
|
||||
|
||||
// +build !go1.5
|
||||
|
||||
package codec
|
||||
|
||||
import "time"
|
||||
|
||||
func fmtTime(t time.Time, b []byte) []byte {
|
||||
s := t.Format(time.RFC3339Nano)
|
||||
b = b[:len(s)]
|
||||
copy(b, s)
|
||||
return b
|
||||
}
|
12
vendor/github.com/ugorji/go/codec/goversion_makemap_lt_go110.go
generated
vendored
Normal file
12
vendor/github.com/ugorji/go/codec/goversion_makemap_lt_go110.go
generated
vendored
Normal file
|
@ -0,0 +1,12 @@
|
|||
// Copyright (c) 2012-2020 Ugorji Nwoke. All rights reserved.
|
||||
// Use of this source code is governed by a MIT license found in the LICENSE file.
|
||||
|
||||
// +build !go1.10
|
||||
|
||||
package codec
|
||||
|
||||
import "reflect"
|
||||
|
||||
func makeMapReflect(t reflect.Type, size int) reflect.Value {
|
||||
return reflect.MakeMap(t)
|
||||
}
|
13
vendor/github.com/ugorji/go/codec/goversion_makemap_not_unsafe_gte_go110.go
generated
vendored
Normal file
13
vendor/github.com/ugorji/go/codec/goversion_makemap_not_unsafe_gte_go110.go
generated
vendored
Normal file
|
@ -0,0 +1,13 @@
|
|||
// Copyright (c) 2012-2020 Ugorji Nwoke. All rights reserved.
|
||||
// Use of this source code is governed by a MIT license found in the LICENSE file.
|
||||
|
||||
// +build go1.10
|
||||
// +build safe appengine
|
||||
|
||||
package codec
|
||||
|
||||
import "reflect"
|
||||
|
||||
func makeMapReflect(t reflect.Type, size int) reflect.Value {
|
||||
return reflect.MakeMapWithSize(t, size)
|
||||
}
|
26
vendor/github.com/ugorji/go/codec/goversion_makemap_unsafe_gte_go110.go
generated
vendored
Normal file
26
vendor/github.com/ugorji/go/codec/goversion_makemap_unsafe_gte_go110.go
generated
vendored
Normal file
|
@ -0,0 +1,26 @@
|
|||
// +build go1.10
|
||||
// +build !safe
|
||||
// +build !appengine
|
||||
|
||||
// Copyright (c) 2012-2020 Ugorji Nwoke. All rights reserved.
|
||||
// Use of this source code is governed by a MIT license found in the LICENSE file.
|
||||
|
||||
package codec
|
||||
|
||||
import (
|
||||
"reflect"
|
||||
"unsafe"
|
||||
)
|
||||
|
||||
func makeMapReflect(typ reflect.Type, size int) (rv reflect.Value) {
|
||||
t := (*unsafeIntf)(unsafe.Pointer(&typ)).word
|
||||
urv := (*unsafeReflectValue)(unsafe.Pointer(&rv))
|
||||
urv.typ = t
|
||||
urv.flag = uintptr(reflect.Map)
|
||||
urv.ptr = makemap(t, size, nil)
|
||||
return
|
||||
}
|
||||
|
||||
//go:linkname makemap runtime.makemap
|
||||
//go:noescape
|
||||
func makemap(typ unsafe.Pointer, size int, h unsafe.Pointer) unsafe.Pointer
|
40
vendor/github.com/ugorji/go/codec/goversion_maprange_gte_go112.go
generated
vendored
Normal file
40
vendor/github.com/ugorji/go/codec/goversion_maprange_gte_go112.go
generated
vendored
Normal file
|
@ -0,0 +1,40 @@
|
|||
// Copyright (c) 2012-2020 Ugorji Nwoke. All rights reserved.
|
||||
// Use of this source code is governed by a MIT license found in the LICENSE file.
|
||||
|
||||
// +build go1.12
|
||||
// +build safe appengine
|
||||
|
||||
package codec
|
||||
|
||||
import "reflect"
|
||||
|
||||
type mapIter struct {
|
||||
t *reflect.MapIter
|
||||
m reflect.Value
|
||||
values bool
|
||||
}
|
||||
|
||||
func (t *mapIter) Next() (r bool) {
|
||||
return t.t.Next()
|
||||
}
|
||||
|
||||
func (t *mapIter) Key() reflect.Value {
|
||||
return t.t.Key()
|
||||
}
|
||||
|
||||
func (t *mapIter) Value() (r reflect.Value) {
|
||||
if t.values {
|
||||
return t.t.Value()
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func (t *mapIter) Done() {}
|
||||
|
||||
func mapRange(t *mapIter, m, k, v reflect.Value, values bool) {
|
||||
*t = mapIter{
|
||||
m: m,
|
||||
t: m.MapRange(),
|
||||
values: values,
|
||||
}
|
||||
}
|
44
vendor/github.com/ugorji/go/codec/goversion_maprange_lt_go112.go
generated
vendored
Normal file
44
vendor/github.com/ugorji/go/codec/goversion_maprange_lt_go112.go
generated
vendored
Normal file
|
@ -0,0 +1,44 @@
|
|||
// Copyright (c) 2012-2020 Ugorji Nwoke. All rights reserved.
|
||||
// Use of this source code is governed by a MIT license found in the LICENSE file.
|
||||
|
||||
// +build go1.7
|
||||
// +build !go1.12
|
||||
// +build safe appengine
|
||||
|
||||
package codec
|
||||
|
||||
import "reflect"
|
||||
|
||||
type mapIter struct {
|
||||
m reflect.Value
|
||||
keys []reflect.Value
|
||||
j int
|
||||
values bool
|
||||
}
|
||||
|
||||
func (t *mapIter) Next() (r bool) {
|
||||
t.j++
|
||||
return t.j < len(t.keys)
|
||||
}
|
||||
|
||||
func (t *mapIter) Key() reflect.Value {
|
||||
return t.keys[t.j]
|
||||
}
|
||||
|
||||
func (t *mapIter) Value() (r reflect.Value) {
|
||||
if t.values {
|
||||
return t.m.MapIndex(t.keys[t.j])
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func (t *mapIter) Done() {}
|
||||
|
||||
func mapRange(t *mapIter, m, k, v reflect.Value, values bool) {
|
||||
*t = mapIter{
|
||||
m: m,
|
||||
keys: m.MapKeys(),
|
||||
values: values,
|
||||
j: -1,
|
||||
}
|
||||
}
|
8
vendor/github.com/ugorji/go/codec/goversion_unexportedembeddedptr_gte_go110.go
generated
vendored
Normal file
8
vendor/github.com/ugorji/go/codec/goversion_unexportedembeddedptr_gte_go110.go
generated
vendored
Normal file
|
@ -0,0 +1,8 @@
|
|||
// Copyright (c) 2012-2020 Ugorji Nwoke. All rights reserved.
|
||||
// Use of this source code is governed by a MIT license found in the LICENSE file.
|
||||
|
||||
// +build go1.10
|
||||
|
||||
package codec
|
||||
|
||||
const allowSetUnexportedEmbeddedPtr = false
|
8
vendor/github.com/ugorji/go/codec/goversion_unexportedembeddedptr_lt_go110.go
generated
vendored
Normal file
8
vendor/github.com/ugorji/go/codec/goversion_unexportedembeddedptr_lt_go110.go
generated
vendored
Normal file
|
@ -0,0 +1,8 @@
|
|||
// Copyright (c) 2012-2020 Ugorji Nwoke. All rights reserved.
|
||||
// Use of this source code is governed by a MIT license found in the LICENSE file.
|
||||
|
||||
// +build !go1.10
|
||||
|
||||
package codec
|
||||
|
||||
const allowSetUnexportedEmbeddedPtr = true
|
21
vendor/github.com/ugorji/go/codec/goversion_unsupported_lt_go14.go
generated
vendored
Normal file
21
vendor/github.com/ugorji/go/codec/goversion_unsupported_lt_go14.go
generated
vendored
Normal file
|
@ -0,0 +1,21 @@
|
|||
// Copyright (c) 2012-2020 Ugorji Nwoke. All rights reserved.
|
||||
// Use of this source code is governed by a MIT license found in the LICENSE file.
|
||||
|
||||
// +build !go1.4
|
||||
|
||||
package codec
|
||||
|
||||
import "errors"
|
||||
|
||||
// This codec package will only work for go1.4 and above.
|
||||
// This is for the following reasons:
|
||||
// - go 1.4 was released in 2014
|
||||
// - go runtime is written fully in go
|
||||
// - interface only holds pointers
|
||||
// - reflect.Value is stabilized as 3 words
|
||||
|
||||
var errCodecSupportedOnlyFromGo14 = errors.New("codec: go 1.3 and below are not supported")
|
||||
|
||||
func init() {
|
||||
panic(errCodecSupportedOnlyFromGo14)
|
||||
}
|
10
vendor/github.com/ugorji/go/codec/goversion_vendor_eq_go15.go
generated
vendored
Normal file
10
vendor/github.com/ugorji/go/codec/goversion_vendor_eq_go15.go
generated
vendored
Normal file
|
@ -0,0 +1,10 @@
|
|||
// Copyright (c) 2012-2020 Ugorji Nwoke. All rights reserved.
|
||||
// Use of this source code is governed by a MIT license found in the LICENSE file.
|
||||
|
||||
// +build go1.5,!go1.6
|
||||
|
||||
package codec
|
||||
|
||||
import "os"
|
||||
|
||||
var genCheckVendor = os.Getenv("GO15VENDOREXPERIMENT") == "1"
|
10
vendor/github.com/ugorji/go/codec/goversion_vendor_eq_go16.go
generated
vendored
Normal file
10
vendor/github.com/ugorji/go/codec/goversion_vendor_eq_go16.go
generated
vendored
Normal file
|
@ -0,0 +1,10 @@
|
|||
// Copyright (c) 2012-2020 Ugorji Nwoke. All rights reserved.
|
||||
// Use of this source code is governed by a MIT license found in the LICENSE file.
|
||||
|
||||
// +build go1.6,!go1.7
|
||||
|
||||
package codec
|
||||
|
||||
import "os"
|
||||
|
||||
var genCheckVendor = os.Getenv("GO15VENDOREXPERIMENT") != "0"
|
8
vendor/github.com/ugorji/go/codec/goversion_vendor_gte_go17.go
generated
vendored
Normal file
8
vendor/github.com/ugorji/go/codec/goversion_vendor_gte_go17.go
generated
vendored
Normal file
|
@ -0,0 +1,8 @@
|
|||
// Copyright (c) 2012-2020 Ugorji Nwoke. All rights reserved.
|
||||
// Use of this source code is governed by a MIT license found in the LICENSE file.
|
||||
|
||||
// +build go1.7
|
||||
|
||||
package codec
|
||||
|
||||
const genCheckVendor = true
|
8
vendor/github.com/ugorji/go/codec/goversion_vendor_lt_go15.go
generated
vendored
Normal file
8
vendor/github.com/ugorji/go/codec/goversion_vendor_lt_go15.go
generated
vendored
Normal file
|
@ -0,0 +1,8 @@
|
|||
// Copyright (c) 2012-2020 Ugorji Nwoke. All rights reserved.
|
||||
// Use of this source code is governed by a MIT license found in the LICENSE file.
|
||||
|
||||
// +build !go1.5
|
||||
|
||||
package codec
|
||||
|
||||
var genCheckVendor = false
|
2691
vendor/github.com/ugorji/go/codec/helper.go
generated
vendored
Normal file
2691
vendor/github.com/ugorji/go/codec/helper.go
generated
vendored
Normal file
File diff suppressed because it is too large
Load diff
0
vendor/github.com/ugorji/go/codec/helper.s
generated
vendored
Normal file
0
vendor/github.com/ugorji/go/codec/helper.s
generated
vendored
Normal file
147
vendor/github.com/ugorji/go/codec/helper_internal.go
generated
vendored
Normal file
147
vendor/github.com/ugorji/go/codec/helper_internal.go
generated
vendored
Normal file
|
@ -0,0 +1,147 @@
|
|||
// Copyright (c) 2012-2020 Ugorji Nwoke. All rights reserved.
|
||||
// Use of this source code is governed by a MIT license found in the LICENSE file.
|
||||
|
||||
package codec
|
||||
|
||||
// maxArrayLen is the size of uint, which determines
|
||||
// the maximum length of any array.
|
||||
const maxArrayLen = 1<<((32<<(^uint(0)>>63))-1) - 1
|
||||
|
||||
// All non-std package dependencies live in this file,
|
||||
// so porting to different environment is easy (just update functions).
|
||||
|
||||
func pruneSignExt(v []byte, pos bool) (n int) {
|
||||
if len(v) < 2 {
|
||||
} else if pos && v[0] == 0 {
|
||||
for ; v[n] == 0 && n+1 < len(v) && (v[n+1]&(1<<7) == 0); n++ {
|
||||
}
|
||||
} else if !pos && v[0] == 0xff {
|
||||
for ; v[n] == 0xff && n+1 < len(v) && (v[n+1]&(1<<7) != 0); n++ {
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func halfFloatToFloatBits(h uint16) (f uint32) {
|
||||
// retrofitted from:
|
||||
// - OGRE (Object-Oriented Graphics Rendering Engine)
|
||||
// function: halfToFloatI https://www.ogre3d.org/docs/api/1.9/_ogre_bitwise_8h_source.html
|
||||
|
||||
s := uint32(h >> 15)
|
||||
m := uint32(h & 0x03ff)
|
||||
e := int32((h >> 10) & 0x1f)
|
||||
|
||||
if e == 0 {
|
||||
if m == 0 { // plus or minus 0
|
||||
return s << 31
|
||||
}
|
||||
// Denormalized number -- renormalize it
|
||||
for (m & 0x0400) == 0 {
|
||||
m <<= 1
|
||||
e -= 1
|
||||
}
|
||||
e += 1
|
||||
m &= ^uint32(0x0400)
|
||||
} else if e == 31 {
|
||||
if m == 0 { // Inf
|
||||
return (s << 31) | 0x7f800000
|
||||
}
|
||||
return (s << 31) | 0x7f800000 | (m << 13) // NaN
|
||||
}
|
||||
e = e + (127 - 15)
|
||||
m = m << 13
|
||||
return (s << 31) | (uint32(e) << 23) | m
|
||||
}
|
||||
|
||||
func floatToHalfFloatBits(i uint32) (h uint16) {
|
||||
// retrofitted from:
|
||||
// - OGRE (Object-Oriented Graphics Rendering Engine)
|
||||
// function: halfToFloatI https://www.ogre3d.org/docs/api/1.9/_ogre_bitwise_8h_source.html
|
||||
// - http://www.java2s.com/example/java-utility-method/float-to/floattohalf-float-f-fae00.html
|
||||
s := (i >> 16) & 0x8000
|
||||
e := int32(((i >> 23) & 0xff) - (127 - 15))
|
||||
m := i & 0x7fffff
|
||||
|
||||
var h32 uint32
|
||||
|
||||
if e <= 0 {
|
||||
if e < -10 { // zero
|
||||
h32 = s // track -0 vs +0
|
||||
} else {
|
||||
m = (m | 0x800000) >> uint32(1-e)
|
||||
h32 = s | (m >> 13)
|
||||
}
|
||||
} else if e == 0xff-(127-15) {
|
||||
if m == 0 { // Inf
|
||||
h32 = s | 0x7c00
|
||||
} else { // NAN
|
||||
m >>= 13
|
||||
var me uint32
|
||||
if m == 0 {
|
||||
me = 1
|
||||
}
|
||||
h32 = s | 0x7c00 | m | me
|
||||
}
|
||||
} else {
|
||||
if e > 30 { // Overflow
|
||||
h32 = s | 0x7c00
|
||||
} else {
|
||||
h32 = s | (uint32(e) << 10) | (m >> 13)
|
||||
}
|
||||
}
|
||||
h = uint16(h32)
|
||||
return
|
||||
}
|
||||
|
||||
// growCap will return a new capacity for a slice, given the following:
|
||||
// - oldCap: current capacity
|
||||
// - unit: in-memory size of an element
|
||||
// - num: number of elements to add
|
||||
func growCap(oldCap, unit, num uint) (newCap uint) {
|
||||
// appendslice logic (if cap < 1024, *2, else *1.25):
|
||||
// leads to many copy calls, especially when copying bytes.
|
||||
// bytes.Buffer model (2*cap + n): much better for bytes.
|
||||
// smarter way is to take the byte-size of the appended element(type) into account
|
||||
|
||||
// maintain 1 thresholds:
|
||||
// t1: if cap <= t1, newcap = 2x
|
||||
// else newcap = 1.5x
|
||||
//
|
||||
// t1 is always >= 1024.
|
||||
// This means that, if unit size >= 16, then always do 2x or 1.5x (ie t1, t2, t3 are all same)
|
||||
//
|
||||
// With this, appending for bytes increase by:
|
||||
// 100% up to 4K
|
||||
// 50% beyond that
|
||||
|
||||
// unit can be 0 e.g. for struct{}{}; handle that appropriately
|
||||
maxCap := num + (oldCap * 3 / 2)
|
||||
if unit == 0 || maxCap > maxArrayLen || maxCap < oldCap { // handle wraparound, etc
|
||||
return maxArrayLen
|
||||
}
|
||||
|
||||
var t1 uint = 1024 // default thresholds for large values
|
||||
if unit <= 4 {
|
||||
t1 = 8 * 1024
|
||||
} else if unit <= 16 {
|
||||
t1 = 2 * 1024
|
||||
}
|
||||
|
||||
newCap = 2 + num
|
||||
if oldCap > 0 {
|
||||
if oldCap <= t1 { // [0,t1]
|
||||
newCap = num + (oldCap * 2)
|
||||
} else { // (t1,infinity]
|
||||
newCap = maxCap
|
||||
}
|
||||
}
|
||||
|
||||
// ensure newCap takes multiples of a cache line (size is a multiple of 64)
|
||||
t1 = newCap * unit
|
||||
if t2 := t1 % 64; t2 != 0 {
|
||||
t1 += 64 - t2
|
||||
newCap = t1 / unit
|
||||
}
|
||||
|
||||
return
|
||||
}
|
505
vendor/github.com/ugorji/go/codec/helper_not_unsafe.go
generated
vendored
Normal file
505
vendor/github.com/ugorji/go/codec/helper_not_unsafe.go
generated
vendored
Normal file
|
@ -0,0 +1,505 @@
|
|||
// +build !go1.8 safe appengine
|
||||
|
||||
// Copyright (c) 2012-2020 Ugorji Nwoke. All rights reserved.
|
||||
// Use of this source code is governed by a MIT license found in the LICENSE file.
|
||||
|
||||
package codec
|
||||
|
||||
import (
|
||||
// "hash/adler32"
|
||||
"math"
|
||||
"reflect"
|
||||
"sync/atomic"
|
||||
"time"
|
||||
)
|
||||
|
||||
const safeMode = true
|
||||
|
||||
// stringView returns a view of the []byte as a string.
|
||||
// In unsafe mode, it doesn't incur allocation and copying caused by conversion.
|
||||
// In regular safe mode, it is an allocation and copy.
|
||||
//
|
||||
// Usage: Always maintain a reference to v while result of this call is in use,
|
||||
// and call keepAlive4BytesView(v) at point where done with view.
|
||||
func stringView(v []byte) string {
|
||||
return string(v)
|
||||
}
|
||||
|
||||
// bytesView returns a view of the string as a []byte.
|
||||
// In unsafe mode, it doesn't incur allocation and copying caused by conversion.
|
||||
// In regular safe mode, it is an allocation and copy.
|
||||
//
|
||||
// Usage: Always maintain a reference to v while result of this call is in use,
|
||||
// and call keepAlive4BytesView(v) at point where done with view.
|
||||
func bytesView(v string) []byte {
|
||||
return []byte(v)
|
||||
}
|
||||
|
||||
// func copyBytes(dst []byte, src []byte) {
|
||||
// copy(dst, src)
|
||||
// }
|
||||
|
||||
// isNil says whether the value v is nil.
|
||||
// This applies to references like map/ptr/unsafepointer/chan/func,
|
||||
// and non-reference values like interface/slice.
|
||||
func isNil(v interface{}) (rv reflect.Value, isnil bool) {
|
||||
rv = rv4i(v)
|
||||
if isnilBitset.isset(byte(rv.Kind())) {
|
||||
isnil = rv.IsNil()
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
// func rvAddr(rv reflect.Value) uintptr {
|
||||
// return rv.UnsafeAddr()
|
||||
// }
|
||||
|
||||
func eq4i(i0, i1 interface{}) bool {
|
||||
return i0 == i1
|
||||
}
|
||||
|
||||
func rv4i(i interface{}) reflect.Value {
|
||||
return reflect.ValueOf(i)
|
||||
}
|
||||
|
||||
func rv2i(rv reflect.Value) interface{} {
|
||||
return rv.Interface()
|
||||
}
|
||||
|
||||
func rvType(rv reflect.Value) reflect.Type {
|
||||
return rv.Type()
|
||||
}
|
||||
|
||||
func rvIsNil(rv reflect.Value) bool {
|
||||
return rv.IsNil()
|
||||
}
|
||||
|
||||
func rvSetSliceLen(rv reflect.Value, length int) {
|
||||
rv.SetLen(length)
|
||||
}
|
||||
|
||||
func rvZeroAddrK(t reflect.Type, k reflect.Kind) reflect.Value {
|
||||
return reflect.New(t).Elem()
|
||||
}
|
||||
|
||||
func rvZeroAddr(t reflect.Type) reflect.Value {
|
||||
return reflect.New(t).Elem()
|
||||
}
|
||||
|
||||
func rvZeroK(t reflect.Type, k reflect.Kind) reflect.Value {
|
||||
return reflect.Zero(t)
|
||||
}
|
||||
|
||||
func rvZero(t reflect.Type) reflect.Value {
|
||||
return reflect.Zero(t)
|
||||
}
|
||||
|
||||
func rvConvert(v reflect.Value, t reflect.Type) (rv reflect.Value) {
|
||||
return v.Convert(t)
|
||||
}
|
||||
|
||||
func rt2id(rt reflect.Type) uintptr {
|
||||
return rv4i(rt).Pointer()
|
||||
}
|
||||
|
||||
func i2rtid(i interface{}) uintptr {
|
||||
return rv4i(reflect.TypeOf(i)).Pointer()
|
||||
}
|
||||
|
||||
// --------------------------
|
||||
|
||||
func isEmptyValue(v reflect.Value, tinfos *TypeInfos, recursive bool) bool {
|
||||
switch v.Kind() {
|
||||
case reflect.Invalid:
|
||||
return true
|
||||
case reflect.Array, reflect.String:
|
||||
return v.Len() == 0
|
||||
case reflect.Map, reflect.Slice, reflect.Chan:
|
||||
return v.IsNil() || v.Len() == 0
|
||||
case reflect.Bool:
|
||||
return !v.Bool()
|
||||
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
|
||||
return v.Int() == 0
|
||||
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
|
||||
return v.Uint() == 0
|
||||
case reflect.Complex64, reflect.Complex128:
|
||||
c := v.Complex()
|
||||
return math.Float64bits(real(c)) == 0 && math.Float64bits(imag(c)) == 0
|
||||
case reflect.Float32, reflect.Float64:
|
||||
return v.Float() == 0
|
||||
case reflect.Func, reflect.UnsafePointer:
|
||||
return v.IsNil()
|
||||
case reflect.Interface, reflect.Ptr:
|
||||
isnil := v.IsNil()
|
||||
if recursive && !isnil {
|
||||
return isEmptyValue(v.Elem(), tinfos, recursive)
|
||||
}
|
||||
return isnil
|
||||
case reflect.Struct:
|
||||
return isEmptyStruct(v, tinfos, recursive)
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
// --------------------------
|
||||
type atomicClsErr struct {
|
||||
v atomic.Value
|
||||
}
|
||||
|
||||
func (x *atomicClsErr) load() (e clsErr) {
|
||||
if i := x.v.Load(); i != nil {
|
||||
e = i.(clsErr)
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func (x *atomicClsErr) store(p clsErr) {
|
||||
x.v.Store(p)
|
||||
}
|
||||
|
||||
// --------------------------
|
||||
type atomicTypeInfoSlice struct {
|
||||
v atomic.Value
|
||||
}
|
||||
|
||||
func (x *atomicTypeInfoSlice) load() (e []rtid2ti) {
|
||||
if i := x.v.Load(); i != nil {
|
||||
e = i.([]rtid2ti)
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func (x *atomicTypeInfoSlice) store(p []rtid2ti) {
|
||||
x.v.Store(p)
|
||||
}
|
||||
|
||||
// --------------------------
|
||||
type atomicRtidFnSlice struct {
|
||||
v atomic.Value
|
||||
}
|
||||
|
||||
func (x *atomicRtidFnSlice) load() (e []codecRtidFn) {
|
||||
if i := x.v.Load(); i != nil {
|
||||
e = i.([]codecRtidFn)
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func (x *atomicRtidFnSlice) store(p []codecRtidFn) {
|
||||
x.v.Store(p)
|
||||
}
|
||||
|
||||
// --------------------------
|
||||
func (n *fauxUnion) ru() reflect.Value {
|
||||
return rv4i(&n.u).Elem()
|
||||
}
|
||||
func (n *fauxUnion) ri() reflect.Value {
|
||||
return rv4i(&n.i).Elem()
|
||||
}
|
||||
func (n *fauxUnion) rf() reflect.Value {
|
||||
return rv4i(&n.f).Elem()
|
||||
}
|
||||
func (n *fauxUnion) rl() reflect.Value {
|
||||
return rv4i(&n.l).Elem()
|
||||
}
|
||||
func (n *fauxUnion) rs() reflect.Value {
|
||||
return rv4i(&n.s).Elem()
|
||||
}
|
||||
func (n *fauxUnion) rt() reflect.Value {
|
||||
return rv4i(&n.t).Elem()
|
||||
}
|
||||
func (n *fauxUnion) rb() reflect.Value {
|
||||
return rv4i(&n.b).Elem()
|
||||
}
|
||||
|
||||
// --------------------------
|
||||
func rvSetBytes(rv reflect.Value, v []byte) {
|
||||
rv.SetBytes(v)
|
||||
}
|
||||
|
||||
func rvSetString(rv reflect.Value, v string) {
|
||||
rv.SetString(v)
|
||||
}
|
||||
|
||||
func rvSetBool(rv reflect.Value, v bool) {
|
||||
rv.SetBool(v)
|
||||
}
|
||||
|
||||
func rvSetTime(rv reflect.Value, v time.Time) {
|
||||
rv.Set(rv4i(v))
|
||||
}
|
||||
|
||||
func rvSetFloat32(rv reflect.Value, v float32) {
|
||||
rv.SetFloat(float64(v))
|
||||
}
|
||||
|
||||
func rvSetFloat64(rv reflect.Value, v float64) {
|
||||
rv.SetFloat(v)
|
||||
}
|
||||
|
||||
func rvSetInt(rv reflect.Value, v int) {
|
||||
rv.SetInt(int64(v))
|
||||
}
|
||||
|
||||
func rvSetInt8(rv reflect.Value, v int8) {
|
||||
rv.SetInt(int64(v))
|
||||
}
|
||||
|
||||
func rvSetInt16(rv reflect.Value, v int16) {
|
||||
rv.SetInt(int64(v))
|
||||
}
|
||||
|
||||
func rvSetInt32(rv reflect.Value, v int32) {
|
||||
rv.SetInt(int64(v))
|
||||
}
|
||||
|
||||
func rvSetInt64(rv reflect.Value, v int64) {
|
||||
rv.SetInt(v)
|
||||
}
|
||||
|
||||
func rvSetUint(rv reflect.Value, v uint) {
|
||||
rv.SetUint(uint64(v))
|
||||
}
|
||||
|
||||
func rvSetUintptr(rv reflect.Value, v uintptr) {
|
||||
rv.SetUint(uint64(v))
|
||||
}
|
||||
|
||||
func rvSetUint8(rv reflect.Value, v uint8) {
|
||||
rv.SetUint(uint64(v))
|
||||
}
|
||||
|
||||
func rvSetUint16(rv reflect.Value, v uint16) {
|
||||
rv.SetUint(uint64(v))
|
||||
}
|
||||
|
||||
func rvSetUint32(rv reflect.Value, v uint32) {
|
||||
rv.SetUint(uint64(v))
|
||||
}
|
||||
|
||||
func rvSetUint64(rv reflect.Value, v uint64) {
|
||||
rv.SetUint(v)
|
||||
}
|
||||
|
||||
// ----------------
|
||||
|
||||
// rvSetDirect is rv.Set for all kinds except reflect.Interface
|
||||
func rvSetDirect(rv reflect.Value, v reflect.Value) {
|
||||
rv.Set(v)
|
||||
}
|
||||
|
||||
func rvSetDirectZero(rv reflect.Value) {
|
||||
rv.Set(reflect.Zero(rv.Type()))
|
||||
}
|
||||
|
||||
// rvSlice returns a slice of the slice of lenth
|
||||
func rvSlice(rv reflect.Value, length int) reflect.Value {
|
||||
return rv.Slice(0, length)
|
||||
}
|
||||
|
||||
// ----------------
|
||||
|
||||
func rvSliceIndex(rv reflect.Value, i int, ti *typeInfo) reflect.Value {
|
||||
return rv.Index(i)
|
||||
}
|
||||
|
||||
func rvSliceZeroCap(t reflect.Type) (v reflect.Value) {
|
||||
return reflect.MakeSlice(t, 0, 0)
|
||||
}
|
||||
|
||||
func rvLenSlice(rv reflect.Value) int {
|
||||
return rv.Len()
|
||||
}
|
||||
|
||||
func rvCapSlice(rv reflect.Value) int {
|
||||
return rv.Cap()
|
||||
}
|
||||
|
||||
func rvGetArrayBytesRO(rv reflect.Value, scratch []byte) (bs []byte) {
|
||||
l := rv.Len()
|
||||
if rv.CanAddr() {
|
||||
return rvGetBytes(rv.Slice(0, l))
|
||||
}
|
||||
|
||||
if l <= cap(scratch) {
|
||||
bs = scratch[:l]
|
||||
} else {
|
||||
bs = make([]byte, l)
|
||||
}
|
||||
reflect.Copy(rv4i(bs), rv)
|
||||
return
|
||||
}
|
||||
|
||||
func rvGetArray4Slice(rv reflect.Value) (v reflect.Value) {
|
||||
v = rvZeroAddrK(reflectArrayOf(rvLenSlice(rv), rvType(rv).Elem()), reflect.Array)
|
||||
reflect.Copy(v, rv)
|
||||
return
|
||||
}
|
||||
|
||||
func rvGetSlice4Array(rv reflect.Value, tslice reflect.Type) (v reflect.Value) {
|
||||
return rv.Slice(0, rv.Len())
|
||||
}
|
||||
|
||||
func rvCopySlice(dest, src reflect.Value) {
|
||||
reflect.Copy(dest, src)
|
||||
}
|
||||
|
||||
// ------------
|
||||
|
||||
func rvGetBool(rv reflect.Value) bool {
|
||||
return rv.Bool()
|
||||
}
|
||||
|
||||
func rvGetBytes(rv reflect.Value) []byte {
|
||||
return rv.Bytes()
|
||||
}
|
||||
|
||||
func rvGetTime(rv reflect.Value) time.Time {
|
||||
return rv2i(rv).(time.Time)
|
||||
}
|
||||
|
||||
func rvGetString(rv reflect.Value) string {
|
||||
return rv.String()
|
||||
}
|
||||
|
||||
func rvGetFloat64(rv reflect.Value) float64 {
|
||||
return rv.Float()
|
||||
}
|
||||
|
||||
func rvGetFloat32(rv reflect.Value) float32 {
|
||||
return float32(rv.Float())
|
||||
}
|
||||
|
||||
func rvGetInt(rv reflect.Value) int {
|
||||
return int(rv.Int())
|
||||
}
|
||||
|
||||
func rvGetInt8(rv reflect.Value) int8 {
|
||||
return int8(rv.Int())
|
||||
}
|
||||
|
||||
func rvGetInt16(rv reflect.Value) int16 {
|
||||
return int16(rv.Int())
|
||||
}
|
||||
|
||||
func rvGetInt32(rv reflect.Value) int32 {
|
||||
return int32(rv.Int())
|
||||
}
|
||||
|
||||
func rvGetInt64(rv reflect.Value) int64 {
|
||||
return rv.Int()
|
||||
}
|
||||
|
||||
func rvGetUint(rv reflect.Value) uint {
|
||||
return uint(rv.Uint())
|
||||
}
|
||||
|
||||
func rvGetUint8(rv reflect.Value) uint8 {
|
||||
return uint8(rv.Uint())
|
||||
}
|
||||
|
||||
func rvGetUint16(rv reflect.Value) uint16 {
|
||||
return uint16(rv.Uint())
|
||||
}
|
||||
|
||||
func rvGetUint32(rv reflect.Value) uint32 {
|
||||
return uint32(rv.Uint())
|
||||
}
|
||||
|
||||
func rvGetUint64(rv reflect.Value) uint64 {
|
||||
return rv.Uint()
|
||||
}
|
||||
|
||||
func rvGetUintptr(rv reflect.Value) uintptr {
|
||||
return uintptr(rv.Uint())
|
||||
}
|
||||
|
||||
func rvLenMap(rv reflect.Value) int {
|
||||
return rv.Len()
|
||||
}
|
||||
|
||||
func rvLenArray(rv reflect.Value) int {
|
||||
return rv.Len()
|
||||
}
|
||||
|
||||
// ------------ map range and map indexing ----------
|
||||
|
||||
func mapGet(m, k, v reflect.Value) (vv reflect.Value) {
|
||||
return m.MapIndex(k)
|
||||
}
|
||||
|
||||
func mapSet(m, k, v reflect.Value) {
|
||||
m.SetMapIndex(k, v)
|
||||
}
|
||||
|
||||
// func mapDelete(m, k reflect.Value) {
|
||||
// m.SetMapIndex(k, reflect.Value{})
|
||||
// }
|
||||
|
||||
// return an addressable reflect value that can be used in mapRange and mapGet operations.
|
||||
//
|
||||
// all calls to mapGet or mapRange will call here to get an addressable reflect.Value.
|
||||
func mapAddrLoopvarRV(t reflect.Type, k reflect.Kind) (r reflect.Value) {
|
||||
return // reflect.New(t).Elem()
|
||||
}
|
||||
|
||||
// ---------- ENCODER optimized ---------------
|
||||
|
||||
func (e *Encoder) jsondriver() *jsonEncDriver {
|
||||
return e.e.(*jsonEncDriver)
|
||||
}
|
||||
|
||||
// ---------- DECODER optimized ---------------
|
||||
|
||||
func (d *Decoder) checkBreak() bool {
|
||||
return d.d.CheckBreak()
|
||||
}
|
||||
|
||||
func (d *Decoder) jsondriver() *jsonDecDriver {
|
||||
return d.d.(*jsonDecDriver)
|
||||
}
|
||||
|
||||
// ---------- structFieldInfo optimized ---------------
|
||||
|
||||
func (n *structFieldInfoPathNode) rvField(v reflect.Value) reflect.Value {
|
||||
return v.Field(int(n.index))
|
||||
}
|
||||
|
||||
// ---------- others ---------------
|
||||
|
||||
/*
|
||||
|
||||
func hashShortString(b []byte) (h uintptr) {
|
||||
return uintptr(adler32.Checksum(b))
|
||||
}
|
||||
|
||||
// func hashShortString(b []byte) (h uint64) {
|
||||
// // culled from https://github.com/golang/go/issues/32779#issuecomment-735494578
|
||||
// // Read the string in two parts using wide-integer loads.
|
||||
// // The prefix and suffix may overlap, which is fine.
|
||||
// switch {
|
||||
// case len(b) > 8:
|
||||
// h ^= binary.LittleEndian.Uint64(b[:8])
|
||||
// h *= 0x00000100000001B3 // inspired by FNV-64
|
||||
// h ^= binary.LittleEndian.Uint64(b[len(b)-8:])
|
||||
// case len(b) > 4:
|
||||
// h ^= uint64(binary.LittleEndian.Uint32(b[:4]))
|
||||
// h *= 0x01000193 // inspired by FNV-32
|
||||
// h ^= uint64(binary.LittleEndian.Uint32(b[len(b)-4:]))
|
||||
// default:
|
||||
// h ^= uint64(binary.LittleEndian.Uint16(b[:2]))
|
||||
// h *= 0x010f // inspired by hypothetical FNV-16
|
||||
// h ^= uint64(binary.LittleEndian.Uint16(b[len(b)-2:]))
|
||||
// }
|
||||
//
|
||||
// // Collapse a 64-bit, 32-bit, or 16-bit hash into an 8-bit hash.
|
||||
// h ^= h >> 32
|
||||
// h ^= h >> 16
|
||||
// h ^= h >> 8
|
||||
//
|
||||
// // The cache has 8 buckets based on the lower 3-bits of the length.
|
||||
// h = ((h << 3) | uint64(len(b)&7))
|
||||
// return
|
||||
// }
|
||||
|
||||
*/
|
1022
vendor/github.com/ugorji/go/codec/helper_unsafe.go
generated
vendored
Normal file
1022
vendor/github.com/ugorji/go/codec/helper_unsafe.go
generated
vendored
Normal file
File diff suppressed because it is too large
Load diff
25
vendor/github.com/ugorji/go/codec/helper_unsafe_compiler_gc.go
generated
vendored
Normal file
25
vendor/github.com/ugorji/go/codec/helper_unsafe_compiler_gc.go
generated
vendored
Normal file
|
@ -0,0 +1,25 @@
|
|||
// +build !safe
|
||||
// +build !appengine
|
||||
// +build go1.8
|
||||
// +build gc
|
||||
|
||||
// Copyright (c) 2012-2020 Ugorji Nwoke. All rights reserved.
|
||||
// Use of this source code is governed by a MIT license found in the LICENSE file.
|
||||
|
||||
package codec
|
||||
|
||||
import (
|
||||
"reflect"
|
||||
"unsafe"
|
||||
)
|
||||
|
||||
func rvType(rv reflect.Value) reflect.Type {
|
||||
return rvPtrToType(((*unsafeReflectValue)(unsafe.Pointer(&rv))).typ) // rv.Type()
|
||||
}
|
||||
|
||||
//go:linkname unsafeZeroArr runtime.zeroVal
|
||||
var unsafeZeroArr [1024]byte
|
||||
|
||||
//go:linkname rvPtrToType reflect.toType
|
||||
//go:noescape
|
||||
func rvPtrToType(typ unsafe.Pointer) reflect.Type
|
17
vendor/github.com/ugorji/go/codec/helper_unsafe_compiler_not_gc.go
generated
vendored
Normal file
17
vendor/github.com/ugorji/go/codec/helper_unsafe_compiler_not_gc.go
generated
vendored
Normal file
|
@ -0,0 +1,17 @@
|
|||
// +build !safe
|
||||
// +build !appengine
|
||||
// +build go1.8
|
||||
// +build !gc
|
||||
|
||||
// Copyright (c) 2012-2020 Ugorji Nwoke. All rights reserved.
|
||||
// Use of this source code is governed by a MIT license found in the LICENSE file.
|
||||
|
||||
package codec
|
||||
|
||||
import "reflect"
|
||||
|
||||
var unsafeZeroArr [1024]byte
|
||||
|
||||
func rvType(rv reflect.Value) reflect.Type {
|
||||
return rv.Type()
|
||||
}
|
1438
vendor/github.com/ugorji/go/codec/json.go
generated
vendored
Normal file
1438
vendor/github.com/ugorji/go/codec/json.go
generated
vendored
Normal file
File diff suppressed because it is too large
Load diff
178
vendor/github.com/ugorji/go/codec/mammoth-test.go.tmpl
generated
vendored
Normal file
178
vendor/github.com/ugorji/go/codec/mammoth-test.go.tmpl
generated
vendored
Normal file
|
@ -0,0 +1,178 @@
|
|||
// Copyright (c) 2012-2020 Ugorji Nwoke. All rights reserved.
|
||||
// Use of this source code is governed by a MIT license found in the LICENSE file.
|
||||
|
||||
// Code generated from mammoth-test.go.tmpl - DO NOT EDIT.
|
||||
|
||||
package codec
|
||||
|
||||
import "testing"
|
||||
import "fmt"
|
||||
|
||||
// TestMammoth has all the different paths optimized in fast-path
|
||||
// It has all the primitives, slices and maps.
|
||||
//
|
||||
// For each of those types, it has a pointer and a non-pointer field.
|
||||
|
||||
func init() { _ = fmt.Printf } // so we can include fmt as needed
|
||||
|
||||
type TestMammoth struct {
|
||||
|
||||
{{range .Values }}{{if .Primitive -}}
|
||||
{{ .MethodNamePfx "F" true }} {{ .Primitive }}
|
||||
{{ .MethodNamePfx "Fptr" true }} *{{ .Primitive }}
|
||||
{{end}}{{end}}
|
||||
|
||||
{{range .Values }}{{if not .Primitive }}{{if not .MapKey -}}
|
||||
{{ .MethodNamePfx "F" false }} []{{ .Elem }}
|
||||
{{ .MethodNamePfx "Fptr" false }} *[]{{ .Elem }}
|
||||
{{end}}{{end}}{{end}}
|
||||
|
||||
{{range .Values }}{{if not .Primitive }}{{if .MapKey -}}
|
||||
{{ .MethodNamePfx "F" false }} map[{{ .MapKey }}]{{ .Elem }}
|
||||
{{ .MethodNamePfx "Fptr" false }} *map[{{ .MapKey }}]{{ .Elem }}
|
||||
{{end}}{{end}}{{end}}
|
||||
|
||||
}
|
||||
|
||||
{{range .Values }}{{if not .Primitive }}{{if not .MapKey -}}
|
||||
type {{ .MethodNamePfx "typMbs" false }} []{{ .Elem }}
|
||||
func (_ {{ .MethodNamePfx "typMbs" false }}) MapBySlice() { }
|
||||
{{end}}{{end}}{{end}}
|
||||
|
||||
{{range .Values }}{{if not .Primitive }}{{if .MapKey -}}
|
||||
type {{ .MethodNamePfx "typMap" false }} map[{{ .MapKey }}]{{ .Elem }}
|
||||
{{end}}{{end}}{{end}}
|
||||
|
||||
func doTestMammothSlices(t *testing.T, h Handle) {
|
||||
{{range $i, $e := .Values }}{{if not .Primitive }}{{if not .MapKey -}}
|
||||
var v{{$i}}va [8]{{ .Elem }}
|
||||
for _, v := range [][]{{ .Elem }}{ nil, {}, { {{ nonzerocmd .Elem }}, {{ zerocmd .Elem }}, {{ zerocmd .Elem }}, {{ nonzerocmd .Elem }} } } {
|
||||
{{/*
|
||||
// fmt.Printf(">>>> running mammoth slice v{{$i}}: %v\n", v)
|
||||
// - encode value to some []byte
|
||||
// - decode into a length-wise-equal []byte
|
||||
// - check if equal to initial slice
|
||||
// - encode ptr to the value
|
||||
// - check if encode bytes are same
|
||||
// - decode into ptrs to: nil, then 1-elem slice, equal-length, then large len slice
|
||||
// - decode into non-addressable slice of equal length, then larger len
|
||||
// - for each decode, compare elem-by-elem to the original slice
|
||||
// -
|
||||
// - rinse and repeat for a MapBySlice version
|
||||
// -
|
||||
*/ -}}
|
||||
var v{{$i}}v1, v{{$i}}v2 []{{ .Elem }}
|
||||
var bs{{$i}} []byte
|
||||
v{{$i}}v1 = v
|
||||
bs{{$i}} = testMarshalErr(v{{$i}}v1, h, t, "enc-slice-v{{$i}}")
|
||||
if v == nil {
|
||||
v{{$i}}v2 = make([]{{ .Elem }}, 2)
|
||||
testUnmarshalErr(v{{$i}}v2, bs{{$i}}, h, t, "dec-slice-v{{$i}}")
|
||||
testDeepEqualErr(v{{$i}}v2[0], v{{$i}}v2[1], t, "equal-slice-v{{$i}}") // should not change
|
||||
testDeepEqualErr(len(v{{$i}}v2), 2, t, "equal-slice-v{{$i}}") // should not change
|
||||
v{{$i}}v2 = make([]{{ .Elem }}, 2)
|
||||
testUnmarshalErr(rv4i(v{{$i}}v2), bs{{$i}}, h, t, "dec-slice-v{{$i}}-noaddr") // non-addressable value
|
||||
testDeepEqualErr(v{{$i}}v2[0], v{{$i}}v2[1], t, "equal-slice-v{{$i}}-noaddr") // should not change
|
||||
testDeepEqualErr(len(v{{$i}}v2), 2, t, "equal-slice-v{{$i}}") // should not change
|
||||
} else {
|
||||
v{{$i}}v2 = make([]{{ .Elem }}, len(v))
|
||||
testUnmarshalErr(v{{$i}}v2, bs{{$i}}, h, t, "dec-slice-v{{$i}}")
|
||||
testDeepEqualErr(v{{$i}}v1, v{{$i}}v2, t, "equal-slice-v{{$i}}")
|
||||
v{{$i}}v2 = make([]{{ .Elem }}, len(v))
|
||||
testUnmarshalErr(rv4i(v{{$i}}v2), bs{{$i}}, h, t, "dec-slice-v{{$i}}-noaddr") // non-addressable value
|
||||
testDeepEqualErr(v{{$i}}v1, v{{$i}}v2, t, "equal-slice-v{{$i}}-noaddr")
|
||||
}
|
||||
testReleaseBytes(bs{{$i}})
|
||||
// ...
|
||||
bs{{$i}} = testMarshalErr(&v{{$i}}v1, h, t, "enc-slice-v{{$i}}-p")
|
||||
v{{$i}}v2 = nil
|
||||
testUnmarshalErr(&v{{$i}}v2, bs{{$i}}, h, t, "dec-slice-v{{$i}}-p")
|
||||
testDeepEqualErr(v{{$i}}v1, v{{$i}}v2, t, "equal-slice-v{{$i}}-p")
|
||||
v{{$i}}va = [8]{{ .Elem }}{} // clear the array
|
||||
v{{$i}}v2 = v{{$i}}va[:1:1]
|
||||
testUnmarshalErr(&v{{$i}}v2, bs{{$i}}, h, t, "dec-slice-v{{$i}}-p-1")
|
||||
testDeepEqualErr(v{{$i}}v1, v{{$i}}v2, t, "equal-slice-v{{$i}}-p-1")
|
||||
v{{$i}}va = [8]{{ .Elem }}{} // clear the array
|
||||
v{{$i}}v2 = v{{$i}}va[:len(v{{$i}}v1):len(v{{$i}}v1)]
|
||||
testUnmarshalErr(&v{{$i}}v2, bs{{$i}}, h, t, "dec-slice-v{{$i}}-p-len")
|
||||
testDeepEqualErr(v{{$i}}v1, v{{$i}}v2, t, "equal-slice-v{{$i}}-p-len")
|
||||
v{{$i}}va = [8]{{ .Elem }}{} // clear the array
|
||||
v{{$i}}v2 = v{{$i}}va[:]
|
||||
testUnmarshalErr(&v{{$i}}v2, bs{{$i}}, h, t, "dec-slice-v{{$i}}-p-cap")
|
||||
testDeepEqualErr(v{{$i}}v1, v{{$i}}v2, t, "equal-slice-v{{$i}}-p-cap")
|
||||
if len(v{{$i}}v1) > 1 {
|
||||
v{{$i}}va = [8]{{ .Elem }}{} // clear the array
|
||||
testUnmarshalErr((&v{{$i}}va)[:len(v{{$i}}v1)], bs{{$i}}, h, t, "dec-slice-v{{$i}}-p-len-noaddr")
|
||||
testDeepEqualErr(v{{$i}}v1, v{{$i}}va[:len(v{{$i}}v1)], t, "equal-slice-v{{$i}}-p-len-noaddr")
|
||||
v{{$i}}va = [8]{{ .Elem }}{} // clear the array
|
||||
testUnmarshalErr((&v{{$i}}va)[:], bs{{$i}}, h, t, "dec-slice-v{{$i}}-p-cap-noaddr")
|
||||
testDeepEqualErr(v{{$i}}v1, v{{$i}}va[:len(v{{$i}}v1)], t, "equal-slice-v{{$i}}-p-cap-noaddr")
|
||||
}
|
||||
testReleaseBytes(bs{{$i}})
|
||||
// ...
|
||||
var v{{$i}}v3, v{{$i}}v4 {{ .MethodNamePfx "typMbs" false }}
|
||||
v{{$i}}v2 = nil
|
||||
if v != nil { v{{$i}}v2 = make([]{{ .Elem }}, len(v)) }
|
||||
v{{$i}}v3 = {{ .MethodNamePfx "typMbs" false }}(v{{$i}}v1)
|
||||
v{{$i}}v4 = {{ .MethodNamePfx "typMbs" false }}(v{{$i}}v2)
|
||||
if v != nil {
|
||||
bs{{$i}} = testMarshalErr(v{{$i}}v3, h, t, "enc-slice-v{{$i}}-custom")
|
||||
testUnmarshalErr(v{{$i}}v4, bs{{$i}}, h, t, "dec-slice-v{{$i}}-custom")
|
||||
testDeepEqualErr(v{{$i}}v3, v{{$i}}v4, t, "equal-slice-v{{$i}}-custom")
|
||||
testReleaseBytes(bs{{$i}})
|
||||
}
|
||||
bs{{$i}} = testMarshalErr(&v{{$i}}v3, h, t, "enc-slice-v{{$i}}-custom-p")
|
||||
v{{$i}}v2 = nil
|
||||
v{{$i}}v4 = {{ .MethodNamePfx "typMbs" false }}(v{{$i}}v2)
|
||||
testUnmarshalErr(&v{{$i}}v4, bs{{$i}}, h, t, "dec-slice-v{{$i}}-custom-p")
|
||||
testDeepEqualErr(v{{$i}}v3, v{{$i}}v4, t, "equal-slice-v{{$i}}-custom-p")
|
||||
testReleaseBytes(bs{{$i}})
|
||||
}
|
||||
{{end}}{{end}}{{end}}
|
||||
}
|
||||
|
||||
func doTestMammothMaps(t *testing.T, h Handle) {
|
||||
{{range $i, $e := .Values }}{{if not .Primitive }}{{if .MapKey -}}
|
||||
for _, v := range []map[{{ .MapKey }}]{{ .Elem }}{ nil, {}, { {{ nonzerocmd .MapKey }}:{{ zerocmd .Elem }} {{if ne "bool" .MapKey}}, {{ nonzerocmd .MapKey }}:{{ nonzerocmd .Elem }} {{end}} } } {
|
||||
// fmt.Printf(">>>> running mammoth map v{{$i}}: %v\n", v)
|
||||
var v{{$i}}v1, v{{$i}}v2 map[{{ .MapKey }}]{{ .Elem }}
|
||||
var bs{{$i}} []byte
|
||||
v{{$i}}v1 = v
|
||||
bs{{$i}} = testMarshalErr(v{{$i}}v1, h, t, "enc-map-v{{$i}}")
|
||||
if v != nil {
|
||||
if v == nil { v{{$i}}v2 = nil } else { v{{$i}}v2 = make(map[{{ .MapKey }}]{{ .Elem }}, len(v)) } // reset map
|
||||
testUnmarshalErr(v{{$i}}v2, bs{{$i}}, h, t, "dec-map-v{{$i}}")
|
||||
testDeepEqualErr(v{{$i}}v1, v{{$i}}v2, t, "equal-map-v{{$i}}")
|
||||
if v == nil { v{{$i}}v2 = nil } else { v{{$i}}v2 = make(map[{{ .MapKey }}]{{ .Elem }}, len(v)) } // reset map
|
||||
testUnmarshalErr(rv4i(v{{$i}}v2), bs{{$i}}, h, t, "dec-map-v{{$i}}-noaddr") // decode into non-addressable map value
|
||||
testDeepEqualErr(v{{$i}}v1, v{{$i}}v2, t, "equal-map-v{{$i}}-noaddr")
|
||||
}
|
||||
if v == nil { v{{$i}}v2 = nil } else { v{{$i}}v2 = make(map[{{ .MapKey }}]{{ .Elem }}, len(v)) } // reset map
|
||||
testUnmarshalErr(&v{{$i}}v2, bs{{$i}}, h, t, "dec-map-v{{$i}}-p-len")
|
||||
testDeepEqualErr(v{{$i}}v1, v{{$i}}v2, t, "equal-map-v{{$i}}-p-len")
|
||||
testReleaseBytes(bs{{$i}})
|
||||
bs{{$i}} = testMarshalErr(&v{{$i}}v1, h, t, "enc-map-v{{$i}}-p")
|
||||
v{{$i}}v2 = nil
|
||||
testUnmarshalErr(&v{{$i}}v2, bs{{$i}}, h, t, "dec-map-v{{$i}}-p-nil")
|
||||
testDeepEqualErr(v{{$i}}v1, v{{$i}}v2, t, "equal-map-v{{$i}}-p-nil")
|
||||
testReleaseBytes(bs{{$i}})
|
||||
// ...
|
||||
if v == nil { v{{$i}}v2 = nil } else { v{{$i}}v2 = make(map[{{ .MapKey }}]{{ .Elem }}, len(v)) } // reset map
|
||||
var v{{$i}}v3, v{{$i}}v4 {{ .MethodNamePfx "typMap" false }}
|
||||
v{{$i}}v3 = {{ .MethodNamePfx "typMap" false }}(v{{$i}}v1)
|
||||
v{{$i}}v4 = {{ .MethodNamePfx "typMap" false }}(v{{$i}}v2)
|
||||
if v != nil {
|
||||
bs{{$i}} = testMarshalErr(v{{$i}}v3, h, t, "enc-map-v{{$i}}-custom")
|
||||
testUnmarshalErr(v{{$i}}v4, bs{{$i}}, h, t, "dec-map-v{{$i}}-p-len")
|
||||
testDeepEqualErr(v{{$i}}v3, v{{$i}}v4, t, "equal-map-v{{$i}}-p-len")
|
||||
testReleaseBytes(bs{{$i}})
|
||||
}
|
||||
}
|
||||
{{end}}{{end}}{{end}}
|
||||
|
||||
}
|
||||
|
||||
func doTestMammothMapsAndSlices(t *testing.T, h Handle) {
|
||||
doTestMammothSlices(t, h)
|
||||
doTestMammothMaps(t, h)
|
||||
}
|
94
vendor/github.com/ugorji/go/codec/mammoth2-test.go.tmpl
generated
vendored
Normal file
94
vendor/github.com/ugorji/go/codec/mammoth2-test.go.tmpl
generated
vendored
Normal file
|
@ -0,0 +1,94 @@
|
|||
// +build !notfastpath
|
||||
|
||||
// Copyright (c) 2012-2020 Ugorji Nwoke. All rights reserved.
|
||||
// Use of this source code is governed by a MIT license found in the LICENSE file.
|
||||
|
||||
// Code generated from mammoth2-test.go.tmpl - DO NOT EDIT.
|
||||
|
||||
package codec
|
||||
|
||||
// Increase codecoverage by covering all the codecgen paths, in fast-path and gen-helper.go....
|
||||
//
|
||||
// Add:
|
||||
// - test file for creating a mammoth generated file as _mammoth_generated.go
|
||||
// - generate a second mammoth files in a different file: mammoth2_generated_test.go
|
||||
// - mammoth-test.go.tmpl will do this
|
||||
// - run codecgen on it, into mammoth2_codecgen_generated_test.go (no build tags)
|
||||
// - as part of TestMammoth, run it also
|
||||
// - this will cover all the codecgen, gen-helper, etc in one full run
|
||||
// - check in mammoth* files into github also
|
||||
// - then
|
||||
//
|
||||
// Now, add some types:
|
||||
// - some that implement BinaryMarshal, TextMarshal, JSONMarshal, and one that implements none of it
|
||||
// - create a wrapper type that includes TestMammoth2, with it in slices, and maps, and the custom types
|
||||
// - this wrapper object is what we work encode/decode (so that the codecgen methods are called)
|
||||
|
||||
|
||||
// import "encoding/binary"
|
||||
import "fmt"
|
||||
|
||||
type TestMammoth2 struct {
|
||||
|
||||
{{range .Values }}{{if .Primitive }}{{/*
|
||||
*/}}{{ .MethodNamePfx "F" true }} {{ .Primitive }}
|
||||
{{ .MethodNamePfx "Fptr" true }} *{{ .Primitive }}
|
||||
{{end}}{{end}}
|
||||
|
||||
{{range .Values }}{{if not .Primitive }}{{if not .MapKey }}{{/*
|
||||
*/}}{{ .MethodNamePfx "F" false }} []{{ .Elem }}
|
||||
{{ .MethodNamePfx "Fptr" false }} *[]{{ .Elem }}
|
||||
{{end}}{{end}}{{end}}
|
||||
|
||||
{{range .Values }}{{if not .Primitive }}{{if .MapKey }}{{/*
|
||||
*/}}{{ .MethodNamePfx "F" false }} map[{{ .MapKey }}]{{ .Elem }}
|
||||
{{ .MethodNamePfx "Fptr" false }} *map[{{ .MapKey }}]{{ .Elem }}
|
||||
{{end}}{{end}}{{end}}
|
||||
|
||||
}
|
||||
|
||||
// -----------
|
||||
|
||||
type testMammoth2Binary uint64
|
||||
func (x testMammoth2Binary) MarshalBinary() (data []byte, err error) {
|
||||
data = make([]byte, 8)
|
||||
bigenstd.PutUint64(data, uint64(x))
|
||||
return
|
||||
}
|
||||
func (x *testMammoth2Binary) UnmarshalBinary(data []byte) (err error) {
|
||||
*x = testMammoth2Binary(bigenstd.Uint64(data))
|
||||
return
|
||||
}
|
||||
|
||||
type testMammoth2Text uint64
|
||||
func (x testMammoth2Text) MarshalText() (data []byte, err error) {
|
||||
data = []byte(fmt.Sprintf("%b", uint64(x)))
|
||||
return
|
||||
}
|
||||
func (x *testMammoth2Text) UnmarshalText(data []byte) (err error) {
|
||||
_, err = fmt.Sscanf(string(data), "%b", (*uint64)(x))
|
||||
return
|
||||
}
|
||||
|
||||
type testMammoth2Json uint64
|
||||
func (x testMammoth2Json) MarshalJSON() (data []byte, err error) {
|
||||
data = []byte(fmt.Sprintf("%v", uint64(x)))
|
||||
return
|
||||
}
|
||||
func (x *testMammoth2Json) UnmarshalJSON(data []byte) (err error) {
|
||||
_, err = fmt.Sscanf(string(data), "%v", (*uint64)(x))
|
||||
return
|
||||
}
|
||||
|
||||
type testMammoth2Basic [4]uint64
|
||||
|
||||
type TestMammoth2Wrapper struct {
|
||||
V TestMammoth2
|
||||
T testMammoth2Text
|
||||
B testMammoth2Binary
|
||||
J testMammoth2Json
|
||||
C testMammoth2Basic
|
||||
M map[testMammoth2Basic]TestMammoth2
|
||||
L []TestMammoth2
|
||||
A [4]int64
|
||||
}
|
1185
vendor/github.com/ugorji/go/codec/msgpack.go
generated
vendored
Normal file
1185
vendor/github.com/ugorji/go/codec/msgpack.go
generated
vendored
Normal file
File diff suppressed because it is too large
Load diff
813
vendor/github.com/ugorji/go/codec/reader.go
generated
vendored
Normal file
813
vendor/github.com/ugorji/go/codec/reader.go
generated
vendored
Normal file
|
@ -0,0 +1,813 @@
|
|||
// Copyright (c) 2012-2020 Ugorji Nwoke. All rights reserved.
|
||||
// Use of this source code is governed by a MIT license found in the LICENSE file.
|
||||
|
||||
package codec
|
||||
|
||||
import "io"
|
||||
|
||||
// decReader abstracts the reading source, allowing implementations that can
|
||||
// read from an io.Reader or directly off a byte slice with zero-copying.
|
||||
type decReader interface {
|
||||
// readx will use the implementation scratch buffer if possible i.e. n < len(scratchbuf), OR
|
||||
// just return a view of the []byte being decoded from.
|
||||
readx(n uint) []byte
|
||||
readb([]byte)
|
||||
|
||||
readn1() byte
|
||||
readn2() [2]byte
|
||||
readn3() [3]byte
|
||||
readn4() [4]byte
|
||||
readn8() [8]byte
|
||||
// readn1eof() (v uint8, eof bool)
|
||||
|
||||
// // read up to 8 bytes at a time
|
||||
// readn(num uint8) (v [8]byte)
|
||||
|
||||
numread() uint // number of bytes read
|
||||
|
||||
// readNumber(includeLastByteRead bool) []byte
|
||||
|
||||
// skip any whitespace characters, and return the first non-matching byte
|
||||
skipWhitespace() (token byte)
|
||||
|
||||
// jsonReadNum will include last read byte in first element of slice,
|
||||
// and continue numeric characters until it sees a non-numeric char
|
||||
// or EOF. If it sees a non-numeric character, it will unread that.
|
||||
jsonReadNum() []byte
|
||||
|
||||
// jsonReadAsisChars will read json plain characters (anything but " or \)
|
||||
// and return a slice terminated by a non-json asis character.
|
||||
jsonReadAsisChars() []byte
|
||||
|
||||
// skip will skip any byte that matches, and return the first non-matching byte
|
||||
// skip(accept *bitset256) (token byte)
|
||||
|
||||
// readTo will read any byte that matches, stopping once no-longer matching.
|
||||
// readTo(accept *bitset256) (out []byte)
|
||||
|
||||
// readUntil will read, only stopping once it matches the 'stop' byte (which it excludes).
|
||||
readUntil(stop byte) (out []byte)
|
||||
}
|
||||
|
||||
// ------------------------------------------------
|
||||
|
||||
type unreadByteStatus uint8
|
||||
|
||||
// unreadByteStatus goes from
|
||||
// undefined (when initialized) -- (read) --> canUnread -- (unread) --> canRead ...
|
||||
const (
|
||||
unreadByteUndefined unreadByteStatus = iota
|
||||
unreadByteCanRead
|
||||
unreadByteCanUnread
|
||||
)
|
||||
|
||||
// --------------------
|
||||
|
||||
type ioDecReaderCommon struct {
|
||||
r io.Reader // the reader passed in
|
||||
|
||||
n uint // num read
|
||||
|
||||
l byte // last byte
|
||||
ls unreadByteStatus // last byte status
|
||||
|
||||
b [6]byte // tiny buffer for reading single bytes
|
||||
|
||||
blist *bytesFreelist
|
||||
|
||||
bufr []byte // buffer for readTo/readUntil
|
||||
}
|
||||
|
||||
func (z *ioDecReaderCommon) reset(r io.Reader, blist *bytesFreelist) {
|
||||
z.blist = blist
|
||||
z.r = r
|
||||
z.ls = unreadByteUndefined
|
||||
z.l, z.n = 0, 0
|
||||
}
|
||||
|
||||
func (z *ioDecReaderCommon) numread() uint {
|
||||
return z.n
|
||||
}
|
||||
|
||||
// ------------------------------------------
|
||||
|
||||
// ioDecReader is a decReader that reads off an io.Reader.
|
||||
//
|
||||
// It also has a fallback implementation of ByteScanner if needed.
|
||||
type ioDecReader struct {
|
||||
ioDecReaderCommon
|
||||
|
||||
br io.ByteScanner
|
||||
|
||||
x [64 + 48]byte // for: get struct field name, swallow valueTypeBytes, etc
|
||||
}
|
||||
|
||||
func (z *ioDecReader) reset(r io.Reader, blist *bytesFreelist) {
|
||||
z.ioDecReaderCommon.reset(r, blist)
|
||||
|
||||
z.br, _ = r.(io.ByteScanner)
|
||||
}
|
||||
|
||||
func (z *ioDecReader) Read(p []byte) (n int, err error) {
|
||||
if len(p) == 0 {
|
||||
return
|
||||
}
|
||||
var firstByte bool
|
||||
if z.ls == unreadByteCanRead {
|
||||
z.ls = unreadByteCanUnread
|
||||
p[0] = z.l
|
||||
if len(p) == 1 {
|
||||
n = 1
|
||||
return
|
||||
}
|
||||
firstByte = true
|
||||
p = p[1:]
|
||||
}
|
||||
n, err = z.r.Read(p)
|
||||
if n > 0 {
|
||||
if err == io.EOF && n == len(p) {
|
||||
err = nil // read was successful, so postpone EOF (till next time)
|
||||
}
|
||||
z.l = p[n-1]
|
||||
z.ls = unreadByteCanUnread
|
||||
}
|
||||
if firstByte {
|
||||
n++
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func (z *ioDecReader) ReadByte() (c byte, err error) {
|
||||
if z.br != nil {
|
||||
c, err = z.br.ReadByte()
|
||||
if err == nil {
|
||||
z.l = c
|
||||
z.ls = unreadByteCanUnread
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
n, err := z.Read(z.b[:1])
|
||||
if n == 1 {
|
||||
c = z.b[0]
|
||||
if err == io.EOF {
|
||||
err = nil // read was successful, so postpone EOF (till next time)
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func (z *ioDecReader) UnreadByte() (err error) {
|
||||
if z.br != nil {
|
||||
err = z.br.UnreadByte()
|
||||
if err == nil {
|
||||
z.ls = unreadByteCanRead
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
switch z.ls {
|
||||
case unreadByteCanUnread:
|
||||
z.ls = unreadByteCanRead
|
||||
case unreadByteCanRead:
|
||||
err = errDecUnreadByteLastByteNotRead
|
||||
case unreadByteUndefined:
|
||||
err = errDecUnreadByteNothingToRead
|
||||
default:
|
||||
err = errDecUnreadByteUnknown
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func (z *ioDecReader) readn2() (bs [2]byte) {
|
||||
z.readb(bs[:])
|
||||
return
|
||||
}
|
||||
|
||||
func (z *ioDecReader) readn3() (bs [3]byte) {
|
||||
z.readb(bs[:])
|
||||
return
|
||||
}
|
||||
|
||||
func (z *ioDecReader) readn4() (bs [4]byte) {
|
||||
z.readb(bs[:])
|
||||
return
|
||||
}
|
||||
|
||||
func (z *ioDecReader) readn8() (bs [8]byte) {
|
||||
z.readb(bs[:])
|
||||
return
|
||||
}
|
||||
|
||||
func (z *ioDecReader) readx(n uint) (bs []byte) {
|
||||
if n == 0 {
|
||||
return
|
||||
}
|
||||
if n < uint(len(z.x)) {
|
||||
bs = z.x[:n]
|
||||
} else {
|
||||
bs = make([]byte, n)
|
||||
}
|
||||
_, err := readFull(z.r, bs)
|
||||
halt.onerror(err)
|
||||
z.n += uint(len(bs))
|
||||
return
|
||||
}
|
||||
|
||||
func (z *ioDecReader) readb(bs []byte) {
|
||||
if len(bs) == 0 {
|
||||
return
|
||||
}
|
||||
_, err := readFull(z.r, bs)
|
||||
halt.onerror(err)
|
||||
z.n += uint(len(bs))
|
||||
}
|
||||
|
||||
func (z *ioDecReader) readn1() (b uint8) {
|
||||
b, err := z.ReadByte()
|
||||
halt.onerror(err)
|
||||
z.n++
|
||||
return
|
||||
}
|
||||
|
||||
func (z *ioDecReader) readn1eof() (b uint8, eof bool) {
|
||||
b, err := z.ReadByte()
|
||||
if err == nil {
|
||||
z.n++
|
||||
} else if err == io.EOF {
|
||||
eof = true
|
||||
} else {
|
||||
halt.onerror(err)
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func (z *ioDecReader) jsonReadNum() (bs []byte) {
|
||||
z.unreadn1()
|
||||
z.bufr = z.blist.check(z.bufr, 256)
|
||||
LOOP:
|
||||
i, eof := z.readn1eof()
|
||||
if eof {
|
||||
return z.bufr
|
||||
}
|
||||
if isNumberChar(i) {
|
||||
z.bufr = append(z.bufr, i)
|
||||
goto LOOP
|
||||
}
|
||||
z.unreadn1()
|
||||
return z.bufr
|
||||
}
|
||||
|
||||
func (z *ioDecReader) jsonReadAsisChars() (bs []byte) {
|
||||
z.bufr = z.blist.check(z.bufr, 256)
|
||||
LOOP:
|
||||
i := z.readn1()
|
||||
z.bufr = append(z.bufr, i)
|
||||
if i == '"' || i == '\\' {
|
||||
return z.bufr
|
||||
}
|
||||
goto LOOP
|
||||
}
|
||||
|
||||
func (z *ioDecReader) skipWhitespace() (token byte) {
|
||||
LOOP:
|
||||
token = z.readn1()
|
||||
if isWhitespaceChar(token) {
|
||||
goto LOOP
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func (z *ioDecReader) readUntil(stop byte) []byte {
|
||||
z.bufr = z.blist.check(z.bufr, 256)
|
||||
LOOP:
|
||||
token := z.readn1()
|
||||
z.bufr = append(z.bufr, token)
|
||||
if token == stop {
|
||||
return z.bufr[:len(z.bufr)-1]
|
||||
}
|
||||
goto LOOP
|
||||
}
|
||||
|
||||
func (z *ioDecReader) unreadn1() {
|
||||
err := z.UnreadByte()
|
||||
halt.onerror(err)
|
||||
z.n--
|
||||
}
|
||||
|
||||
// ------------------------------------
|
||||
|
||||
type bufioDecReader struct {
|
||||
ioDecReaderCommon
|
||||
|
||||
c uint // cursor
|
||||
buf []byte
|
||||
}
|
||||
|
||||
func (z *bufioDecReader) reset(r io.Reader, bufsize int, blist *bytesFreelist) {
|
||||
z.ioDecReaderCommon.reset(r, blist)
|
||||
z.c = 0
|
||||
if cap(z.buf) < bufsize {
|
||||
z.buf = blist.get(bufsize)
|
||||
} else {
|
||||
z.buf = z.buf[:0]
|
||||
}
|
||||
}
|
||||
|
||||
func (z *bufioDecReader) readb(p []byte) {
|
||||
var n = uint(copy(p, z.buf[z.c:]))
|
||||
z.n += n
|
||||
z.c += n
|
||||
if len(p) != int(n) {
|
||||
z.readbFill(p, n, true, false)
|
||||
}
|
||||
}
|
||||
|
||||
func readbFillHandleErr(err error, must, eof bool) (isEOF bool) {
|
||||
if err == io.EOF {
|
||||
isEOF = true
|
||||
}
|
||||
if must && !(eof && isEOF) {
|
||||
halt.onerror(err)
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func (z *bufioDecReader) readbFill(p0 []byte, n uint, must, eof bool) (isEOF bool, err error) {
|
||||
// at this point, there's nothing in z.buf to read (z.buf is fully consumed)
|
||||
var p []byte
|
||||
if p0 != nil {
|
||||
p = p0[n:]
|
||||
}
|
||||
var n2 uint
|
||||
if len(p) > cap(z.buf) {
|
||||
n2, err = readFull(z.r, p)
|
||||
if err != nil {
|
||||
isEOF = readbFillHandleErr(err, must, eof)
|
||||
return
|
||||
}
|
||||
n += n2
|
||||
z.n += n2
|
||||
// always keep last byte in z.buf
|
||||
z.buf = z.buf[:1]
|
||||
z.buf[0] = p[len(p)-1]
|
||||
z.c = 1
|
||||
return
|
||||
}
|
||||
// z.c is now 0, and len(p) <= cap(z.buf)
|
||||
var n1 int
|
||||
LOOP:
|
||||
// for len(p) > 0 && z.err == nil {
|
||||
z.buf = z.buf[0:cap(z.buf)]
|
||||
n1, err = z.r.Read(z.buf)
|
||||
n2 = uint(n1)
|
||||
if n2 == 0 && err != nil {
|
||||
isEOF = readbFillHandleErr(err, must, eof)
|
||||
return
|
||||
}
|
||||
err = nil
|
||||
z.buf = z.buf[:n2]
|
||||
z.c = 0
|
||||
if len(p) > 0 {
|
||||
n2 = uint(copy(p, z.buf))
|
||||
z.c = n2
|
||||
n += n2
|
||||
z.n += n2
|
||||
p = p[n2:]
|
||||
if len(p) > 0 {
|
||||
goto LOOP
|
||||
}
|
||||
if z.c == 0 {
|
||||
z.buf = z.buf[:1]
|
||||
z.buf[0] = p[len(p)-1]
|
||||
z.c = 1
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func (z *bufioDecReader) readn1() (b byte) {
|
||||
if z.c >= uint(len(z.buf)) {
|
||||
z.readbFill(nil, 0, true, false)
|
||||
}
|
||||
b = z.buf[z.c]
|
||||
z.c++
|
||||
z.n++
|
||||
return
|
||||
}
|
||||
|
||||
func (z *bufioDecReader) readn1eof() (b byte, eof bool) {
|
||||
if z.c >= uint(len(z.buf)) {
|
||||
eof, _ = z.readbFill(nil, 0, true, true)
|
||||
if eof {
|
||||
return
|
||||
}
|
||||
}
|
||||
b = z.buf[z.c]
|
||||
z.c++
|
||||
z.n++
|
||||
return
|
||||
}
|
||||
|
||||
func (z *bufioDecReader) unreadn1() {
|
||||
if z.c == 0 {
|
||||
halt.onerror(errDecUnreadByteNothingToRead)
|
||||
}
|
||||
z.c--
|
||||
z.n--
|
||||
}
|
||||
|
||||
func (z *bufioDecReader) readn2() (bs [2]byte) {
|
||||
z.readb(bs[:])
|
||||
return
|
||||
}
|
||||
|
||||
func (z *bufioDecReader) readn3() (bs [3]byte) {
|
||||
z.readb(bs[:])
|
||||
return
|
||||
}
|
||||
|
||||
func (z *bufioDecReader) readn4() (bs [4]byte) {
|
||||
z.readb(bs[:])
|
||||
return
|
||||
}
|
||||
|
||||
func (z *bufioDecReader) readn8() (bs [8]byte) {
|
||||
z.readb(bs[:])
|
||||
return
|
||||
}
|
||||
|
||||
func (z *bufioDecReader) readx(n uint) (bs []byte) {
|
||||
if n == 0 {
|
||||
// return
|
||||
} else if z.c+n <= uint(len(z.buf)) {
|
||||
bs = z.buf[z.c : z.c+n]
|
||||
z.n += n
|
||||
z.c += n
|
||||
} else {
|
||||
bs = make([]byte, n)
|
||||
// n no longer used - can reuse
|
||||
n = uint(copy(bs, z.buf[z.c:]))
|
||||
z.n += n
|
||||
z.c += n
|
||||
z.readbFill(bs, n, true, false)
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func (z *bufioDecReader) jsonReadNum() (bs []byte) {
|
||||
z.unreadn1()
|
||||
z.bufr = z.blist.check(z.bufr, 256)
|
||||
LOOP:
|
||||
i, eof := z.readn1eof()
|
||||
if eof {
|
||||
return z.bufr
|
||||
}
|
||||
if isNumberChar(i) {
|
||||
z.bufr = append(z.bufr, i)
|
||||
goto LOOP
|
||||
}
|
||||
z.unreadn1()
|
||||
return z.bufr
|
||||
}
|
||||
|
||||
func (z *bufioDecReader) jsonReadAsisChars() (bs []byte) {
|
||||
z.bufr = z.blist.check(z.bufr, 256)
|
||||
LOOP:
|
||||
i := z.readn1()
|
||||
z.bufr = append(z.bufr, i)
|
||||
if i == '"' || i == '\\' {
|
||||
return z.bufr
|
||||
}
|
||||
goto LOOP
|
||||
}
|
||||
|
||||
func (z *bufioDecReader) skipWhitespace() (token byte) {
|
||||
i := z.c
|
||||
LOOP:
|
||||
if i < uint(len(z.buf)) {
|
||||
// inline z.skipLoopFn(i) and refactor, so cost is within inline budget
|
||||
token = z.buf[i]
|
||||
i++
|
||||
if isWhitespaceChar(token) {
|
||||
goto LOOP
|
||||
}
|
||||
z.n += i - 2 - z.c
|
||||
z.c = i
|
||||
return
|
||||
}
|
||||
return z.skipFillWhitespace()
|
||||
}
|
||||
|
||||
func (z *bufioDecReader) skipFillWhitespace() (token byte) {
|
||||
z.n += uint(len(z.buf)) - z.c
|
||||
var i, n2 int
|
||||
var err error
|
||||
for {
|
||||
z.c = 0
|
||||
z.buf = z.buf[0:cap(z.buf)]
|
||||
n2, err = z.r.Read(z.buf)
|
||||
if n2 == 0 {
|
||||
halt.onerror(err)
|
||||
}
|
||||
z.buf = z.buf[:n2]
|
||||
for i, token = range z.buf {
|
||||
if !isWhitespaceChar(token) {
|
||||
z.n += (uint(i) - z.c) - 1
|
||||
z.loopFn(uint(i + 1))
|
||||
return
|
||||
}
|
||||
}
|
||||
z.n += uint(n2)
|
||||
}
|
||||
}
|
||||
|
||||
func (z *bufioDecReader) loopFn(i uint) {
|
||||
z.c = i
|
||||
}
|
||||
|
||||
func (z *bufioDecReader) readUntil(stop byte) (out []byte) {
|
||||
i := z.c
|
||||
LOOP:
|
||||
if i < uint(len(z.buf)) {
|
||||
if z.buf[i] == stop {
|
||||
z.n += (i - z.c) - 1
|
||||
i++
|
||||
out = z.buf[z.c:i]
|
||||
z.c = i
|
||||
goto FINISH
|
||||
}
|
||||
i++
|
||||
goto LOOP
|
||||
}
|
||||
out = z.readUntilFill(stop)
|
||||
FINISH:
|
||||
return out[:len(out)-1]
|
||||
}
|
||||
|
||||
func (z *bufioDecReader) readUntilFill(stop byte) []byte {
|
||||
z.bufr = z.blist.check(z.bufr, 256)
|
||||
z.n += uint(len(z.buf)) - z.c
|
||||
z.bufr = append(z.bufr, z.buf[z.c:]...)
|
||||
for {
|
||||
z.c = 0
|
||||
z.buf = z.buf[0:cap(z.buf)]
|
||||
n1, err := z.r.Read(z.buf)
|
||||
if n1 == 0 {
|
||||
halt.onerror(err)
|
||||
}
|
||||
n2 := uint(n1)
|
||||
z.buf = z.buf[:n2]
|
||||
for i, token := range z.buf {
|
||||
if token == stop {
|
||||
z.n += (uint(i) - z.c) - 1
|
||||
z.bufr = append(z.bufr, z.buf[z.c:i+1]...)
|
||||
z.loopFn(uint(i + 1))
|
||||
return z.bufr
|
||||
}
|
||||
}
|
||||
z.bufr = append(z.bufr, z.buf...)
|
||||
z.n += n2
|
||||
}
|
||||
}
|
||||
|
||||
// ------------------------------------
|
||||
|
||||
// bytesDecReader is a decReader that reads off a byte slice with zero copying
|
||||
//
|
||||
// Note: we do not try to convert index'ing out of bounds to an io.EOF.
|
||||
// instead, we let it bubble up to the exported Encode/Decode method
|
||||
// and recover it as an io.EOF.
|
||||
//
|
||||
// see panicValToErr(...) function in helper.go.
|
||||
type bytesDecReader struct {
|
||||
b []byte // data
|
||||
c uint // cursor
|
||||
}
|
||||
|
||||
func (z *bytesDecReader) reset(in []byte) {
|
||||
z.b = in[:len(in):len(in)] // reslicing must not go past capacity
|
||||
z.c = 0
|
||||
}
|
||||
|
||||
func (z *bytesDecReader) numread() uint {
|
||||
return z.c
|
||||
}
|
||||
|
||||
// Note: slicing from a non-constant start position is more expensive,
|
||||
// as more computation is required to decipher the pointer start position.
|
||||
// However, we do it only once, and it's better than reslicing both z.b and return value.
|
||||
|
||||
func (z *bytesDecReader) readx(n uint) (bs []byte) {
|
||||
x := z.c + n
|
||||
bs = z.b[z.c:x]
|
||||
z.c = x
|
||||
return
|
||||
}
|
||||
|
||||
func (z *bytesDecReader) readb(bs []byte) {
|
||||
copy(bs, z.readx(uint(len(bs))))
|
||||
}
|
||||
|
||||
func (z *bytesDecReader) readn1() (v uint8) {
|
||||
v = z.b[z.c]
|
||||
z.c++
|
||||
return
|
||||
}
|
||||
|
||||
// func (z *bytesDecReader) readn(num uint8) (bs [8]byte) {
|
||||
// x := z.c + uint(num)
|
||||
// copy(bs[:], z.b[z.c:x]) // slice z.b completely, so we get bounds error if past
|
||||
// z.c = x
|
||||
// return
|
||||
// }
|
||||
|
||||
func (z *bytesDecReader) readn2() (bs [2]byte) {
|
||||
x := z.c + 2
|
||||
copy(bs[:], z.b[z.c:x]) // slice z.b completely, so we get bounds error if past
|
||||
z.c = x
|
||||
return
|
||||
}
|
||||
|
||||
func (z *bytesDecReader) readn3() (bs [3]byte) {
|
||||
x := z.c + 3
|
||||
copy(bs[:], z.b[z.c:x]) // slice z.b completely, so we get bounds error if past
|
||||
z.c = x
|
||||
return
|
||||
}
|
||||
|
||||
func (z *bytesDecReader) readn4() (bs [4]byte) {
|
||||
x := z.c + 4
|
||||
copy(bs[:], z.b[z.c:x]) // slice z.b completely, so we get bounds error if past
|
||||
z.c = x
|
||||
return
|
||||
}
|
||||
|
||||
func (z *bytesDecReader) readn8() (bs [8]byte) {
|
||||
x := z.c + 8
|
||||
copy(bs[:], z.b[z.c:x]) // slice z.b completely, so we get bounds error if past
|
||||
z.c = x
|
||||
return
|
||||
}
|
||||
|
||||
func (z *bytesDecReader) jsonReadNum() (out []byte) {
|
||||
z.c--
|
||||
i := z.c
|
||||
LOOP:
|
||||
if i < uint(len(z.b)) && isNumberChar(z.b[i]) {
|
||||
i++
|
||||
goto LOOP
|
||||
}
|
||||
out = z.b[z.c:i]
|
||||
z.c = i
|
||||
return
|
||||
}
|
||||
|
||||
func (z *bytesDecReader) jsonReadAsisChars() (out []byte) {
|
||||
i := z.c
|
||||
LOOP:
|
||||
token := z.b[i]
|
||||
i++
|
||||
if token == '"' || token == '\\' {
|
||||
out = z.b[z.c:i]
|
||||
z.c = i
|
||||
return // z.b[c:i]
|
||||
}
|
||||
goto LOOP
|
||||
}
|
||||
|
||||
func (z *bytesDecReader) skipWhitespace() (token byte) {
|
||||
i := z.c
|
||||
LOOP:
|
||||
if isWhitespaceChar(z.b[i]) {
|
||||
i++
|
||||
goto LOOP
|
||||
}
|
||||
z.c = i + 1
|
||||
return z.b[i]
|
||||
}
|
||||
|
||||
// func (z *bytesDecReader) skipWhitespace() (token byte) {
|
||||
// LOOP:
|
||||
// token = z.b[z.c]
|
||||
// z.c++
|
||||
// if isWhitespaceChar(token) {
|
||||
// goto LOOP
|
||||
// }
|
||||
// return
|
||||
// }
|
||||
|
||||
func (z *bytesDecReader) readUntil(stop byte) (out []byte) {
|
||||
i := z.c
|
||||
LOOP:
|
||||
if z.b[i] == stop {
|
||||
i++
|
||||
out = z.b[z.c : i-1]
|
||||
z.c = i
|
||||
return
|
||||
}
|
||||
i++
|
||||
goto LOOP
|
||||
}
|
||||
|
||||
// --------------
|
||||
|
||||
type decRd struct {
|
||||
mtr bool // is maptype a known type?
|
||||
str bool // is slicetype a known type?
|
||||
|
||||
be bool // is binary encoding
|
||||
js bool // is json handle
|
||||
jsms bool // is json handle, and MapKeyAsString
|
||||
cbor bool // is cbor handle
|
||||
|
||||
bytes bool // is bytes reader
|
||||
bufio bool // is this a bufioDecReader?
|
||||
|
||||
rb bytesDecReader
|
||||
ri *ioDecReader
|
||||
bi *bufioDecReader
|
||||
|
||||
decReader
|
||||
}
|
||||
|
||||
// From out benchmarking, we see the following in terms of performance:
|
||||
//
|
||||
// - interface calls
|
||||
// - branch that can inline what it calls
|
||||
//
|
||||
// the if/else-if/else block is expensive to inline.
|
||||
// Each node of this construct costs a lot and dominates the budget.
|
||||
// Best to only do an if fast-path else block (so fast-path is inlined).
|
||||
// This is irrespective of inlineExtraCallCost set in $GOROOT/src/cmd/compile/internal/gc/inl.go
|
||||
//
|
||||
// In decRd methods below, we delegate all IO functions into their own methods.
|
||||
// This allows for the inlining of the common path when z.bytes=true.
|
||||
// Go 1.12+ supports inlining methods with up to 1 inlined function (or 2 if no other constructs).
|
||||
//
|
||||
// However, up through Go 1.13, decRd's readXXX, skip and unreadXXX methods are not inlined.
|
||||
// Consequently, there is no benefit to do the xxxIO methods for decRd at this time.
|
||||
// Instead, we have a if/else-if/else block so that IO calls do not have to jump through
|
||||
// a second unnecessary function call.
|
||||
//
|
||||
// If golang inlining gets better and bytesDecReader methods can be inlined,
|
||||
// then we can revert to using these 2 functions so the bytesDecReader
|
||||
// methods are inlined and the IO paths call out to a function.
|
||||
//
|
||||
// decRd is designed to embed a decReader, and then re-implement some of the decReader
|
||||
// methods using a conditional branch. We only override the ones that have a bytes version
|
||||
// that is small enough to be inlined. We use ./run.sh -z to check.
|
||||
// Right now, only numread and readn1 can be inlined.
|
||||
|
||||
func (z *decRd) numread() uint {
|
||||
if z.bytes {
|
||||
return z.rb.numread()
|
||||
} else if z.bufio {
|
||||
return z.bi.numread()
|
||||
} else {
|
||||
return z.ri.numread()
|
||||
}
|
||||
}
|
||||
|
||||
func (z *decRd) readn1() (v uint8) {
|
||||
if z.bytes {
|
||||
// MARKER: manually inline, else this function is not inlined.
|
||||
// Keep in sync with bytesDecReader.readn1
|
||||
// return z.rb.readn1()
|
||||
v = z.rb.b[z.rb.c]
|
||||
z.rb.c++
|
||||
} else {
|
||||
v = z.readn1IO()
|
||||
}
|
||||
return
|
||||
}
|
||||
func (z *decRd) readn1IO() uint8 {
|
||||
if z.bufio {
|
||||
return z.bi.readn1()
|
||||
}
|
||||
return z.ri.readn1()
|
||||
}
|
||||
|
||||
type devNullReader struct{}
|
||||
|
||||
func (devNullReader) Read(p []byte) (int, error) { return 0, io.EOF }
|
||||
func (devNullReader) Close() error { return nil }
|
||||
|
||||
func readFull(r io.Reader, bs []byte) (n uint, err error) {
|
||||
var nn int
|
||||
for n < uint(len(bs)) && err == nil {
|
||||
nn, err = r.Read(bs[n:])
|
||||
if nn > 0 {
|
||||
if err == io.EOF {
|
||||
// leave EOF for next time
|
||||
err = nil
|
||||
}
|
||||
n += uint(nn)
|
||||
}
|
||||
}
|
||||
// do not do this below - it serves no purpose
|
||||
// if n != len(bs) && err == io.EOF { err = io.ErrUnexpectedEOF }
|
||||
return
|
||||
}
|
||||
|
||||
var _ decReader = (*decRd)(nil)
|
38
vendor/github.com/ugorji/go/codec/register_ext.go
generated
vendored
Normal file
38
vendor/github.com/ugorji/go/codec/register_ext.go
generated
vendored
Normal file
|
@ -0,0 +1,38 @@
|
|||
// Copyright (c) 2012-2020 Ugorji Nwoke. All rights reserved.
|
||||
// Use of this source code is governed by a MIT license found in the LICENSE file.
|
||||
|
||||
package codec
|
||||
|
||||
import "reflect"
|
||||
|
||||
// This file exists, so that the files for specific formats do not all import reflect.
|
||||
// This just helps us ensure that reflect package is isolated to a few files.
|
||||
|
||||
// SetInterfaceExt sets an extension
|
||||
func (h *JsonHandle) SetInterfaceExt(rt reflect.Type, tag uint64, ext InterfaceExt) (err error) {
|
||||
return h.SetExt(rt, tag, makeExt(ext))
|
||||
}
|
||||
|
||||
// SetInterfaceExt sets an extension
|
||||
func (h *CborHandle) SetInterfaceExt(rt reflect.Type, tag uint64, ext InterfaceExt) (err error) {
|
||||
return h.SetExt(rt, tag, makeExt(ext))
|
||||
}
|
||||
|
||||
// SetBytesExt sets an extension
|
||||
func (h *MsgpackHandle) SetBytesExt(rt reflect.Type, tag uint64, ext BytesExt) (err error) {
|
||||
return h.SetExt(rt, tag, makeExt(ext))
|
||||
}
|
||||
|
||||
// SetBytesExt sets an extension
|
||||
func (h *SimpleHandle) SetBytesExt(rt reflect.Type, tag uint64, ext BytesExt) (err error) {
|
||||
return h.SetExt(rt, tag, makeExt(ext))
|
||||
}
|
||||
|
||||
// SetBytesExt sets an extension
|
||||
func (h *BincHandle) SetBytesExt(rt reflect.Type, tag uint64, ext BytesExt) (err error) {
|
||||
return h.SetExt(rt, tag, makeExt(ext))
|
||||
}
|
||||
|
||||
// func (h *XMLHandle) SetInterfaceExt(rt reflect.Type, tag uint64, ext InterfaceExt) (err error) {
|
||||
// return h.SetExt(rt, tag, &interfaceExtWrapper{InterfaceExt: ext})
|
||||
// }
|
220
vendor/github.com/ugorji/go/codec/rpc.go
generated
vendored
Normal file
220
vendor/github.com/ugorji/go/codec/rpc.go
generated
vendored
Normal file
|
@ -0,0 +1,220 @@
|
|||
// Copyright (c) 2012-2020 Ugorji Nwoke. All rights reserved.
|
||||
// Use of this source code is governed by a MIT license found in the LICENSE file.
|
||||
|
||||
package codec
|
||||
|
||||
import (
|
||||
"bufio"
|
||||
"errors"
|
||||
"io"
|
||||
"net/rpc"
|
||||
)
|
||||
|
||||
var (
|
||||
errRpcJsonNeedsTermWhitespace = errors.New("rpc - requires JsonHandle with TermWhitespace=true")
|
||||
errRpcIsClosed = errors.New("rpc - connection has been closed")
|
||||
errRpcNoConn = errors.New("rpc - no connection")
|
||||
)
|
||||
|
||||
// Rpc provides a rpc Server or Client Codec for rpc communication.
|
||||
type Rpc interface {
|
||||
ServerCodec(conn io.ReadWriteCloser, h Handle) rpc.ServerCodec
|
||||
ClientCodec(conn io.ReadWriteCloser, h Handle) rpc.ClientCodec
|
||||
}
|
||||
|
||||
// RPCOptions holds options specific to rpc functionality
|
||||
type RPCOptions struct {
|
||||
// RPCNoBuffer configures whether we attempt to buffer reads and writes during RPC calls.
|
||||
//
|
||||
// Set RPCNoBuffer=true to turn buffering off.
|
||||
// Buffering can still be done if buffered connections are passed in, or
|
||||
// buffering is configured on the handle.
|
||||
RPCNoBuffer bool
|
||||
}
|
||||
|
||||
// rpcCodec defines the struct members and common methods.
|
||||
type rpcCodec struct {
|
||||
c io.Closer
|
||||
r io.Reader
|
||||
w io.Writer
|
||||
f ioFlusher
|
||||
|
||||
dec *Decoder
|
||||
enc *Encoder
|
||||
h Handle
|
||||
|
||||
cls atomicClsErr
|
||||
}
|
||||
|
||||
func newRPCCodec(conn io.ReadWriteCloser, h Handle) rpcCodec {
|
||||
return newRPCCodec2(conn, conn, conn, h)
|
||||
}
|
||||
|
||||
func newRPCCodec2(r io.Reader, w io.Writer, c io.Closer, h Handle) rpcCodec {
|
||||
// defensive: ensure that jsonH has TermWhitespace turned on.
|
||||
jsonH, ok := h.(*JsonHandle)
|
||||
if ok && !jsonH.TermWhitespace {
|
||||
halt.onerror(errRpcJsonNeedsTermWhitespace)
|
||||
}
|
||||
var f ioFlusher
|
||||
bh := h.getBasicHandle()
|
||||
if !bh.RPCNoBuffer {
|
||||
f, ok = w.(ioFlusher)
|
||||
if bh.WriterBufferSize <= 0 {
|
||||
if !ok {
|
||||
bw := bufio.NewWriter(w)
|
||||
f, w = bw, bw
|
||||
}
|
||||
}
|
||||
if bh.ReaderBufferSize <= 0 {
|
||||
if _, ok = w.(ioBuffered); !ok {
|
||||
r = bufio.NewReader(r)
|
||||
}
|
||||
}
|
||||
}
|
||||
return rpcCodec{
|
||||
c: c,
|
||||
w: w,
|
||||
r: r,
|
||||
f: f,
|
||||
h: h,
|
||||
enc: NewEncoder(w, h),
|
||||
dec: NewDecoder(r, h),
|
||||
}
|
||||
}
|
||||
|
||||
func (c *rpcCodec) write(obj1, obj2 interface{}, writeObj2 bool) (err error) {
|
||||
err = c.ready()
|
||||
if err == nil {
|
||||
err = c.enc.Encode(obj1)
|
||||
if err == nil && writeObj2 {
|
||||
err = c.enc.Encode(obj2)
|
||||
}
|
||||
if c.f != nil {
|
||||
flushErr := c.f.Flush()
|
||||
if err == nil {
|
||||
// ignore flush error if prior error occurred during Encode
|
||||
err = flushErr
|
||||
}
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func (c *rpcCodec) read(obj interface{}) (err error) {
|
||||
err = c.ready()
|
||||
if err == nil {
|
||||
//If nil is passed in, we should read and discard
|
||||
if obj == nil {
|
||||
// return c.dec.Decode(&obj)
|
||||
err = c.dec.swallowErr()
|
||||
} else {
|
||||
err = c.dec.Decode(obj)
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func (c *rpcCodec) Close() (err error) {
|
||||
if c.c != nil {
|
||||
cls := c.cls.load()
|
||||
if !cls.closed {
|
||||
cls.err = c.c.Close()
|
||||
cls.closed = true
|
||||
c.cls.store(cls)
|
||||
}
|
||||
err = cls.err
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func (c *rpcCodec) ready() (err error) {
|
||||
if c.c == nil {
|
||||
err = errRpcNoConn
|
||||
} else {
|
||||
cls := c.cls.load()
|
||||
if cls.closed {
|
||||
if err = cls.err; err == nil {
|
||||
err = errRpcIsClosed
|
||||
}
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func (c *rpcCodec) ReadResponseBody(body interface{}) error {
|
||||
return c.read(body)
|
||||
}
|
||||
|
||||
// -------------------------------------
|
||||
|
||||
type goRpcCodec struct {
|
||||
rpcCodec
|
||||
}
|
||||
|
||||
func (c *goRpcCodec) WriteRequest(r *rpc.Request, body interface{}) error {
|
||||
return c.write(r, body, true)
|
||||
}
|
||||
|
||||
func (c *goRpcCodec) WriteResponse(r *rpc.Response, body interface{}) error {
|
||||
return c.write(r, body, true)
|
||||
}
|
||||
|
||||
func (c *goRpcCodec) ReadResponseHeader(r *rpc.Response) error {
|
||||
return c.read(r)
|
||||
}
|
||||
|
||||
func (c *goRpcCodec) ReadRequestHeader(r *rpc.Request) error {
|
||||
return c.read(r)
|
||||
}
|
||||
|
||||
func (c *goRpcCodec) ReadRequestBody(body interface{}) error {
|
||||
return c.read(body)
|
||||
}
|
||||
|
||||
// -------------------------------------
|
||||
|
||||
// goRpc is the implementation of Rpc that uses the communication protocol
|
||||
// as defined in net/rpc package.
|
||||
type goRpc struct{}
|
||||
|
||||
// GoRpc implements Rpc using the communication protocol defined in net/rpc package.
|
||||
//
|
||||
// Note: network connection (from net.Dial, of type io.ReadWriteCloser) is not buffered.
|
||||
//
|
||||
// For performance, you should configure WriterBufferSize and ReaderBufferSize on the handle.
|
||||
// This ensures we use an adequate buffer during reading and writing.
|
||||
// If not configured, we will internally initialize and use a buffer during reads and writes.
|
||||
// This can be turned off via the RPCNoBuffer option on the Handle.
|
||||
// var handle codec.JsonHandle
|
||||
// handle.RPCNoBuffer = true // turns off attempt by rpc module to initialize a buffer
|
||||
//
|
||||
// Example 1: one way of configuring buffering explicitly:
|
||||
// var handle codec.JsonHandle // codec handle
|
||||
// handle.ReaderBufferSize = 1024
|
||||
// handle.WriterBufferSize = 1024
|
||||
// var conn io.ReadWriteCloser // connection got from a socket
|
||||
// var serverCodec = GoRpc.ServerCodec(conn, handle)
|
||||
// var clientCodec = GoRpc.ClientCodec(conn, handle)
|
||||
//
|
||||
// Example 2: you can also explicitly create a buffered connection yourself,
|
||||
// and not worry about configuring the buffer sizes in the Handle.
|
||||
// var handle codec.Handle // codec handle
|
||||
// var conn io.ReadWriteCloser // connection got from a socket
|
||||
// var bufconn = struct { // bufconn here is a buffered io.ReadWriteCloser
|
||||
// io.Closer
|
||||
// *bufio.Reader
|
||||
// *bufio.Writer
|
||||
// }{conn, bufio.NewReader(conn), bufio.NewWriter(conn)}
|
||||
// var serverCodec = GoRpc.ServerCodec(bufconn, handle)
|
||||
// var clientCodec = GoRpc.ClientCodec(bufconn, handle)
|
||||
//
|
||||
var GoRpc goRpc
|
||||
|
||||
func (x goRpc) ServerCodec(conn io.ReadWriteCloser, h Handle) rpc.ServerCodec {
|
||||
return &goRpcCodec{newRPCCodec(conn, h)}
|
||||
}
|
||||
|
||||
func (x goRpc) ClientCodec(conn io.ReadWriteCloser, h Handle) rpc.ClientCodec {
|
||||
return &goRpcCodec{newRPCCodec(conn, h)}
|
||||
}
|
737
vendor/github.com/ugorji/go/codec/simple.go
generated
vendored
Normal file
737
vendor/github.com/ugorji/go/codec/simple.go
generated
vendored
Normal file
|
@ -0,0 +1,737 @@
|
|||
// Copyright (c) 2012-2020 Ugorji Nwoke. All rights reserved.
|
||||
// Use of this source code is governed by a MIT license found in the LICENSE file.
|
||||
|
||||
package codec
|
||||
|
||||
import (
|
||||
"math"
|
||||
"time"
|
||||
)
|
||||
|
||||
const (
|
||||
_ uint8 = iota
|
||||
simpleVdNil = 1
|
||||
simpleVdFalse = 2
|
||||
simpleVdTrue = 3
|
||||
simpleVdFloat32 = 4
|
||||
simpleVdFloat64 = 5
|
||||
|
||||
// each lasts for 4 (ie n, n+1, n+2, n+3)
|
||||
simpleVdPosInt = 8
|
||||
simpleVdNegInt = 12
|
||||
|
||||
simpleVdTime = 24
|
||||
|
||||
// containers: each lasts for 4 (ie n, n+1, n+2, ... n+7)
|
||||
simpleVdString = 216
|
||||
simpleVdByteArray = 224
|
||||
simpleVdArray = 232
|
||||
simpleVdMap = 240
|
||||
simpleVdExt = 248
|
||||
)
|
||||
|
||||
var simpledescNames = map[byte]string{
|
||||
simpleVdNil: "null",
|
||||
simpleVdFalse: "false",
|
||||
simpleVdTrue: "true",
|
||||
simpleVdFloat32: "float32",
|
||||
simpleVdFloat64: "float64",
|
||||
|
||||
simpleVdPosInt: "+int",
|
||||
simpleVdNegInt: "-int",
|
||||
|
||||
simpleVdTime: "time",
|
||||
|
||||
simpleVdString: "string",
|
||||
simpleVdByteArray: "binary",
|
||||
simpleVdArray: "array",
|
||||
simpleVdMap: "map",
|
||||
simpleVdExt: "ext",
|
||||
}
|
||||
|
||||
func simpledesc(bd byte) (s string) {
|
||||
s = simpledescNames[bd]
|
||||
if s == "" {
|
||||
s = "unknown"
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
type simpleEncDriver struct {
|
||||
noBuiltInTypes
|
||||
encDriverNoopContainerWriter
|
||||
h *SimpleHandle
|
||||
// b [8]byte
|
||||
e Encoder
|
||||
}
|
||||
|
||||
func (e *simpleEncDriver) encoder() *Encoder {
|
||||
return &e.e
|
||||
}
|
||||
|
||||
func (e *simpleEncDriver) EncodeNil() {
|
||||
e.e.encWr.writen1(simpleVdNil)
|
||||
}
|
||||
|
||||
func (e *simpleEncDriver) EncodeBool(b bool) {
|
||||
if e.h.EncZeroValuesAsNil && e.e.c != containerMapKey && !b {
|
||||
e.EncodeNil()
|
||||
return
|
||||
}
|
||||
if b {
|
||||
e.e.encWr.writen1(simpleVdTrue)
|
||||
} else {
|
||||
e.e.encWr.writen1(simpleVdFalse)
|
||||
}
|
||||
}
|
||||
|
||||
func (e *simpleEncDriver) EncodeFloat32(f float32) {
|
||||
if e.h.EncZeroValuesAsNil && e.e.c != containerMapKey && f == 0.0 {
|
||||
e.EncodeNil()
|
||||
return
|
||||
}
|
||||
e.e.encWr.writen1(simpleVdFloat32)
|
||||
bigen.writeUint32(e.e.w(), math.Float32bits(f))
|
||||
}
|
||||
|
||||
func (e *simpleEncDriver) EncodeFloat64(f float64) {
|
||||
if e.h.EncZeroValuesAsNil && e.e.c != containerMapKey && f == 0.0 {
|
||||
e.EncodeNil()
|
||||
return
|
||||
}
|
||||
e.e.encWr.writen1(simpleVdFloat64)
|
||||
bigen.writeUint64(e.e.w(), math.Float64bits(f))
|
||||
}
|
||||
|
||||
func (e *simpleEncDriver) EncodeInt(v int64) {
|
||||
if v < 0 {
|
||||
e.encUint(uint64(-v), simpleVdNegInt)
|
||||
} else {
|
||||
e.encUint(uint64(v), simpleVdPosInt)
|
||||
}
|
||||
}
|
||||
|
||||
func (e *simpleEncDriver) EncodeUint(v uint64) {
|
||||
e.encUint(v, simpleVdPosInt)
|
||||
}
|
||||
|
||||
func (e *simpleEncDriver) encUint(v uint64, bd uint8) {
|
||||
if e.h.EncZeroValuesAsNil && e.e.c != containerMapKey && v == 0 {
|
||||
e.EncodeNil()
|
||||
return
|
||||
}
|
||||
if v <= math.MaxUint8 {
|
||||
e.e.encWr.writen2(bd, uint8(v))
|
||||
} else if v <= math.MaxUint16 {
|
||||
e.e.encWr.writen1(bd + 1)
|
||||
bigen.writeUint16(e.e.w(), uint16(v))
|
||||
} else if v <= math.MaxUint32 {
|
||||
e.e.encWr.writen1(bd + 2)
|
||||
bigen.writeUint32(e.e.w(), uint32(v))
|
||||
} else { // if v <= math.MaxUint64 {
|
||||
e.e.encWr.writen1(bd + 3)
|
||||
bigen.writeUint64(e.e.w(), v)
|
||||
}
|
||||
}
|
||||
|
||||
func (e *simpleEncDriver) encLen(bd byte, length int) {
|
||||
if length == 0 {
|
||||
e.e.encWr.writen1(bd)
|
||||
} else if length <= math.MaxUint8 {
|
||||
e.e.encWr.writen1(bd + 1)
|
||||
e.e.encWr.writen1(uint8(length))
|
||||
} else if length <= math.MaxUint16 {
|
||||
e.e.encWr.writen1(bd + 2)
|
||||
bigen.writeUint16(e.e.w(), uint16(length))
|
||||
} else if int64(length) <= math.MaxUint32 {
|
||||
e.e.encWr.writen1(bd + 3)
|
||||
bigen.writeUint32(e.e.w(), uint32(length))
|
||||
} else {
|
||||
e.e.encWr.writen1(bd + 4)
|
||||
bigen.writeUint64(e.e.w(), uint64(length))
|
||||
}
|
||||
}
|
||||
|
||||
func (e *simpleEncDriver) EncodeExt(v interface{}, xtag uint64, ext Ext) {
|
||||
var bs []byte
|
||||
if ext == SelfExt {
|
||||
bs = e.e.blist.get(1024)
|
||||
e.e.sideEncode(v, &bs)
|
||||
} else {
|
||||
bs = ext.WriteExt(v)
|
||||
}
|
||||
if bs == nil {
|
||||
e.EncodeNil()
|
||||
return
|
||||
}
|
||||
e.encodeExtPreamble(uint8(xtag), len(bs))
|
||||
e.e.encWr.writeb(bs)
|
||||
if ext == SelfExt {
|
||||
e.e.blist.put(bs)
|
||||
}
|
||||
}
|
||||
|
||||
func (e *simpleEncDriver) EncodeRawExt(re *RawExt) {
|
||||
e.encodeExtPreamble(uint8(re.Tag), len(re.Data))
|
||||
e.e.encWr.writeb(re.Data)
|
||||
}
|
||||
|
||||
func (e *simpleEncDriver) encodeExtPreamble(xtag byte, length int) {
|
||||
e.encLen(simpleVdExt, length)
|
||||
e.e.encWr.writen1(xtag)
|
||||
}
|
||||
|
||||
func (e *simpleEncDriver) WriteArrayStart(length int) {
|
||||
e.encLen(simpleVdArray, length)
|
||||
}
|
||||
|
||||
func (e *simpleEncDriver) WriteMapStart(length int) {
|
||||
e.encLen(simpleVdMap, length)
|
||||
}
|
||||
|
||||
func (e *simpleEncDriver) EncodeString(v string) {
|
||||
if e.h.EncZeroValuesAsNil && e.e.c != containerMapKey && v == "" {
|
||||
e.EncodeNil()
|
||||
return
|
||||
}
|
||||
if e.h.StringToRaw {
|
||||
e.encLen(simpleVdByteArray, len(v))
|
||||
} else {
|
||||
e.encLen(simpleVdString, len(v))
|
||||
}
|
||||
e.e.encWr.writestr(v)
|
||||
}
|
||||
|
||||
func (e *simpleEncDriver) EncodeStringBytesRaw(v []byte) {
|
||||
// if e.h.EncZeroValuesAsNil && e.c != containerMapKey && v == nil {
|
||||
if v == nil {
|
||||
e.EncodeNil()
|
||||
return
|
||||
}
|
||||
e.encLen(simpleVdByteArray, len(v))
|
||||
e.e.encWr.writeb(v)
|
||||
}
|
||||
|
||||
func (e *simpleEncDriver) EncodeTime(t time.Time) {
|
||||
// if e.h.EncZeroValuesAsNil && e.c != containerMapKey && t.IsZero() {
|
||||
if t.IsZero() {
|
||||
e.EncodeNil()
|
||||
return
|
||||
}
|
||||
v, err := t.MarshalBinary()
|
||||
e.e.onerror(err)
|
||||
e.e.encWr.writen2(simpleVdTime, uint8(len(v)))
|
||||
e.e.encWr.writeb(v)
|
||||
}
|
||||
|
||||
//------------------------------------
|
||||
|
||||
type simpleDecDriver struct {
|
||||
h *SimpleHandle
|
||||
bdRead bool
|
||||
bd byte
|
||||
_ bool
|
||||
noBuiltInTypes
|
||||
decDriverNoopContainerReader
|
||||
d Decoder
|
||||
}
|
||||
|
||||
func (d *simpleDecDriver) decoder() *Decoder {
|
||||
return &d.d
|
||||
}
|
||||
|
||||
func (d *simpleDecDriver) readNextBd() {
|
||||
d.bd = d.d.decRd.readn1()
|
||||
d.bdRead = true
|
||||
}
|
||||
|
||||
func (d *simpleDecDriver) advanceNil() (null bool) {
|
||||
if !d.bdRead {
|
||||
d.readNextBd()
|
||||
}
|
||||
if d.bd == simpleVdNil {
|
||||
d.bdRead = false
|
||||
return true // null = true
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func (d *simpleDecDriver) ContainerType() (vt valueType) {
|
||||
if !d.bdRead {
|
||||
d.readNextBd()
|
||||
}
|
||||
switch d.bd {
|
||||
case simpleVdNil:
|
||||
d.bdRead = false
|
||||
return valueTypeNil
|
||||
case simpleVdByteArray, simpleVdByteArray + 1,
|
||||
simpleVdByteArray + 2, simpleVdByteArray + 3, simpleVdByteArray + 4:
|
||||
return valueTypeBytes
|
||||
case simpleVdString, simpleVdString + 1,
|
||||
simpleVdString + 2, simpleVdString + 3, simpleVdString + 4:
|
||||
return valueTypeString
|
||||
case simpleVdArray, simpleVdArray + 1,
|
||||
simpleVdArray + 2, simpleVdArray + 3, simpleVdArray + 4:
|
||||
return valueTypeArray
|
||||
case simpleVdMap, simpleVdMap + 1,
|
||||
simpleVdMap + 2, simpleVdMap + 3, simpleVdMap + 4:
|
||||
return valueTypeMap
|
||||
}
|
||||
return valueTypeUnset
|
||||
}
|
||||
|
||||
func (d *simpleDecDriver) TryNil() bool {
|
||||
return d.advanceNil()
|
||||
}
|
||||
|
||||
func (d *simpleDecDriver) decCheckInteger() (ui uint64, neg bool) {
|
||||
switch d.bd {
|
||||
case simpleVdPosInt:
|
||||
ui = uint64(d.d.decRd.readn1())
|
||||
case simpleVdPosInt + 1:
|
||||
ui = uint64(bigen.Uint16(d.d.decRd.readn2()))
|
||||
case simpleVdPosInt + 2:
|
||||
ui = uint64(bigen.Uint32(d.d.decRd.readn4()))
|
||||
case simpleVdPosInt + 3:
|
||||
ui = uint64(bigen.Uint64(d.d.decRd.readn8()))
|
||||
case simpleVdNegInt:
|
||||
ui = uint64(d.d.decRd.readn1())
|
||||
neg = true
|
||||
case simpleVdNegInt + 1:
|
||||
ui = uint64(bigen.Uint16(d.d.decRd.readn2()))
|
||||
neg = true
|
||||
case simpleVdNegInt + 2:
|
||||
ui = uint64(bigen.Uint32(d.d.decRd.readn4()))
|
||||
neg = true
|
||||
case simpleVdNegInt + 3:
|
||||
ui = uint64(bigen.Uint64(d.d.decRd.readn8()))
|
||||
neg = true
|
||||
default:
|
||||
d.d.errorf("integer only valid from pos/neg integer1..8. Invalid descriptor: %v", d.bd)
|
||||
}
|
||||
// DO NOT do this check below, because callers may only want the unsigned value:
|
||||
//
|
||||
// if ui > math.MaxInt64 {
|
||||
// d.d.errorf("decIntAny: Integer out of range for signed int64: %v", ui)
|
||||
// return
|
||||
// }
|
||||
return
|
||||
}
|
||||
|
||||
func (d *simpleDecDriver) DecodeInt64() (i int64) {
|
||||
if d.advanceNil() {
|
||||
return
|
||||
}
|
||||
ui, neg := d.decCheckInteger()
|
||||
i = chkOvf.SignedIntV(ui)
|
||||
if neg {
|
||||
i = -i
|
||||
}
|
||||
d.bdRead = false
|
||||
return
|
||||
}
|
||||
|
||||
func (d *simpleDecDriver) DecodeUint64() (ui uint64) {
|
||||
if d.advanceNil() {
|
||||
return
|
||||
}
|
||||
ui, neg := d.decCheckInteger()
|
||||
if neg {
|
||||
d.d.errorf("assigning negative signed value to unsigned type")
|
||||
}
|
||||
d.bdRead = false
|
||||
return
|
||||
}
|
||||
|
||||
func (d *simpleDecDriver) DecodeFloat64() (f float64) {
|
||||
if d.advanceNil() {
|
||||
return
|
||||
}
|
||||
if d.bd == simpleVdFloat32 {
|
||||
f = float64(math.Float32frombits(bigen.Uint32(d.d.decRd.readn4())))
|
||||
} else if d.bd == simpleVdFloat64 {
|
||||
f = math.Float64frombits(bigen.Uint64(d.d.decRd.readn8()))
|
||||
} else {
|
||||
if d.bd >= simpleVdPosInt && d.bd <= simpleVdNegInt+3 {
|
||||
f = float64(d.DecodeInt64())
|
||||
} else {
|
||||
d.d.errorf("float only valid from float32/64: Invalid descriptor: %v", d.bd)
|
||||
}
|
||||
}
|
||||
d.bdRead = false
|
||||
return
|
||||
}
|
||||
|
||||
// bool can be decoded from bool only (single byte).
|
||||
func (d *simpleDecDriver) DecodeBool() (b bool) {
|
||||
if d.advanceNil() {
|
||||
return
|
||||
}
|
||||
if d.bd == simpleVdFalse {
|
||||
} else if d.bd == simpleVdTrue {
|
||||
b = true
|
||||
} else {
|
||||
d.d.errorf("cannot decode bool - %s: %x", msgBadDesc, d.bd)
|
||||
}
|
||||
d.bdRead = false
|
||||
return
|
||||
}
|
||||
|
||||
func (d *simpleDecDriver) ReadMapStart() (length int) {
|
||||
if d.advanceNil() {
|
||||
return containerLenNil
|
||||
}
|
||||
d.bdRead = false
|
||||
return d.decLen()
|
||||
}
|
||||
|
||||
func (d *simpleDecDriver) ReadArrayStart() (length int) {
|
||||
if d.advanceNil() {
|
||||
return containerLenNil
|
||||
}
|
||||
d.bdRead = false
|
||||
return d.decLen()
|
||||
}
|
||||
|
||||
func (d *simpleDecDriver) uint2Len(ui uint64) int {
|
||||
if chkOvf.Uint(ui, intBitsize) {
|
||||
d.d.errorf("overflow integer: %v", ui)
|
||||
}
|
||||
return int(ui)
|
||||
}
|
||||
|
||||
func (d *simpleDecDriver) decLen() int {
|
||||
switch d.bd & 7 { // d.bd % 8 {
|
||||
case 0:
|
||||
return 0
|
||||
case 1:
|
||||
return int(d.d.decRd.readn1())
|
||||
case 2:
|
||||
return int(bigen.Uint16(d.d.decRd.readn2()))
|
||||
case 3:
|
||||
return d.uint2Len(uint64(bigen.Uint32(d.d.decRd.readn4())))
|
||||
case 4:
|
||||
return d.uint2Len(bigen.Uint64(d.d.decRd.readn8()))
|
||||
}
|
||||
d.d.errorf("cannot read length: bd%%8 must be in range 0..4. Got: %d", d.bd%8)
|
||||
return -1
|
||||
}
|
||||
|
||||
func (d *simpleDecDriver) DecodeStringAsBytes() (s []byte) {
|
||||
return d.DecodeBytes(nil)
|
||||
}
|
||||
|
||||
func (d *simpleDecDriver) DecodeBytes(bs []byte) (bsOut []byte) {
|
||||
d.d.decByteState = decByteStateNone
|
||||
if d.advanceNil() {
|
||||
return
|
||||
}
|
||||
// check if an "array" of uint8's (see ContainerType for how to infer if an array)
|
||||
if d.bd >= simpleVdArray && d.bd <= simpleVdMap+4 {
|
||||
if bs == nil {
|
||||
d.d.decByteState = decByteStateReuseBuf
|
||||
bs = d.d.b[:]
|
||||
}
|
||||
slen := d.ReadArrayStart()
|
||||
var changed bool
|
||||
if bs, changed = usableByteSlice(bs, slen); changed {
|
||||
d.d.decByteState = decByteStateNone
|
||||
}
|
||||
for i := 0; i < len(bs); i++ {
|
||||
bs[i] = uint8(chkOvf.UintV(d.DecodeUint64(), 8))
|
||||
}
|
||||
return bs
|
||||
}
|
||||
|
||||
clen := d.decLen()
|
||||
d.bdRead = false
|
||||
if d.d.zerocopy() {
|
||||
d.d.decByteState = decByteStateZerocopy
|
||||
return d.d.decRd.rb.readx(uint(clen))
|
||||
}
|
||||
if bs == nil {
|
||||
d.d.decByteState = decByteStateReuseBuf
|
||||
bs = d.d.b[:]
|
||||
}
|
||||
return decByteSlice(d.d.r(), clen, d.d.h.MaxInitLen, bs)
|
||||
}
|
||||
|
||||
func (d *simpleDecDriver) DecodeTime() (t time.Time) {
|
||||
if d.advanceNil() {
|
||||
return
|
||||
}
|
||||
if d.bd != simpleVdTime {
|
||||
d.d.errorf("invalid descriptor for time.Time - expect 0x%x, received 0x%x", simpleVdTime, d.bd)
|
||||
}
|
||||
d.bdRead = false
|
||||
clen := uint(d.d.decRd.readn1())
|
||||
b := d.d.decRd.readx(clen)
|
||||
d.d.onerror((&t).UnmarshalBinary(b))
|
||||
return
|
||||
}
|
||||
|
||||
func (d *simpleDecDriver) DecodeExt(rv interface{}, xtag uint64, ext Ext) {
|
||||
if xtag > 0xff {
|
||||
d.d.errorf("ext: tag must be <= 0xff; got: %v", xtag)
|
||||
}
|
||||
if d.advanceNil() {
|
||||
return
|
||||
}
|
||||
xbs, realxtag1, zerocopy := d.decodeExtV(ext != nil, uint8(xtag))
|
||||
realxtag := uint64(realxtag1)
|
||||
if ext == nil {
|
||||
re := rv.(*RawExt)
|
||||
re.Tag = realxtag
|
||||
re.setData(xbs, zerocopy)
|
||||
} else if ext == SelfExt {
|
||||
d.d.sideDecode(rv, xbs)
|
||||
} else {
|
||||
ext.ReadExt(rv, xbs)
|
||||
}
|
||||
}
|
||||
|
||||
func (d *simpleDecDriver) decodeExtV(verifyTag bool, tag byte) (xbs []byte, xtag byte, zerocopy bool) {
|
||||
switch d.bd {
|
||||
case simpleVdExt, simpleVdExt + 1, simpleVdExt + 2, simpleVdExt + 3, simpleVdExt + 4:
|
||||
l := d.decLen()
|
||||
xtag = d.d.decRd.readn1()
|
||||
if verifyTag && xtag != tag {
|
||||
d.d.errorf("wrong extension tag. Got %b. Expecting: %v", xtag, tag)
|
||||
}
|
||||
if d.d.bytes {
|
||||
xbs = d.d.decRd.rb.readx(uint(l))
|
||||
zerocopy = true
|
||||
} else {
|
||||
xbs = decByteSlice(d.d.r(), l, d.d.h.MaxInitLen, d.d.b[:])
|
||||
}
|
||||
case simpleVdByteArray, simpleVdByteArray + 1,
|
||||
simpleVdByteArray + 2, simpleVdByteArray + 3, simpleVdByteArray + 4:
|
||||
xbs = d.DecodeBytes(nil)
|
||||
default:
|
||||
d.d.errorf("ext - %s - expecting extensions/bytearray, got: 0x%x", msgBadDesc, d.bd)
|
||||
}
|
||||
d.bdRead = false
|
||||
return
|
||||
}
|
||||
|
||||
func (d *simpleDecDriver) DecodeNaked() {
|
||||
if !d.bdRead {
|
||||
d.readNextBd()
|
||||
}
|
||||
|
||||
n := d.d.naked()
|
||||
var decodeFurther bool
|
||||
|
||||
switch d.bd {
|
||||
case simpleVdNil:
|
||||
n.v = valueTypeNil
|
||||
case simpleVdFalse:
|
||||
n.v = valueTypeBool
|
||||
n.b = false
|
||||
case simpleVdTrue:
|
||||
n.v = valueTypeBool
|
||||
n.b = true
|
||||
case simpleVdPosInt, simpleVdPosInt + 1, simpleVdPosInt + 2, simpleVdPosInt + 3:
|
||||
if d.h.SignedInteger {
|
||||
n.v = valueTypeInt
|
||||
n.i = d.DecodeInt64()
|
||||
} else {
|
||||
n.v = valueTypeUint
|
||||
n.u = d.DecodeUint64()
|
||||
}
|
||||
case simpleVdNegInt, simpleVdNegInt + 1, simpleVdNegInt + 2, simpleVdNegInt + 3:
|
||||
n.v = valueTypeInt
|
||||
n.i = d.DecodeInt64()
|
||||
case simpleVdFloat32:
|
||||
n.v = valueTypeFloat
|
||||
n.f = d.DecodeFloat64()
|
||||
case simpleVdFloat64:
|
||||
n.v = valueTypeFloat
|
||||
n.f = d.DecodeFloat64()
|
||||
case simpleVdTime:
|
||||
n.v = valueTypeTime
|
||||
n.t = d.DecodeTime()
|
||||
case simpleVdString, simpleVdString + 1,
|
||||
simpleVdString + 2, simpleVdString + 3, simpleVdString + 4:
|
||||
n.v = valueTypeString
|
||||
n.s = d.d.stringZC(d.DecodeStringAsBytes())
|
||||
case simpleVdByteArray, simpleVdByteArray + 1,
|
||||
simpleVdByteArray + 2, simpleVdByteArray + 3, simpleVdByteArray + 4:
|
||||
d.d.fauxUnionReadRawBytes(false)
|
||||
case simpleVdExt, simpleVdExt + 1, simpleVdExt + 2, simpleVdExt + 3, simpleVdExt + 4:
|
||||
n.v = valueTypeExt
|
||||
l := d.decLen()
|
||||
n.u = uint64(d.d.decRd.readn1())
|
||||
if d.d.bytes {
|
||||
n.l = d.d.decRd.rb.readx(uint(l))
|
||||
} else {
|
||||
n.l = decByteSlice(d.d.r(), l, d.d.h.MaxInitLen, d.d.b[:])
|
||||
}
|
||||
case simpleVdArray, simpleVdArray + 1, simpleVdArray + 2,
|
||||
simpleVdArray + 3, simpleVdArray + 4:
|
||||
n.v = valueTypeArray
|
||||
decodeFurther = true
|
||||
case simpleVdMap, simpleVdMap + 1, simpleVdMap + 2, simpleVdMap + 3, simpleVdMap + 4:
|
||||
n.v = valueTypeMap
|
||||
decodeFurther = true
|
||||
default:
|
||||
d.d.errorf("cannot infer value - %s 0x%x", msgBadDesc, d.bd)
|
||||
}
|
||||
|
||||
if !decodeFurther {
|
||||
d.bdRead = false
|
||||
}
|
||||
}
|
||||
|
||||
func (d *simpleDecDriver) nextValueBytes(start []byte) (v []byte) {
|
||||
if !d.bdRead {
|
||||
d.readNextBd()
|
||||
}
|
||||
v = append(start, d.bd)
|
||||
v = d.nextValueBytesBdReadR(v)
|
||||
d.bdRead = false
|
||||
return
|
||||
}
|
||||
|
||||
func (d *simpleDecDriver) nextValueBytesR(v0 []byte) (v []byte) {
|
||||
d.readNextBd()
|
||||
v = append(v0, d.bd)
|
||||
return d.nextValueBytesBdReadR(v)
|
||||
}
|
||||
|
||||
func (d *simpleDecDriver) nextValueBytesBdReadR(v0 []byte) (v []byte) {
|
||||
v = v0
|
||||
c := d.bd
|
||||
|
||||
var length uint
|
||||
|
||||
switch c {
|
||||
case simpleVdNil, simpleVdFalse, simpleVdTrue, simpleVdString, simpleVdByteArray:
|
||||
// pass
|
||||
case simpleVdPosInt, simpleVdNegInt:
|
||||
v = append(v, d.d.decRd.readn1())
|
||||
case simpleVdPosInt + 1, simpleVdNegInt + 1:
|
||||
v = append(v, d.d.decRd.readx(2)...)
|
||||
case simpleVdPosInt + 2, simpleVdNegInt + 2, simpleVdFloat32:
|
||||
v = append(v, d.d.decRd.readx(4)...)
|
||||
case simpleVdPosInt + 3, simpleVdNegInt + 3, simpleVdFloat64:
|
||||
v = append(v, d.d.decRd.readx(8)...)
|
||||
case simpleVdTime:
|
||||
c = d.d.decRd.readn1()
|
||||
v = append(v, c)
|
||||
v = append(v, d.d.decRd.readx(uint(c))...)
|
||||
|
||||
default:
|
||||
switch c & 7 { // c % 8 {
|
||||
case 0:
|
||||
length = 0
|
||||
case 1:
|
||||
b := d.d.decRd.readn1()
|
||||
length = uint(b)
|
||||
v = append(v, b)
|
||||
case 2:
|
||||
x := d.d.decRd.readn2()
|
||||
length = uint(bigen.Uint16(x))
|
||||
v = append(v, x[:]...)
|
||||
case 3:
|
||||
x := d.d.decRd.readn4()
|
||||
length = uint(bigen.Uint32(x))
|
||||
v = append(v, x[:]...)
|
||||
case 4:
|
||||
x := d.d.decRd.readn8()
|
||||
length = uint(bigen.Uint64(x))
|
||||
v = append(v, x[:]...)
|
||||
}
|
||||
|
||||
bExt := c >= simpleVdExt && c <= simpleVdExt+7
|
||||
bStr := c >= simpleVdString && c <= simpleVdString+7
|
||||
bByteArray := c >= simpleVdByteArray && c <= simpleVdByteArray+7
|
||||
bArray := c >= simpleVdArray && c <= simpleVdArray+7
|
||||
bMap := c >= simpleVdMap && c <= simpleVdMap+7
|
||||
|
||||
if !(bExt || bStr || bByteArray || bArray || bMap) {
|
||||
d.d.errorf("cannot infer value - %s 0x%x", msgBadDesc, c)
|
||||
}
|
||||
|
||||
if bExt {
|
||||
v = append(v, d.d.decRd.readn1()) // tag
|
||||
}
|
||||
|
||||
if length == 0 {
|
||||
break
|
||||
}
|
||||
|
||||
if bArray {
|
||||
for i := uint(0); i < length; i++ {
|
||||
v = d.nextValueBytesR(v)
|
||||
}
|
||||
} else if bMap {
|
||||
for i := uint(0); i < length; i++ {
|
||||
v = d.nextValueBytesR(v)
|
||||
v = d.nextValueBytesR(v)
|
||||
}
|
||||
} else {
|
||||
v = append(v, d.d.decRd.readx(length)...)
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
//------------------------------------
|
||||
|
||||
// SimpleHandle is a Handle for a very simple encoding format.
|
||||
//
|
||||
// simple is a simplistic codec similar to binc, but not as compact.
|
||||
// - Encoding of a value is always preceded by the descriptor byte (bd)
|
||||
// - True, false, nil are encoded fully in 1 byte (the descriptor)
|
||||
// - Integers (intXXX, uintXXX) are encoded in 1, 2, 4 or 8 bytes (plus a descriptor byte).
|
||||
// There are positive (uintXXX and intXXX >= 0) and negative (intXXX < 0) integers.
|
||||
// - Floats are encoded in 4 or 8 bytes (plus a descriptor byte)
|
||||
// - Length of containers (strings, bytes, array, map, extensions)
|
||||
// are encoded in 0, 1, 2, 4 or 8 bytes.
|
||||
// Zero-length containers have no length encoded.
|
||||
// For others, the number of bytes is given by pow(2, bd%3)
|
||||
// - maps are encoded as [bd] [length] [[key][value]]...
|
||||
// - arrays are encoded as [bd] [length] [value]...
|
||||
// - extensions are encoded as [bd] [length] [tag] [byte]...
|
||||
// - strings/bytearrays are encoded as [bd] [length] [byte]...
|
||||
// - time.Time are encoded as [bd] [length] [byte]...
|
||||
//
|
||||
// The full spec will be published soon.
|
||||
type SimpleHandle struct {
|
||||
binaryEncodingType
|
||||
BasicHandle
|
||||
// EncZeroValuesAsNil says to encode zero values for numbers, bool, string, etc as nil
|
||||
EncZeroValuesAsNil bool
|
||||
}
|
||||
|
||||
// Name returns the name of the handle: simple
|
||||
func (h *SimpleHandle) Name() string { return "simple" }
|
||||
|
||||
func (h *SimpleHandle) desc(bd byte) string { return simpledesc(bd) }
|
||||
|
||||
func (h *SimpleHandle) newEncDriver() encDriver {
|
||||
var e = &simpleEncDriver{h: h}
|
||||
e.e.e = e
|
||||
e.e.init(h)
|
||||
e.reset()
|
||||
return e
|
||||
}
|
||||
|
||||
func (h *SimpleHandle) newDecDriver() decDriver {
|
||||
d := &simpleDecDriver{h: h}
|
||||
d.d.d = d
|
||||
d.d.init(h)
|
||||
d.reset()
|
||||
return d
|
||||
}
|
||||
|
||||
func (e *simpleEncDriver) reset() {
|
||||
}
|
||||
|
||||
func (d *simpleDecDriver) reset() {
|
||||
d.bd, d.bdRead = 0, false
|
||||
}
|
||||
|
||||
var _ decDriver = (*simpleDecDriver)(nil)
|
||||
var _ encDriver = (*simpleEncDriver)(nil)
|
148
vendor/github.com/ugorji/go/codec/sort-slice.generated.go
generated
vendored
Normal file
148
vendor/github.com/ugorji/go/codec/sort-slice.generated.go
generated
vendored
Normal file
|
@ -0,0 +1,148 @@
|
|||
// Copyright (c) 2012-2020 Ugorji Nwoke. All rights reserved.
|
||||
// Use of this source code is governed by a MIT license found in the LICENSE file.
|
||||
|
||||
// Code generated from sort-slice.go.tmpl - DO NOT EDIT.
|
||||
|
||||
package codec
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"reflect"
|
||||
"time"
|
||||
)
|
||||
|
||||
type stringSlice []string
|
||||
|
||||
func (p stringSlice) Len() int { return len(p) }
|
||||
func (p stringSlice) Swap(i, j int) { p[uint(i)], p[uint(j)] = p[uint(j)], p[uint(i)] }
|
||||
func (p stringSlice) Less(i, j int) bool {
|
||||
return p[uint(i)] < p[uint(j)]
|
||||
}
|
||||
|
||||
type uint8Slice []uint8
|
||||
|
||||
func (p uint8Slice) Len() int { return len(p) }
|
||||
func (p uint8Slice) Swap(i, j int) { p[uint(i)], p[uint(j)] = p[uint(j)], p[uint(i)] }
|
||||
func (p uint8Slice) Less(i, j int) bool {
|
||||
return p[uint(i)] < p[uint(j)]
|
||||
}
|
||||
|
||||
type uint64Slice []uint64
|
||||
|
||||
func (p uint64Slice) Len() int { return len(p) }
|
||||
func (p uint64Slice) Swap(i, j int) { p[uint(i)], p[uint(j)] = p[uint(j)], p[uint(i)] }
|
||||
func (p uint64Slice) Less(i, j int) bool {
|
||||
return p[uint(i)] < p[uint(j)]
|
||||
}
|
||||
|
||||
type intSlice []int
|
||||
|
||||
func (p intSlice) Len() int { return len(p) }
|
||||
func (p intSlice) Swap(i, j int) { p[uint(i)], p[uint(j)] = p[uint(j)], p[uint(i)] }
|
||||
func (p intSlice) Less(i, j int) bool {
|
||||
return p[uint(i)] < p[uint(j)]
|
||||
}
|
||||
|
||||
type int64Slice []int64
|
||||
|
||||
func (p int64Slice) Len() int { return len(p) }
|
||||
func (p int64Slice) Swap(i, j int) { p[uint(i)], p[uint(j)] = p[uint(j)], p[uint(i)] }
|
||||
func (p int64Slice) Less(i, j int) bool {
|
||||
return p[uint(i)] < p[uint(j)]
|
||||
}
|
||||
|
||||
type stringRv struct {
|
||||
v string
|
||||
r reflect.Value
|
||||
}
|
||||
type stringRvSlice []stringRv
|
||||
|
||||
func (p stringRvSlice) Len() int { return len(p) }
|
||||
func (p stringRvSlice) Swap(i, j int) { p[uint(i)], p[uint(j)] = p[uint(j)], p[uint(i)] }
|
||||
func (p stringRvSlice) Less(i, j int) bool {
|
||||
return p[uint(i)].v < p[uint(j)].v
|
||||
}
|
||||
|
||||
type float64Rv struct {
|
||||
v float64
|
||||
r reflect.Value
|
||||
}
|
||||
type float64RvSlice []float64Rv
|
||||
|
||||
func (p float64RvSlice) Len() int { return len(p) }
|
||||
func (p float64RvSlice) Swap(i, j int) { p[uint(i)], p[uint(j)] = p[uint(j)], p[uint(i)] }
|
||||
func (p float64RvSlice) Less(i, j int) bool {
|
||||
return p[uint(i)].v < p[uint(j)].v || isNaN64(p[uint(i)].v) && !isNaN64(p[uint(j)].v)
|
||||
}
|
||||
|
||||
type uint64Rv struct {
|
||||
v uint64
|
||||
r reflect.Value
|
||||
}
|
||||
type uint64RvSlice []uint64Rv
|
||||
|
||||
func (p uint64RvSlice) Len() int { return len(p) }
|
||||
func (p uint64RvSlice) Swap(i, j int) { p[uint(i)], p[uint(j)] = p[uint(j)], p[uint(i)] }
|
||||
func (p uint64RvSlice) Less(i, j int) bool {
|
||||
return p[uint(i)].v < p[uint(j)].v
|
||||
}
|
||||
|
||||
type int64Rv struct {
|
||||
v int64
|
||||
r reflect.Value
|
||||
}
|
||||
type int64RvSlice []int64Rv
|
||||
|
||||
func (p int64RvSlice) Len() int { return len(p) }
|
||||
func (p int64RvSlice) Swap(i, j int) { p[uint(i)], p[uint(j)] = p[uint(j)], p[uint(i)] }
|
||||
func (p int64RvSlice) Less(i, j int) bool {
|
||||
return p[uint(i)].v < p[uint(j)].v
|
||||
}
|
||||
|
||||
type boolRv struct {
|
||||
v bool
|
||||
r reflect.Value
|
||||
}
|
||||
type boolRvSlice []boolRv
|
||||
|
||||
func (p boolRvSlice) Len() int { return len(p) }
|
||||
func (p boolRvSlice) Swap(i, j int) { p[uint(i)], p[uint(j)] = p[uint(j)], p[uint(i)] }
|
||||
func (p boolRvSlice) Less(i, j int) bool {
|
||||
return !p[uint(i)].v && p[uint(j)].v
|
||||
}
|
||||
|
||||
type timeRv struct {
|
||||
v time.Time
|
||||
r reflect.Value
|
||||
}
|
||||
type timeRvSlice []timeRv
|
||||
|
||||
func (p timeRvSlice) Len() int { return len(p) }
|
||||
func (p timeRvSlice) Swap(i, j int) { p[uint(i)], p[uint(j)] = p[uint(j)], p[uint(i)] }
|
||||
func (p timeRvSlice) Less(i, j int) bool {
|
||||
return p[uint(i)].v.Before(p[uint(j)].v)
|
||||
}
|
||||
|
||||
type bytesRv struct {
|
||||
v []byte
|
||||
r reflect.Value
|
||||
}
|
||||
type bytesRvSlice []bytesRv
|
||||
|
||||
func (p bytesRvSlice) Len() int { return len(p) }
|
||||
func (p bytesRvSlice) Swap(i, j int) { p[uint(i)], p[uint(j)] = p[uint(j)], p[uint(i)] }
|
||||
func (p bytesRvSlice) Less(i, j int) bool {
|
||||
return bytes.Compare(p[uint(i)].v, p[uint(j)].v) == -1
|
||||
}
|
||||
|
||||
type bytesIntf struct {
|
||||
v []byte
|
||||
i interface{}
|
||||
}
|
||||
type bytesIntfSlice []bytesIntf
|
||||
|
||||
func (p bytesIntfSlice) Len() int { return len(p) }
|
||||
func (p bytesIntfSlice) Swap(i, j int) { p[uint(i)], p[uint(j)] = p[uint(j)], p[uint(i)] }
|
||||
func (p bytesIntfSlice) Less(i, j int) bool {
|
||||
return bytes.Compare(p[uint(i)].v, p[uint(j)].v) == -1
|
||||
}
|
66
vendor/github.com/ugorji/go/codec/sort-slice.go.tmpl
generated
vendored
Normal file
66
vendor/github.com/ugorji/go/codec/sort-slice.go.tmpl
generated
vendored
Normal file
|
@ -0,0 +1,66 @@
|
|||
// Copyright (c) 2012-2020 Ugorji Nwoke. All rights reserved.
|
||||
// Use of this source code is governed by a MIT license found in the LICENSE file.
|
||||
|
||||
// Code generated from sort-slice.go.tmpl - DO NOT EDIT.
|
||||
|
||||
{{/*
|
||||
xxxSlice
|
||||
xxxIntf
|
||||
xxxIntfSlice
|
||||
xxxRv
|
||||
xxxRvSlice
|
||||
|
||||
I'm now going to create them for
|
||||
- sortables
|
||||
- sortablesplus
|
||||
|
||||
With the parameters passed in sortables or sortablesplus,
|
||||
'time, 'bytes' are special, and correspond to time.Time and []byte respectively.
|
||||
*/}}
|
||||
|
||||
package codec
|
||||
|
||||
import "time"
|
||||
import "reflect"
|
||||
import "bytes"
|
||||
|
||||
{{/* func init() { _ = time.Unix } */}}
|
||||
|
||||
{{define "T"}}
|
||||
func (p {{ .Type }}) Len() int { return len(p) }
|
||||
func (p {{ .Type }}) Swap(i, j int) { p[uint(i)], p[uint(j)] = p[uint(j)], p[uint(i)] }
|
||||
func (p {{ .Type }}) Less(i, j int) bool {
|
||||
{{ if eq .Kind "bool" }} return !p[uint(i)]{{.V}} && p[uint(j)]{{.V}}
|
||||
{{ else if eq .Kind "float32" }} return p[uint(i)]{{.V}} < p[uint(j)]{{.V}} || isNaN32(p[uint(i)]{{.V}}) && !isNaN32(p[uint(j)]{{.V}})
|
||||
{{ else if eq .Kind "float64" }} return p[uint(i)]{{.V}} < p[uint(j)]{{.V}} || isNaN64(p[uint(i)]{{.V}}) && !isNaN64(p[uint(j)]{{.V}})
|
||||
{{ else if eq .Kind "time" }} return p[uint(i)]{{.V}}.Before(p[uint(j)]{{.V}})
|
||||
{{ else if eq .Kind "bytes" }} return bytes.Compare(p[uint(i)]{{.V}}, p[uint(j)]{{.V}}) == -1
|
||||
{{ else }} return p[uint(i)]{{.V}} < p[uint(j)]{{.V}}
|
||||
{{ end -}}
|
||||
}
|
||||
{{end}}
|
||||
|
||||
{{range $i, $v := sortables }}{{ $t := tshort $v }}
|
||||
type {{ $v }}Slice []{{ $t }}
|
||||
{{template "T" args "Kind" $v "Type" (print $v "Slice") "V" ""}}
|
||||
{{end}}
|
||||
|
||||
{{range $i, $v := sortablesplus }}{{ $t := tshort $v }}
|
||||
|
||||
type {{ $v }}Rv struct {
|
||||
v {{ $t }}
|
||||
r reflect.Value
|
||||
}
|
||||
type {{ $v }}RvSlice []{{ $v }}Rv
|
||||
{{template "T" args "Kind" $v "Type" (print $v "RvSlice") "V" ".v"}}
|
||||
|
||||
{{if eq $v "bytes" -}}
|
||||
type {{ $v }}Intf struct {
|
||||
v {{ $t }}
|
||||
i interface{}
|
||||
}
|
||||
type {{ $v }}IntfSlice []{{ $v }}Intf
|
||||
{{template "T" args "Kind" $v "Type" (print $v "IntfSlice") "V" ".v"}}
|
||||
{{end}}
|
||||
|
||||
{{end}}
|
639
vendor/github.com/ugorji/go/codec/test-cbor-goldens.json
generated
vendored
Normal file
639
vendor/github.com/ugorji/go/codec/test-cbor-goldens.json
generated
vendored
Normal file
|
@ -0,0 +1,639 @@
|
|||
[
|
||||
{
|
||||
"cbor": "AA==",
|
||||
"hex": "00",
|
||||
"roundtrip": true,
|
||||
"decoded": 0
|
||||
},
|
||||
{
|
||||
"cbor": "AQ==",
|
||||
"hex": "01",
|
||||
"roundtrip": true,
|
||||
"decoded": 1
|
||||
},
|
||||
{
|
||||
"cbor": "Cg==",
|
||||
"hex": "0a",
|
||||
"roundtrip": true,
|
||||
"decoded": 10
|
||||
},
|
||||
{
|
||||
"cbor": "Fw==",
|
||||
"hex": "17",
|
||||
"roundtrip": true,
|
||||
"decoded": 23
|
||||
},
|
||||
{
|
||||
"cbor": "GBg=",
|
||||
"hex": "1818",
|
||||
"roundtrip": true,
|
||||
"decoded": 24
|
||||
},
|
||||
{
|
||||
"cbor": "GBk=",
|
||||
"hex": "1819",
|
||||
"roundtrip": true,
|
||||
"decoded": 25
|
||||
},
|
||||
{
|
||||
"cbor": "GGQ=",
|
||||
"hex": "1864",
|
||||
"roundtrip": true,
|
||||
"decoded": 100
|
||||
},
|
||||
{
|
||||
"cbor": "GQPo",
|
||||
"hex": "1903e8",
|
||||
"roundtrip": true,
|
||||
"decoded": 1000
|
||||
},
|
||||
{
|
||||
"cbor": "GgAPQkA=",
|
||||
"hex": "1a000f4240",
|
||||
"roundtrip": true,
|
||||
"decoded": 1000000
|
||||
},
|
||||
{
|
||||
"cbor": "GwAAAOjUpRAA",
|
||||
"hex": "1b000000e8d4a51000",
|
||||
"roundtrip": true,
|
||||
"decoded": 1000000000000
|
||||
},
|
||||
{
|
||||
"cbor": "G///////////",
|
||||
"hex": "1bffffffffffffffff",
|
||||
"roundtrip": true,
|
||||
"decoded": 18446744073709551615
|
||||
},
|
||||
{
|
||||
"cbor": "wkkBAAAAAAAAAAA=",
|
||||
"hex": "c249010000000000000000",
|
||||
"roundtrip": true,
|
||||
"decoded": 18446744073709551616
|
||||
},
|
||||
{
|
||||
"cbor": "O///////////",
|
||||
"hex": "3bffffffffffffffff",
|
||||
"roundtrip": true,
|
||||
"decoded": -18446744073709551616,
|
||||
"skip": true
|
||||
},
|
||||
{
|
||||
"cbor": "w0kBAAAAAAAAAAA=",
|
||||
"hex": "c349010000000000000000",
|
||||
"roundtrip": true,
|
||||
"decoded": -18446744073709551617
|
||||
},
|
||||
{
|
||||
"cbor": "IA==",
|
||||
"hex": "20",
|
||||
"roundtrip": true,
|
||||
"decoded": -1
|
||||
},
|
||||
{
|
||||
"cbor": "KQ==",
|
||||
"hex": "29",
|
||||
"roundtrip": true,
|
||||
"decoded": -10
|
||||
},
|
||||
{
|
||||
"cbor": "OGM=",
|
||||
"hex": "3863",
|
||||
"roundtrip": true,
|
||||
"decoded": -100
|
||||
},
|
||||
{
|
||||
"cbor": "OQPn",
|
||||
"hex": "3903e7",
|
||||
"roundtrip": true,
|
||||
"decoded": -1000
|
||||
},
|
||||
{
|
||||
"cbor": "+QAA",
|
||||
"hex": "f90000",
|
||||
"roundtrip": true,
|
||||
"decoded": 0.0
|
||||
},
|
||||
{
|
||||
"cbor": "+YAA",
|
||||
"hex": "f98000",
|
||||
"roundtrip": true,
|
||||
"decoded": -0.0
|
||||
},
|
||||
{
|
||||
"cbor": "+TwA",
|
||||
"hex": "f93c00",
|
||||
"roundtrip": true,
|
||||
"decoded": 1.0
|
||||
},
|
||||
{
|
||||
"cbor": "+z/xmZmZmZma",
|
||||
"hex": "fb3ff199999999999a",
|
||||
"roundtrip": true,
|
||||
"decoded": 1.1
|
||||
},
|
||||
{
|
||||
"cbor": "+T4A",
|
||||
"hex": "f93e00",
|
||||
"roundtrip": true,
|
||||
"decoded": 1.5
|
||||
},
|
||||
{
|
||||
"cbor": "+Xv/",
|
||||
"hex": "f97bff",
|
||||
"roundtrip": true,
|
||||
"decoded": 65504.0
|
||||
},
|
||||
{
|
||||
"cbor": "+kfDUAA=",
|
||||
"hex": "fa47c35000",
|
||||
"roundtrip": true,
|
||||
"decoded": 100000.0
|
||||
},
|
||||
{
|
||||
"cbor": "+n9///8=",
|
||||
"hex": "fa7f7fffff",
|
||||
"roundtrip": true,
|
||||
"decoded": 3.4028234663852886e+38
|
||||
},
|
||||
{
|
||||
"cbor": "+3435DyIAHWc",
|
||||
"hex": "fb7e37e43c8800759c",
|
||||
"roundtrip": true,
|
||||
"decoded": 1.0e+300
|
||||
},
|
||||
{
|
||||
"cbor": "+QAB",
|
||||
"hex": "f90001",
|
||||
"roundtrip": true,
|
||||
"decoded": 5.960464477539063e-08
|
||||
},
|
||||
{
|
||||
"cbor": "+QQA",
|
||||
"hex": "f90400",
|
||||
"roundtrip": true,
|
||||
"decoded": 6.103515625e-05
|
||||
},
|
||||
{
|
||||
"cbor": "+cQA",
|
||||
"hex": "f9c400",
|
||||
"roundtrip": true,
|
||||
"decoded": -4.0
|
||||
},
|
||||
{
|
||||
"cbor": "+8AQZmZmZmZm",
|
||||
"hex": "fbc010666666666666",
|
||||
"roundtrip": true,
|
||||
"decoded": -4.1
|
||||
},
|
||||
{
|
||||
"cbor": "+XwA",
|
||||
"hex": "f97c00",
|
||||
"roundtrip": true,
|
||||
"diagnostic": "Infinity"
|
||||
},
|
||||
{
|
||||
"cbor": "+X4A",
|
||||
"hex": "f97e00",
|
||||
"roundtrip": true,
|
||||
"diagnostic": "NaN"
|
||||
},
|
||||
{
|
||||
"cbor": "+fwA",
|
||||
"hex": "f9fc00",
|
||||
"roundtrip": true,
|
||||
"diagnostic": "-Infinity"
|
||||
},
|
||||
{
|
||||
"cbor": "+n+AAAA=",
|
||||
"hex": "fa7f800000",
|
||||
"roundtrip": false,
|
||||
"diagnostic": "Infinity"
|
||||
},
|
||||
{
|
||||
"cbor": "+n/AAAA=",
|
||||
"hex": "fa7fc00000",
|
||||
"roundtrip": false,
|
||||
"diagnostic": "NaN"
|
||||
},
|
||||
{
|
||||
"cbor": "+v+AAAA=",
|
||||
"hex": "faff800000",
|
||||
"roundtrip": false,
|
||||
"diagnostic": "-Infinity"
|
||||
},
|
||||
{
|
||||
"cbor": "+3/wAAAAAAAA",
|
||||
"hex": "fb7ff0000000000000",
|
||||
"roundtrip": false,
|
||||
"diagnostic": "Infinity"
|
||||
},
|
||||
{
|
||||
"cbor": "+3/4AAAAAAAA",
|
||||
"hex": "fb7ff8000000000000",
|
||||
"roundtrip": false,
|
||||
"diagnostic": "NaN"
|
||||
},
|
||||
{
|
||||
"cbor": "+//wAAAAAAAA",
|
||||
"hex": "fbfff0000000000000",
|
||||
"roundtrip": false,
|
||||
"diagnostic": "-Infinity"
|
||||
},
|
||||
{
|
||||
"cbor": "9A==",
|
||||
"hex": "f4",
|
||||
"roundtrip": true,
|
||||
"decoded": false
|
||||
},
|
||||
{
|
||||
"cbor": "9Q==",
|
||||
"hex": "f5",
|
||||
"roundtrip": true,
|
||||
"decoded": true
|
||||
},
|
||||
{
|
||||
"cbor": "9g==",
|
||||
"hex": "f6",
|
||||
"roundtrip": true,
|
||||
"decoded": null
|
||||
},
|
||||
{
|
||||
"cbor": "9w==",
|
||||
"hex": "f7",
|
||||
"roundtrip": true,
|
||||
"diagnostic": "undefined"
|
||||
},
|
||||
{
|
||||
"cbor": "8A==",
|
||||
"hex": "f0",
|
||||
"roundtrip": true,
|
||||
"diagnostic": "simple(16)"
|
||||
},
|
||||
{
|
||||
"cbor": "+Bg=",
|
||||
"hex": "f818",
|
||||
"roundtrip": true,
|
||||
"diagnostic": "simple(24)"
|
||||
},
|
||||
{
|
||||
"cbor": "+P8=",
|
||||
"hex": "f8ff",
|
||||
"roundtrip": true,
|
||||
"diagnostic": "simple(255)"
|
||||
},
|
||||
{
|
||||
"cbor": "wHQyMDEzLTAzLTIxVDIwOjA0OjAwWg==",
|
||||
"hex": "c074323031332d30332d32315432303a30343a30305a",
|
||||
"roundtrip": true,
|
||||
"diagnostic": "0(\"2013-03-21T20:04:00Z\")"
|
||||
},
|
||||
{
|
||||
"cbor": "wRpRS2ew",
|
||||
"hex": "c11a514b67b0",
|
||||
"roundtrip": true,
|
||||
"diagnostic": "1(1363896240)"
|
||||
},
|
||||
{
|
||||
"cbor": "wftB1FLZ7CAAAA==",
|
||||
"hex": "c1fb41d452d9ec200000",
|
||||
"roundtrip": true,
|
||||
"diagnostic": "1(1363896240.5)"
|
||||
},
|
||||
{
|
||||
"cbor": "10QBAgME",
|
||||
"hex": "d74401020304",
|
||||
"roundtrip": true,
|
||||
"diagnostic": "23(h'01020304')"
|
||||
},
|
||||
{
|
||||
"cbor": "2BhFZElFVEY=",
|
||||
"hex": "d818456449455446",
|
||||
"roundtrip": true,
|
||||
"diagnostic": "24(h'6449455446')"
|
||||
},
|
||||
{
|
||||
"cbor": "2CB2aHR0cDovL3d3dy5leGFtcGxlLmNvbQ==",
|
||||
"hex": "d82076687474703a2f2f7777772e6578616d706c652e636f6d",
|
||||
"roundtrip": true,
|
||||
"diagnostic": "32(\"http://www.example.com\")"
|
||||
},
|
||||
{
|
||||
"cbor": "QA==",
|
||||
"hex": "40",
|
||||
"roundtrip": true,
|
||||
"diagnostic": "h''"
|
||||
},
|
||||
{
|
||||
"cbor": "RAECAwQ=",
|
||||
"hex": "4401020304",
|
||||
"roundtrip": true,
|
||||
"diagnostic": "h'01020304'"
|
||||
},
|
||||
{
|
||||
"cbor": "YA==",
|
||||
"hex": "60",
|
||||
"roundtrip": true,
|
||||
"decoded": ""
|
||||
},
|
||||
{
|
||||
"cbor": "YWE=",
|
||||
"hex": "6161",
|
||||
"roundtrip": true,
|
||||
"decoded": "a"
|
||||
},
|
||||
{
|
||||
"cbor": "ZElFVEY=",
|
||||
"hex": "6449455446",
|
||||
"roundtrip": true,
|
||||
"decoded": "IETF"
|
||||
},
|
||||
{
|
||||
"cbor": "YiJc",
|
||||
"hex": "62225c",
|
||||
"roundtrip": true,
|
||||
"decoded": "\"\\"
|
||||
},
|
||||
{
|
||||
"cbor": "YsO8",
|
||||
"hex": "62c3bc",
|
||||
"roundtrip": true,
|
||||
"decoded": "ü"
|
||||
},
|
||||
{
|
||||
"cbor": "Y+awtA==",
|
||||
"hex": "63e6b0b4",
|
||||
"roundtrip": true,
|
||||
"decoded": "水"
|
||||
},
|
||||
{
|
||||
"cbor": "ZPCQhZE=",
|
||||
"hex": "64f0908591",
|
||||
"roundtrip": true,
|
||||
"decoded": "𐅑"
|
||||
},
|
||||
{
|
||||
"cbor": "gA==",
|
||||
"hex": "80",
|
||||
"roundtrip": true,
|
||||
"decoded": [
|
||||
|
||||
]
|
||||
},
|
||||
{
|
||||
"cbor": "gwECAw==",
|
||||
"hex": "83010203",
|
||||
"roundtrip": true,
|
||||
"decoded": [
|
||||
1,
|
||||
2,
|
||||
3
|
||||
]
|
||||
},
|
||||
{
|
||||
"cbor": "gwGCAgOCBAU=",
|
||||
"hex": "8301820203820405",
|
||||
"roundtrip": true,
|
||||
"decoded": [
|
||||
1,
|
||||
[
|
||||
2,
|
||||
3
|
||||
],
|
||||
[
|
||||
4,
|
||||
5
|
||||
]
|
||||
]
|
||||
},
|
||||
{
|
||||
"cbor": "mBkBAgMEBQYHCAkKCwwNDg8QERITFBUWFxgYGBk=",
|
||||
"hex": "98190102030405060708090a0b0c0d0e0f101112131415161718181819",
|
||||
"roundtrip": true,
|
||||
"decoded": [
|
||||
1,
|
||||
2,
|
||||
3,
|
||||
4,
|
||||
5,
|
||||
6,
|
||||
7,
|
||||
8,
|
||||
9,
|
||||
10,
|
||||
11,
|
||||
12,
|
||||
13,
|
||||
14,
|
||||
15,
|
||||
16,
|
||||
17,
|
||||
18,
|
||||
19,
|
||||
20,
|
||||
21,
|
||||
22,
|
||||
23,
|
||||
24,
|
||||
25
|
||||
]
|
||||
},
|
||||
{
|
||||
"cbor": "oA==",
|
||||
"hex": "a0",
|
||||
"roundtrip": true,
|
||||
"decoded": {
|
||||
}
|
||||
},
|
||||
{
|
||||
"cbor": "ogECAwQ=",
|
||||
"hex": "a201020304",
|
||||
"roundtrip": true,
|
||||
"skip": true,
|
||||
"diagnostic": "{1: 2, 3: 4}"
|
||||
},
|
||||
{
|
||||
"cbor": "omFhAWFiggID",
|
||||
"hex": "a26161016162820203",
|
||||
"roundtrip": true,
|
||||
"decoded": {
|
||||
"a": 1,
|
||||
"b": [
|
||||
2,
|
||||
3
|
||||
]
|
||||
}
|
||||
},
|
||||
{
|
||||
"cbor": "gmFhoWFiYWM=",
|
||||
"hex": "826161a161626163",
|
||||
"roundtrip": true,
|
||||
"decoded": [
|
||||
"a",
|
||||
{
|
||||
"b": "c"
|
||||
}
|
||||
]
|
||||
},
|
||||
{
|
||||
"cbor": "pWFhYUFhYmFCYWNhQ2FkYURhZWFF",
|
||||
"hex": "a56161614161626142616361436164614461656145",
|
||||
"roundtrip": true,
|
||||
"decoded": {
|
||||
"a": "A",
|
||||
"b": "B",
|
||||
"c": "C",
|
||||
"d": "D",
|
||||
"e": "E"
|
||||
}
|
||||
},
|
||||
{
|
||||
"cbor": "X0IBAkMDBAX/",
|
||||
"hex": "5f42010243030405ff",
|
||||
"roundtrip": false,
|
||||
"skip": true,
|
||||
"diagnostic": "(_ h'0102', h'030405')"
|
||||
},
|
||||
{
|
||||
"cbor": "f2VzdHJlYWRtaW5n/w==",
|
||||
"hex": "7f657374726561646d696e67ff",
|
||||
"roundtrip": false,
|
||||
"decoded": "streaming"
|
||||
},
|
||||
{
|
||||
"cbor": "n/8=",
|
||||
"hex": "9fff",
|
||||
"roundtrip": false,
|
||||
"decoded": [
|
||||
|
||||
]
|
||||
},
|
||||
{
|
||||
"cbor": "nwGCAgOfBAX//w==",
|
||||
"hex": "9f018202039f0405ffff",
|
||||
"roundtrip": false,
|
||||
"decoded": [
|
||||
1,
|
||||
[
|
||||
2,
|
||||
3
|
||||
],
|
||||
[
|
||||
4,
|
||||
5
|
||||
]
|
||||
]
|
||||
},
|
||||
{
|
||||
"cbor": "nwGCAgOCBAX/",
|
||||
"hex": "9f01820203820405ff",
|
||||
"roundtrip": false,
|
||||
"decoded": [
|
||||
1,
|
||||
[
|
||||
2,
|
||||
3
|
||||
],
|
||||
[
|
||||
4,
|
||||
5
|
||||
]
|
||||
]
|
||||
},
|
||||
{
|
||||
"cbor": "gwGCAgOfBAX/",
|
||||
"hex": "83018202039f0405ff",
|
||||
"roundtrip": false,
|
||||
"decoded": [
|
||||
1,
|
||||
[
|
||||
2,
|
||||
3
|
||||
],
|
||||
[
|
||||
4,
|
||||
5
|
||||
]
|
||||
]
|
||||
},
|
||||
{
|
||||
"cbor": "gwGfAgP/ggQF",
|
||||
"hex": "83019f0203ff820405",
|
||||
"roundtrip": false,
|
||||
"decoded": [
|
||||
1,
|
||||
[
|
||||
2,
|
||||
3
|
||||
],
|
||||
[
|
||||
4,
|
||||
5
|
||||
]
|
||||
]
|
||||
},
|
||||
{
|
||||
"cbor": "nwECAwQFBgcICQoLDA0ODxAREhMUFRYXGBgYGf8=",
|
||||
"hex": "9f0102030405060708090a0b0c0d0e0f101112131415161718181819ff",
|
||||
"roundtrip": false,
|
||||
"decoded": [
|
||||
1,
|
||||
2,
|
||||
3,
|
||||
4,
|
||||
5,
|
||||
6,
|
||||
7,
|
||||
8,
|
||||
9,
|
||||
10,
|
||||
11,
|
||||
12,
|
||||
13,
|
||||
14,
|
||||
15,
|
||||
16,
|
||||
17,
|
||||
18,
|
||||
19,
|
||||
20,
|
||||
21,
|
||||
22,
|
||||
23,
|
||||
24,
|
||||
25
|
||||
]
|
||||
},
|
||||
{
|
||||
"cbor": "v2FhAWFinwID//8=",
|
||||
"hex": "bf61610161629f0203ffff",
|
||||
"roundtrip": false,
|
||||
"decoded": {
|
||||
"a": 1,
|
||||
"b": [
|
||||
2,
|
||||
3
|
||||
]
|
||||
}
|
||||
},
|
||||
{
|
||||
"cbor": "gmFhv2FiYWP/",
|
||||
"hex": "826161bf61626163ff",
|
||||
"roundtrip": false,
|
||||
"decoded": [
|
||||
"a",
|
||||
{
|
||||
"b": "c"
|
||||
}
|
||||
]
|
||||
},
|
||||
{
|
||||
"cbor": "v2NGdW71Y0FtdCH/",
|
||||
"hex": "bf6346756ef563416d7421ff",
|
||||
"roundtrip": false,
|
||||
"decoded": {
|
||||
"Fun": true,
|
||||
"Amt": -2
|
||||
}
|
||||
}
|
||||
]
|
136
vendor/github.com/ugorji/go/codec/test.py
generated
vendored
Normal file
136
vendor/github.com/ugorji/go/codec/test.py
generated
vendored
Normal file
|
@ -0,0 +1,136 @@
|
|||
#!/usr/bin/env python
|
||||
|
||||
# This will create golden files in a directory passed to it.
|
||||
# A Test calls this internally to create the golden files
|
||||
# So it can process them (so we don't have to checkin the files).
|
||||
|
||||
# Ensure msgpack-python and cbor are installed first, using:
|
||||
# sudo apt install python-dev (may not be necessary)
|
||||
# sudo apt install python-pip # or python3-pip
|
||||
# pip install --user msgpack-python msgpack-rpc-python cbor
|
||||
|
||||
# Ensure all "string" keys are utf strings (else encoded as bytes)
|
||||
|
||||
from __future__ import print_function
|
||||
import cbor, msgpack, msgpackrpc, sys, os, threading
|
||||
|
||||
mylocaladdr="127.0.0.1" # localhost.localdomain localhost 127.0.0.1
|
||||
|
||||
def get_test_data_list():
|
||||
# get list with all primitive types, and a combo type
|
||||
l0 = [
|
||||
-8,
|
||||
-1616,
|
||||
-32323232,
|
||||
-6464646464646464,
|
||||
192,
|
||||
1616,
|
||||
32323232,
|
||||
6464646464646464,
|
||||
192,
|
||||
-3232.0,
|
||||
-6464646464.0,
|
||||
3232.0,
|
||||
6464.0,
|
||||
6464646464.0,
|
||||
False,
|
||||
True,
|
||||
u"null",
|
||||
None,
|
||||
u"some&day>some<day",
|
||||
1328176922000002000,
|
||||
u"",
|
||||
-2206187877999998000,
|
||||
u"bytestring",
|
||||
270,
|
||||
u"none",
|
||||
-2013855847999995777,
|
||||
#-6795364578871345152,
|
||||
]
|
||||
l1 = [
|
||||
{ "true": True,
|
||||
"false": False },
|
||||
{ "true": u"True",
|
||||
"false": False,
|
||||
"uint16(1616)": 1616 },
|
||||
{ "list": [1616, 32323232, True, -3232.0, {"TRUE":True, "FALSE":False}, [True, False] ],
|
||||
"int32":32323232, "bool": True,
|
||||
"LONG STRING": u"123456789012345678901234567890123456789012345678901234567890",
|
||||
"SHORT STRING": u"1234567890" },
|
||||
{ True: "true", 138: False, "false": 200 }
|
||||
]
|
||||
|
||||
l = []
|
||||
l.extend(l0)
|
||||
l.append(l0)
|
||||
l.append(1)
|
||||
l.extend(l1)
|
||||
return l
|
||||
|
||||
def build_test_data(destdir):
|
||||
l = get_test_data_list()
|
||||
for i in range(len(l)):
|
||||
# packer = msgpack.Packer()
|
||||
serialized = msgpack.dumps(l[i])
|
||||
with open(os.path.join(destdir, str(i) + '.msgpack.golden'), 'wb') as f:
|
||||
f.write(serialized)
|
||||
serialized = cbor.dumps(l[i])
|
||||
with open(os.path.join(destdir, str(i) + '.cbor.golden'), 'wb') as f:
|
||||
f.write(serialized)
|
||||
|
||||
def doRpcServer(port, stopTimeSec):
|
||||
class EchoHandler(object):
|
||||
def Echo123(self, msg1, msg2, msg3):
|
||||
return ("1:%s 2:%s 3:%s" % (msg1.decode("utf-8"), msg2.decode("utf-8"), msg3.decode("utf-8")))
|
||||
def EchoStruct(self, msg):
|
||||
return ("%s" % msg)
|
||||
|
||||
addr = msgpackrpc.Address(mylocaladdr, port)
|
||||
server = msgpackrpc.Server(EchoHandler())
|
||||
server.listen(addr)
|
||||
# run thread to stop it after stopTimeSec seconds if > 0
|
||||
if stopTimeSec > 0:
|
||||
def myStopRpcServer():
|
||||
server.stop()
|
||||
t = threading.Timer(stopTimeSec, myStopRpcServer)
|
||||
t.start()
|
||||
server.start()
|
||||
|
||||
def doRpcClientToPythonSvc(port):
|
||||
address = msgpackrpc.Address(mylocaladdr, port)
|
||||
client = msgpackrpc.Client(address, unpack_encoding='utf-8')
|
||||
print(client.call("Echo123", "A1", "B2", "C3"))
|
||||
print(client.call("EchoStruct", {"A" :"Aa", "B":"Bb", "C":"Cc"}))
|
||||
|
||||
# def doCheckSocket(port):
|
||||
# print(">>>> port: ", port, " <<<<<")
|
||||
# sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
|
||||
# result = sock.connect_ex(('127.0.0.1', port))
|
||||
# if result == 0:
|
||||
# print("\t>>>> Port is open")
|
||||
# else:
|
||||
# print("\t>>>> Port is not open")
|
||||
# sock.close()
|
||||
|
||||
def doRpcClientToGoSvc(port):
|
||||
# doCheckSocket(port)
|
||||
address = msgpackrpc.Address(mylocaladdr, port)
|
||||
client = msgpackrpc.Client(address, unpack_encoding='utf-8')
|
||||
print(client.call("TestRpcInt.Echo123", ["A1", "B2", "C3"]))
|
||||
print(client.call("TestRpcInt.EchoStruct", {"A" :"Aa", "B":"Bb", "C":"Cc"}))
|
||||
|
||||
def doMain(args):
|
||||
if len(args) == 2 and args[0] == "testdata":
|
||||
build_test_data(args[1])
|
||||
elif len(args) == 3 and args[0] == "rpc-server":
|
||||
doRpcServer(int(args[1]), int(args[2]))
|
||||
elif len(args) == 2 and args[0] == "rpc-client-python-service":
|
||||
doRpcClientToPythonSvc(int(args[1]))
|
||||
elif len(args) == 2 and args[0] == "rpc-client-go-service":
|
||||
doRpcClientToGoSvc(int(args[1]))
|
||||
else:
|
||||
print("Usage: test.py " +
|
||||
"[testdata|rpc-server|rpc-client-python-service|rpc-client-go-service] ...")
|
||||
|
||||
if __name__ == "__main__":
|
||||
doMain(sys.argv[1:])
|
287
vendor/github.com/ugorji/go/codec/writer.go
generated
vendored
Normal file
287
vendor/github.com/ugorji/go/codec/writer.go
generated
vendored
Normal file
|
@ -0,0 +1,287 @@
|
|||
// Copyright (c) 2012-2020 Ugorji Nwoke. All rights reserved.
|
||||
// Use of this source code is governed by a MIT license found in the LICENSE file.
|
||||
|
||||
package codec
|
||||
|
||||
import "io"
|
||||
|
||||
// encWriter abstracts writing to a byte array or to an io.Writer.
|
||||
type encWriter interface {
|
||||
writeb([]byte)
|
||||
writestr(string)
|
||||
writeqstr(string) // write string wrapped in quotes ie "..."
|
||||
writen1(byte)
|
||||
|
||||
// add convenience functions for writing 2,4
|
||||
writen2(byte, byte)
|
||||
writen4([4]byte)
|
||||
writen8([8]byte)
|
||||
|
||||
end()
|
||||
}
|
||||
|
||||
// ---------------------------------------------
|
||||
|
||||
type bufioEncWriter struct {
|
||||
w io.Writer
|
||||
|
||||
buf []byte
|
||||
|
||||
n int
|
||||
|
||||
b [16]byte // scratch buffer and padding (cache-aligned)
|
||||
}
|
||||
|
||||
func (z *bufioEncWriter) reset(w io.Writer, bufsize int, blist *bytesFreelist) {
|
||||
z.w = w
|
||||
z.n = 0
|
||||
if bufsize <= 0 {
|
||||
bufsize = defEncByteBufSize
|
||||
}
|
||||
// bufsize must be >= 8, to accomodate writen methods (where n <= 8)
|
||||
if bufsize <= 8 {
|
||||
bufsize = 8
|
||||
}
|
||||
if cap(z.buf) < bufsize {
|
||||
if len(z.buf) > 0 && &z.buf[0] != &z.b[0] {
|
||||
blist.put(z.buf)
|
||||
}
|
||||
if len(z.b) > bufsize {
|
||||
z.buf = z.b[:]
|
||||
} else {
|
||||
z.buf = blist.get(bufsize)
|
||||
}
|
||||
}
|
||||
z.buf = z.buf[:cap(z.buf)]
|
||||
}
|
||||
|
||||
func (z *bufioEncWriter) flushErr() (err error) {
|
||||
n, err := z.w.Write(z.buf[:z.n])
|
||||
z.n -= n
|
||||
if z.n > 0 {
|
||||
if err == nil {
|
||||
err = io.ErrShortWrite
|
||||
}
|
||||
if n > 0 {
|
||||
copy(z.buf, z.buf[n:z.n+n])
|
||||
}
|
||||
}
|
||||
return err
|
||||
}
|
||||
|
||||
func (z *bufioEncWriter) flush() {
|
||||
halt.onerror(z.flushErr())
|
||||
}
|
||||
|
||||
func (z *bufioEncWriter) writeb(s []byte) {
|
||||
LOOP:
|
||||
a := len(z.buf) - z.n
|
||||
if len(s) > a {
|
||||
z.n += copy(z.buf[z.n:], s[:a])
|
||||
s = s[a:]
|
||||
z.flush()
|
||||
goto LOOP
|
||||
}
|
||||
z.n += copy(z.buf[z.n:], s)
|
||||
}
|
||||
|
||||
func (z *bufioEncWriter) writestr(s string) {
|
||||
// z.writeb(bytesView(s)) // inlined below
|
||||
LOOP:
|
||||
a := len(z.buf) - z.n
|
||||
if len(s) > a {
|
||||
z.n += copy(z.buf[z.n:], s[:a])
|
||||
s = s[a:]
|
||||
z.flush()
|
||||
goto LOOP
|
||||
}
|
||||
z.n += copy(z.buf[z.n:], s)
|
||||
}
|
||||
|
||||
func (z *bufioEncWriter) writeqstr(s string) {
|
||||
// z.writen1('"')
|
||||
// z.writestr(s)
|
||||
// z.writen1('"')
|
||||
|
||||
if z.n+len(s)+2 > len(z.buf) {
|
||||
z.flush()
|
||||
}
|
||||
z.buf[z.n] = '"'
|
||||
z.n++
|
||||
LOOP:
|
||||
a := len(z.buf) - z.n
|
||||
if len(s)+1 > a {
|
||||
z.n += copy(z.buf[z.n:], s[:a])
|
||||
s = s[a:]
|
||||
z.flush()
|
||||
goto LOOP
|
||||
}
|
||||
z.n += copy(z.buf[z.n:], s)
|
||||
z.buf[z.n] = '"'
|
||||
z.n++
|
||||
}
|
||||
|
||||
func (z *bufioEncWriter) writen1(b1 byte) {
|
||||
if 1 > len(z.buf)-z.n {
|
||||
z.flush()
|
||||
}
|
||||
z.buf[z.n] = b1
|
||||
z.n++
|
||||
}
|
||||
func (z *bufioEncWriter) writen2(b1, b2 byte) {
|
||||
if 2 > len(z.buf)-z.n {
|
||||
z.flush()
|
||||
}
|
||||
z.buf[z.n+1] = b2
|
||||
z.buf[z.n] = b1
|
||||
z.n += 2
|
||||
}
|
||||
func (z *bufioEncWriter) writen4(b [4]byte) {
|
||||
if 4 > len(z.buf)-z.n {
|
||||
z.flush()
|
||||
}
|
||||
copy(z.buf[z.n:], b[:])
|
||||
z.n += 4
|
||||
}
|
||||
|
||||
func (z *bufioEncWriter) writen8(b [8]byte) {
|
||||
if 8 > len(z.buf)-z.n {
|
||||
z.flush()
|
||||
}
|
||||
copy(z.buf[z.n:], b[:])
|
||||
z.n += 8
|
||||
}
|
||||
|
||||
func (z *bufioEncWriter) endErr() (err error) {
|
||||
if z.n > 0 {
|
||||
err = z.flushErr()
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
// ---------------------------------------------
|
||||
|
||||
// bytesEncAppender implements encWriter and can write to an byte slice.
|
||||
type bytesEncAppender struct {
|
||||
b []byte
|
||||
out *[]byte
|
||||
}
|
||||
|
||||
func (z *bytesEncAppender) writeb(s []byte) {
|
||||
z.b = append(z.b, s...)
|
||||
}
|
||||
func (z *bytesEncAppender) writestr(s string) {
|
||||
z.b = append(z.b, s...)
|
||||
}
|
||||
func (z *bytesEncAppender) writeqstr(s string) {
|
||||
z.b = append(append(append(z.b, '"'), s...), '"')
|
||||
// z.b = append(z.b, '"')
|
||||
// z.b = append(z.b, s...)
|
||||
// z.b = append(z.b, '"')
|
||||
}
|
||||
func (z *bytesEncAppender) writen1(b1 byte) {
|
||||
z.b = append(z.b, b1)
|
||||
}
|
||||
func (z *bytesEncAppender) writen2(b1, b2 byte) {
|
||||
z.b = append(z.b, b1, b2)
|
||||
}
|
||||
func (z *bytesEncAppender) writen4(b [4]byte) {
|
||||
z.b = append(z.b, b[:]...)
|
||||
}
|
||||
func (z *bytesEncAppender) writen8(b [8]byte) {
|
||||
z.b = append(z.b, b[:]...)
|
||||
}
|
||||
func (z *bytesEncAppender) endErr() error {
|
||||
*(z.out) = z.b
|
||||
return nil
|
||||
}
|
||||
func (z *bytesEncAppender) reset(in []byte, out *[]byte) {
|
||||
z.b = in[:0]
|
||||
z.out = out
|
||||
}
|
||||
|
||||
// --------------------------------------------------
|
||||
|
||||
type encWr struct {
|
||||
bytes bool // encoding to []byte
|
||||
js bool // is json encoder?
|
||||
be bool // is binary encoder?
|
||||
|
||||
c containerState
|
||||
|
||||
calls uint16
|
||||
|
||||
wb bytesEncAppender
|
||||
wf *bufioEncWriter
|
||||
}
|
||||
|
||||
// MARKER: manually inline bytesEncAppender.writenx/writeqstr methods,
|
||||
// as calling them causes encWr.writenx/writeqstr methods to not be inlined (cost > 80).
|
||||
//
|
||||
// i.e. e.g. instead of writing z.wb.writen2(b1, b2), use z.wb.b = append(z.wb.b, b1, b2)
|
||||
|
||||
func (z *encWr) writeb(s []byte) {
|
||||
if z.bytes {
|
||||
z.wb.writeb(s)
|
||||
} else {
|
||||
z.wf.writeb(s)
|
||||
}
|
||||
}
|
||||
func (z *encWr) writeqstr(s string) {
|
||||
if z.bytes {
|
||||
// MARKER: z.wb.writeqstr(s)
|
||||
z.wb.b = append(append(append(z.wb.b, '"'), s...), '"')
|
||||
} else {
|
||||
z.wf.writeqstr(s)
|
||||
}
|
||||
}
|
||||
func (z *encWr) writestr(s string) {
|
||||
if z.bytes {
|
||||
z.wb.writestr(s)
|
||||
} else {
|
||||
z.wf.writestr(s)
|
||||
}
|
||||
}
|
||||
func (z *encWr) writen1(b1 byte) {
|
||||
if z.bytes {
|
||||
z.wb.writen1(b1)
|
||||
} else {
|
||||
z.wf.writen1(b1)
|
||||
}
|
||||
}
|
||||
|
||||
func (z *encWr) writen2(b1, b2 byte) {
|
||||
if z.bytes {
|
||||
// MARKER: z.wb.writen2(b1, b2)
|
||||
z.wb.b = append(z.wb.b, b1, b2)
|
||||
} else {
|
||||
z.wf.writen2(b1, b2)
|
||||
}
|
||||
}
|
||||
func (z *encWr) writen4(b [4]byte) {
|
||||
if z.bytes {
|
||||
z.wb.writen4(b)
|
||||
} else {
|
||||
z.wf.writen4(b)
|
||||
}
|
||||
}
|
||||
func (z *encWr) writen8(b [8]byte) {
|
||||
if z.bytes {
|
||||
z.wb.writen8(b)
|
||||
} else {
|
||||
z.wf.writen8(b)
|
||||
}
|
||||
}
|
||||
|
||||
func (z *encWr) endErr() error {
|
||||
if z.bytes {
|
||||
return z.wb.endErr()
|
||||
}
|
||||
return z.wf.endErr()
|
||||
}
|
||||
|
||||
func (z *encWr) end() {
|
||||
halt.onerror(z.endErr())
|
||||
}
|
||||
|
||||
var _ encWriter = (*encWr)(nil)
|
Loading…
Add table
Add a link
Reference in a new issue