summaryrefslogtreecommitdiff
path: root/vendor/github.com/vmihailenco/msgpack/v5
diff options
context:
space:
mode:
Diffstat (limited to 'vendor/github.com/vmihailenco/msgpack/v5')
-rw-r--r--vendor/github.com/vmihailenco/msgpack/v5/.prettierrc4
-rw-r--r--vendor/github.com/vmihailenco/msgpack/v5/.travis.yml20
-rw-r--r--vendor/github.com/vmihailenco/msgpack/v5/CHANGELOG.md75
-rw-r--r--vendor/github.com/vmihailenco/msgpack/v5/LICENSE25
-rw-r--r--vendor/github.com/vmihailenco/msgpack/v5/Makefile6
-rw-r--r--vendor/github.com/vmihailenco/msgpack/v5/README.md100
-rw-r--r--vendor/github.com/vmihailenco/msgpack/v5/commitlint.config.js1
-rw-r--r--vendor/github.com/vmihailenco/msgpack/v5/decode.go708
-rw-r--r--vendor/github.com/vmihailenco/msgpack/v5/decode_map.go356
-rw-r--r--vendor/github.com/vmihailenco/msgpack/v5/decode_number.go295
-rw-r--r--vendor/github.com/vmihailenco/msgpack/v5/decode_query.go157
-rw-r--r--vendor/github.com/vmihailenco/msgpack/v5/decode_slice.go198
-rw-r--r--vendor/github.com/vmihailenco/msgpack/v5/decode_string.go192
-rw-r--r--vendor/github.com/vmihailenco/msgpack/v5/decode_typgen.go46
-rw-r--r--vendor/github.com/vmihailenco/msgpack/v5/decode_value.go251
-rw-r--r--vendor/github.com/vmihailenco/msgpack/v5/encode.go270
-rw-r--r--vendor/github.com/vmihailenco/msgpack/v5/encode_map.go225
-rw-r--r--vendor/github.com/vmihailenco/msgpack/v5/encode_number.go252
-rw-r--r--vendor/github.com/vmihailenco/msgpack/v5/encode_slice.go139
-rw-r--r--vendor/github.com/vmihailenco/msgpack/v5/encode_value.go254
-rw-r--r--vendor/github.com/vmihailenco/msgpack/v5/ext.go303
-rw-r--r--vendor/github.com/vmihailenco/msgpack/v5/intern.go236
-rw-r--r--vendor/github.com/vmihailenco/msgpack/v5/msgpack.go52
-rw-r--r--vendor/github.com/vmihailenco/msgpack/v5/msgpcode/msgpcode.go88
-rw-r--r--vendor/github.com/vmihailenco/msgpack/v5/package.json4
-rw-r--r--vendor/github.com/vmihailenco/msgpack/v5/safe.go13
-rw-r--r--vendor/github.com/vmihailenco/msgpack/v5/time.go151
-rw-r--r--vendor/github.com/vmihailenco/msgpack/v5/types.go413
-rw-r--r--vendor/github.com/vmihailenco/msgpack/v5/unsafe.go22
-rw-r--r--vendor/github.com/vmihailenco/msgpack/v5/version.go6
30 files changed, 0 insertions, 4862 deletions
diff --git a/vendor/github.com/vmihailenco/msgpack/v5/.prettierrc b/vendor/github.com/vmihailenco/msgpack/v5/.prettierrc
deleted file mode 100644
index 8b7f044ad..000000000
--- a/vendor/github.com/vmihailenco/msgpack/v5/.prettierrc
+++ /dev/null
@@ -1,4 +0,0 @@
-semi: false
-singleQuote: true
-proseWrap: always
-printWidth: 100
diff --git a/vendor/github.com/vmihailenco/msgpack/v5/.travis.yml b/vendor/github.com/vmihailenco/msgpack/v5/.travis.yml
deleted file mode 100644
index e2ce06c49..000000000
--- a/vendor/github.com/vmihailenco/msgpack/v5/.travis.yml
+++ /dev/null
@@ -1,20 +0,0 @@
-sudo: false
-language: go
-
-go:
- - 1.15.x
- - 1.16.x
- - tip
-
-matrix:
- allow_failures:
- - go: tip
-
-env:
- - GO111MODULE=on
-
-go_import_path: github.com/vmihailenco/msgpack
-
-before_install:
- - curl -sfL https://install.goreleaser.com/github.com/golangci/golangci-lint.sh | sh -s -- -b $(go
- env GOPATH)/bin v1.31.0
diff --git a/vendor/github.com/vmihailenco/msgpack/v5/CHANGELOG.md b/vendor/github.com/vmihailenco/msgpack/v5/CHANGELOG.md
deleted file mode 100644
index d45441e6d..000000000
--- a/vendor/github.com/vmihailenco/msgpack/v5/CHANGELOG.md
+++ /dev/null
@@ -1,75 +0,0 @@
-## [5.4.1](https://github.com/vmihailenco/msgpack/compare/v5.4.0...v5.4.1) (2023-10-26)
-
-
-### Bug Fixes
-
-* **reflect:** not assignable to type ([edeaedd](https://github.com/vmihailenco/msgpack/commit/edeaeddb2d51868df8c6ff2d8a218b527aeaf5fd))
-
-
-
-# [5.4.0](https://github.com/vmihailenco/msgpack/compare/v5.3.6...v5.4.0) (2023-10-01)
-
-
-
-## [5.3.6](https://github.com/vmihailenco/msgpack/compare/v5.3.5...v5.3.6) (2023-10-01)
-
-
-### Features
-
-* allow overwriting time.Time parsing from extID 13 (for NodeJS Date) ([9a6b73b](https://github.com/vmihailenco/msgpack/commit/9a6b73b3588fd962d568715f4375e24b089f7066))
-* apply omitEmptyFlag to empty structs ([e5f8d03](https://github.com/vmihailenco/msgpack/commit/e5f8d03c0a1dd9cc571d648cd610305139078de5))
-* support sorted keys for map[string]bool ([690c1fa](https://github.com/vmihailenco/msgpack/commit/690c1fab9814fab4842295ea986111f49850d9a4))
-
-
-
-## [5.3.5](https://github.com/vmihailenco/msgpack/compare/v5.3.4...v5.3.5) (2021-10-22)
-
-- Allow decoding `nil` code as boolean false.
-
-## v5
-
-### Added
-
-- `DecodeMap` is split into `DecodeMap`, `DecodeTypedMap`, and `DecodeUntypedMap`.
-- New msgpack extensions API.
-
-### Changed
-
-- `Reset*` functions also reset flags.
-- `SetMapDecodeFunc` is renamed to `SetMapDecoder`.
-- `StructAsArray` is renamed to `UseArrayEncodedStructs`.
-- `SortMapKeys` is renamed to `SetSortMapKeys`.
-
-### Removed
-
-- `UseJSONTag` is removed. Use `SetCustomStructTag("json")` instead.
-
-## v4
-
-- Encode, Decode, Marshal, and Unmarshal are changed to accept single argument. EncodeMulti and
- DecodeMulti are added as replacement.
-- Added EncodeInt8/16/32/64 and EncodeUint8/16/32/64.
-- Encoder changed to preserve type of numbers instead of chosing most compact encoding. The old
- behavior can be achieved with Encoder.UseCompactEncoding.
-
-## v3.3
-
-- `msgpack:",inline"` tag is restored to force inlining structs.
-
-## v3.2
-
-- Decoding extension types returns pointer to the value instead of the value. Fixes #153
-
-## v3
-
-- gopkg.in is not supported any more. Update import path to github.com/vmihailenco/msgpack.
-- Msgpack maps are decoded into map[string]interface{} by default.
-- EncodeSliceLen is removed in favor of EncodeArrayLen. DecodeSliceLen is removed in favor of
- DecodeArrayLen.
-- Embedded structs are automatically inlined where possible.
-- Time is encoded using extension as described in https://github.com/msgpack/msgpack/pull/209. Old
- format is supported as well.
-- EncodeInt8/16/32/64 is replaced with EncodeInt. EncodeUint8/16/32/64 is replaced with EncodeUint.
- There should be no performance differences.
-- DecodeInterface can now return int8/16/32 and uint8/16/32.
-- PeekCode returns codes.Code instead of byte.
diff --git a/vendor/github.com/vmihailenco/msgpack/v5/LICENSE b/vendor/github.com/vmihailenco/msgpack/v5/LICENSE
deleted file mode 100644
index b749d0707..000000000
--- a/vendor/github.com/vmihailenco/msgpack/v5/LICENSE
+++ /dev/null
@@ -1,25 +0,0 @@
-Copyright (c) 2013 The github.com/vmihailenco/msgpack Authors.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:
-
- * Redistributions of source code must retain the above copyright
-notice, this list of conditions and the following disclaimer.
- * Redistributions in binary form must reproduce the above
-copyright notice, this list of conditions and the following disclaimer
-in the documentation and/or other materials provided with the
-distribution.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/vendor/github.com/vmihailenco/msgpack/v5/Makefile b/vendor/github.com/vmihailenco/msgpack/v5/Makefile
deleted file mode 100644
index e9aade782..000000000
--- a/vendor/github.com/vmihailenco/msgpack/v5/Makefile
+++ /dev/null
@@ -1,6 +0,0 @@
-test:
- go test ./...
- go test ./... -short -race
- go test ./... -run=NONE -bench=. -benchmem
- env GOOS=linux GOARCH=386 go test ./...
- go vet
diff --git a/vendor/github.com/vmihailenco/msgpack/v5/README.md b/vendor/github.com/vmihailenco/msgpack/v5/README.md
deleted file mode 100644
index 038464f18..000000000
--- a/vendor/github.com/vmihailenco/msgpack/v5/README.md
+++ /dev/null
@@ -1,100 +0,0 @@
-# MessagePack encoding for Golang
-
-[![Build Status](https://travis-ci.org/vmihailenco/msgpack.svg)](https://travis-ci.org/vmihailenco/msgpack)
-[![PkgGoDev](https://pkg.go.dev/badge/github.com/vmihailenco/msgpack/v5)](https://pkg.go.dev/github.com/vmihailenco/msgpack/v5)
-[![Documentation](https://img.shields.io/badge/msgpack-documentation-informational)](https://msgpack.uptrace.dev/)
-[![Chat](https://discordapp.com/api/guilds/752070105847955518/widget.png)](https://discord.gg/rWtp5Aj)
-
-> msgpack is brought to you by :star: [**uptrace/uptrace**](https://github.com/uptrace/uptrace).
-> Uptrace is an [open source APM](https://uptrace.dev/get/open-source-apm.html) and blazingly fast
-> [distributed tracing tool](https://get.uptrace.dev/compare/distributed-tracing-tools.html) powered
-> by OpenTelemetry and ClickHouse. Give it a star as well!
-
-## Resources
-
-- [Documentation](https://msgpack.uptrace.dev)
-- [Chat](https://discord.gg/rWtp5Aj)
-- [Reference](https://pkg.go.dev/github.com/vmihailenco/msgpack/v5)
-- [Examples](https://pkg.go.dev/github.com/vmihailenco/msgpack/v5#pkg-examples)
-
-## Features
-
-- Primitives, arrays, maps, structs, time.Time and interface{}.
-- Appengine \*datastore.Key and datastore.Cursor.
-- [CustomEncoder]/[CustomDecoder] interfaces for custom encoding.
-- [Extensions](https://pkg.go.dev/github.com/vmihailenco/msgpack/v5#example-RegisterExt) to encode
- type information.
-- Renaming fields via `msgpack:"my_field_name"` and alias via `msgpack:"alias:another_name"`.
-- Omitting individual empty fields via `msgpack:",omitempty"` tag or all
- [empty fields in a struct](https://pkg.go.dev/github.com/vmihailenco/msgpack/v5#example-Marshal-OmitEmpty).
-- [Map keys sorting](https://pkg.go.dev/github.com/vmihailenco/msgpack/v5#Encoder.SetSortMapKeys).
-- Encoding/decoding all
- [structs as arrays](https://pkg.go.dev/github.com/vmihailenco/msgpack/v5#Encoder.UseArrayEncodedStructs)
- or
- [individual structs](https://pkg.go.dev/github.com/vmihailenco/msgpack/v5#example-Marshal-AsArray).
-- [Encoder.SetCustomStructTag] with [Decoder.SetCustomStructTag] can turn msgpack into drop-in
- replacement for any tag.
-- Simple but very fast and efficient
- [queries](https://pkg.go.dev/github.com/vmihailenco/msgpack/v5#example-Decoder.Query).
-
-[customencoder]: https://pkg.go.dev/github.com/vmihailenco/msgpack/v5#CustomEncoder
-[customdecoder]: https://pkg.go.dev/github.com/vmihailenco/msgpack/v5#CustomDecoder
-[encoder.setcustomstructtag]:
- https://pkg.go.dev/github.com/vmihailenco/msgpack/v5#Encoder.SetCustomStructTag
-[decoder.setcustomstructtag]:
- https://pkg.go.dev/github.com/vmihailenco/msgpack/v5#Decoder.SetCustomStructTag
-
-## Installation
-
-msgpack supports 2 last Go versions and requires support for
-[Go modules](https://github.com/golang/go/wiki/Modules). So make sure to initialize a Go module:
-
-```shell
-go mod init github.com/my/repo
-```
-
-And then install msgpack/v5 (note _v5_ in the import; omitting it is a popular mistake):
-
-```shell
-go get github.com/vmihailenco/msgpack/v5
-```
-
-## Quickstart
-
-```go
-import "github.com/vmihailenco/msgpack/v5"
-
-func ExampleMarshal() {
- type Item struct {
- Foo string
- }
-
- b, err := msgpack.Marshal(&Item{Foo: "bar"})
- if err != nil {
- panic(err)
- }
-
- var item Item
- err = msgpack.Unmarshal(b, &item)
- if err != nil {
- panic(err)
- }
- fmt.Println(item.Foo)
- // Output: bar
-}
-```
-
-## See also
-
-- [Golang ORM](https://github.com/uptrace/bun) for PostgreSQL, MySQL, MSSQL, and SQLite
-- [Golang PostgreSQL](https://bun.uptrace.dev/postgres/)
-- [Golang HTTP router](https://github.com/uptrace/bunrouter)
-- [Golang ClickHouse ORM](https://github.com/uptrace/go-clickhouse)
-
-## Contributors
-
-Thanks to all the people who already contributed!
-
-<a href="https://github.com/vmihailenco/msgpack/graphs/contributors">
- <img src="https://contributors-img.web.app/image?repo=vmihailenco/msgpack" />
-</a>
diff --git a/vendor/github.com/vmihailenco/msgpack/v5/commitlint.config.js b/vendor/github.com/vmihailenco/msgpack/v5/commitlint.config.js
deleted file mode 100644
index 4fedde6da..000000000
--- a/vendor/github.com/vmihailenco/msgpack/v5/commitlint.config.js
+++ /dev/null
@@ -1 +0,0 @@
-module.exports = { extends: ['@commitlint/config-conventional'] }
diff --git a/vendor/github.com/vmihailenco/msgpack/v5/decode.go b/vendor/github.com/vmihailenco/msgpack/v5/decode.go
deleted file mode 100644
index ea645aadb..000000000
--- a/vendor/github.com/vmihailenco/msgpack/v5/decode.go
+++ /dev/null
@@ -1,708 +0,0 @@
-package msgpack
-
-import (
- "bufio"
- "bytes"
- "errors"
- "fmt"
- "io"
- "reflect"
- "sync"
- "time"
-
- "github.com/vmihailenco/msgpack/v5/msgpcode"
-)
-
-const (
- bytesAllocLimit = 1 << 20 // 1mb
- sliceAllocLimit = 1e6 // 1m elements
- maxMapSize = 1e6 // 1m elements
-)
-
-const (
- looseInterfaceDecodingFlag uint32 = 1 << iota
- disallowUnknownFieldsFlag
- usePreallocateValues
- disableAllocLimitFlag
-)
-
-type bufReader interface {
- io.Reader
- io.ByteScanner
-}
-
-//------------------------------------------------------------------------------
-
-var decPool = sync.Pool{
- New: func() interface{} {
- return NewDecoder(nil)
- },
-}
-
-func GetDecoder() *Decoder {
- return decPool.Get().(*Decoder)
-}
-
-func PutDecoder(dec *Decoder) {
- dec.r = nil
- dec.s = nil
- decPool.Put(dec)
-}
-
-//------------------------------------------------------------------------------
-
-// Unmarshal decodes the MessagePack-encoded data and stores the result
-// in the value pointed to by v.
-func Unmarshal(data []byte, v interface{}) error {
- dec := GetDecoder()
- dec.UsePreallocateValues(true)
- dec.Reset(bytes.NewReader(data))
- err := dec.Decode(v)
-
- PutDecoder(dec)
-
- return err
-}
-
-// A Decoder reads and decodes MessagePack values from an input stream.
-type Decoder struct {
- r io.Reader
- s io.ByteScanner
- mapDecoder func(*Decoder) (interface{}, error)
- structTag string
- buf []byte
- rec []byte
- dict []string
- flags uint32
-}
-
-// NewDecoder returns a new decoder that reads from r.
-//
-// The decoder introduces its own buffering and may read data from r
-// beyond the requested msgpack values. Buffering can be disabled
-// by passing a reader that implements io.ByteScanner interface.
-func NewDecoder(r io.Reader) *Decoder {
- d := new(Decoder)
- d.Reset(r)
- return d
-}
-
-// Reset discards any buffered data, resets all state, and switches the buffered
-// reader to read from r.
-func (d *Decoder) Reset(r io.Reader) {
- d.ResetDict(r, nil)
-}
-
-// ResetDict is like Reset, but also resets the dict.
-func (d *Decoder) ResetDict(r io.Reader, dict []string) {
- d.ResetReader(r)
- d.flags = 0
- d.structTag = ""
- d.dict = dict
-}
-
-func (d *Decoder) WithDict(dict []string, fn func(*Decoder) error) error {
- oldDict := d.dict
- d.dict = dict
- err := fn(d)
- d.dict = oldDict
- return err
-}
-
-func (d *Decoder) ResetReader(r io.Reader) {
- d.mapDecoder = nil
- d.dict = nil
-
- if br, ok := r.(bufReader); ok {
- d.r = br
- d.s = br
- } else if r == nil {
- d.r = nil
- d.s = nil
- } else {
- br := bufio.NewReader(r)
- d.r = br
- d.s = br
- }
-}
-
-func (d *Decoder) SetMapDecoder(fn func(*Decoder) (interface{}, error)) {
- d.mapDecoder = fn
-}
-
-// UseLooseInterfaceDecoding causes decoder to use DecodeInterfaceLoose
-// to decode msgpack value into Go interface{}.
-func (d *Decoder) UseLooseInterfaceDecoding(on bool) {
- if on {
- d.flags |= looseInterfaceDecodingFlag
- } else {
- d.flags &= ^looseInterfaceDecodingFlag
- }
-}
-
-// SetCustomStructTag causes the decoder to use the supplied tag as a fallback option
-// if there is no msgpack tag.
-func (d *Decoder) SetCustomStructTag(tag string) {
- d.structTag = tag
-}
-
-// DisallowUnknownFields causes the Decoder to return an error when the destination
-// is a struct and the input contains object keys which do not match any
-// non-ignored, exported fields in the destination.
-func (d *Decoder) DisallowUnknownFields(on bool) {
- if on {
- d.flags |= disallowUnknownFieldsFlag
- } else {
- d.flags &= ^disallowUnknownFieldsFlag
- }
-}
-
-// UseInternedStrings enables support for decoding interned strings.
-func (d *Decoder) UseInternedStrings(on bool) {
- if on {
- d.flags |= useInternedStringsFlag
- } else {
- d.flags &= ^useInternedStringsFlag
- }
-}
-
-// UsePreallocateValues enables preallocating values in chunks
-func (d *Decoder) UsePreallocateValues(on bool) {
- if on {
- d.flags |= usePreallocateValues
- } else {
- d.flags &= ^usePreallocateValues
- }
-}
-
-// DisableAllocLimit enables fully allocating slices/maps when the size is known
-func (d *Decoder) DisableAllocLimit(on bool) {
- if on {
- d.flags |= disableAllocLimitFlag
- } else {
- d.flags &= ^disableAllocLimitFlag
- }
-}
-
-// Buffered returns a reader of the data remaining in the Decoder's buffer.
-// The reader is valid until the next call to Decode.
-func (d *Decoder) Buffered() io.Reader {
- return d.r
-}
-
-//nolint:gocyclo
-func (d *Decoder) Decode(v interface{}) error {
- var err error
- switch v := v.(type) {
- case *string:
- if v != nil {
- *v, err = d.DecodeString()
- return err
- }
- case *[]byte:
- if v != nil {
- return d.decodeBytesPtr(v)
- }
- case *int:
- if v != nil {
- *v, err = d.DecodeInt()
- return err
- }
- case *int8:
- if v != nil {
- *v, err = d.DecodeInt8()
- return err
- }
- case *int16:
- if v != nil {
- *v, err = d.DecodeInt16()
- return err
- }
- case *int32:
- if v != nil {
- *v, err = d.DecodeInt32()
- return err
- }
- case *int64:
- if v != nil {
- *v, err = d.DecodeInt64()
- return err
- }
- case *uint:
- if v != nil {
- *v, err = d.DecodeUint()
- return err
- }
- case *uint8:
- if v != nil {
- *v, err = d.DecodeUint8()
- return err
- }
- case *uint16:
- if v != nil {
- *v, err = d.DecodeUint16()
- return err
- }
- case *uint32:
- if v != nil {
- *v, err = d.DecodeUint32()
- return err
- }
- case *uint64:
- if v != nil {
- *v, err = d.DecodeUint64()
- return err
- }
- case *bool:
- if v != nil {
- *v, err = d.DecodeBool()
- return err
- }
- case *float32:
- if v != nil {
- *v, err = d.DecodeFloat32()
- return err
- }
- case *float64:
- if v != nil {
- *v, err = d.DecodeFloat64()
- return err
- }
- case *[]string:
- return d.decodeStringSlicePtr(v)
- case *map[string]string:
- return d.decodeMapStringStringPtr(v)
- case *map[string]interface{}:
- return d.decodeMapStringInterfacePtr(v)
- case *time.Duration:
- if v != nil {
- vv, err := d.DecodeInt64()
- *v = time.Duration(vv)
- return err
- }
- case *time.Time:
- if v != nil {
- *v, err = d.DecodeTime()
- return err
- }
- }
-
- vv := reflect.ValueOf(v)
- if !vv.IsValid() {
- return errors.New("msgpack: Decode(nil)")
- }
- if vv.Kind() != reflect.Ptr {
- return fmt.Errorf("msgpack: Decode(non-pointer %T)", v)
- }
- if vv.IsNil() {
- return fmt.Errorf("msgpack: Decode(non-settable %T)", v)
- }
-
- vv = vv.Elem()
- if vv.Kind() == reflect.Interface {
- if !vv.IsNil() {
- vv = vv.Elem()
- if vv.Kind() != reflect.Ptr {
- return fmt.Errorf("msgpack: Decode(non-pointer %s)", vv.Type().String())
- }
- }
- }
-
- return d.DecodeValue(vv)
-}
-
-func (d *Decoder) DecodeMulti(v ...interface{}) error {
- for _, vv := range v {
- if err := d.Decode(vv); err != nil {
- return err
- }
- }
- return nil
-}
-
-func (d *Decoder) decodeInterfaceCond() (interface{}, error) {
- if d.flags&looseInterfaceDecodingFlag != 0 {
- return d.DecodeInterfaceLoose()
- }
- return d.DecodeInterface()
-}
-
-func (d *Decoder) DecodeValue(v reflect.Value) error {
- decode := getDecoder(v.Type())
- return decode(d, v)
-}
-
-func (d *Decoder) DecodeNil() error {
- c, err := d.readCode()
- if err != nil {
- return err
- }
- if c != msgpcode.Nil {
- return fmt.Errorf("msgpack: invalid code=%x decoding nil", c)
- }
- return nil
-}
-
-func (d *Decoder) decodeNilValue(v reflect.Value) error {
- err := d.DecodeNil()
- if v.IsNil() {
- return err
- }
- if v.Kind() == reflect.Ptr {
- v = v.Elem()
- }
- v.Set(reflect.Zero(v.Type()))
- return err
-}
-
-func (d *Decoder) DecodeBool() (bool, error) {
- c, err := d.readCode()
- if err != nil {
- return false, err
- }
- return d.bool(c)
-}
-
-func (d *Decoder) bool(c byte) (bool, error) {
- if c == msgpcode.Nil {
- return false, nil
- }
- if c == msgpcode.False {
- return false, nil
- }
- if c == msgpcode.True {
- return true, nil
- }
- return false, fmt.Errorf("msgpack: invalid code=%x decoding bool", c)
-}
-
-func (d *Decoder) DecodeDuration() (time.Duration, error) {
- n, err := d.DecodeInt64()
- if err != nil {
- return 0, err
- }
- return time.Duration(n), nil
-}
-
-// DecodeInterface decodes value into interface. It returns following types:
-// - nil,
-// - bool,
-// - int8, int16, int32, int64,
-// - uint8, uint16, uint32, uint64,
-// - float32 and float64,
-// - string,
-// - []byte,
-// - slices of any of the above,
-// - maps of any of the above.
-//
-// DecodeInterface should be used only when you don't know the type of value
-// you are decoding. For example, if you are decoding number it is better to use
-// DecodeInt64 for negative numbers and DecodeUint64 for positive numbers.
-func (d *Decoder) DecodeInterface() (interface{}, error) {
- c, err := d.readCode()
- if err != nil {
- return nil, err
- }
-
- if msgpcode.IsFixedNum(c) {
- return int8(c), nil
- }
- if msgpcode.IsFixedMap(c) {
- err = d.s.UnreadByte()
- if err != nil {
- return nil, err
- }
- return d.decodeMapDefault()
- }
- if msgpcode.IsFixedArray(c) {
- return d.decodeSlice(c)
- }
- if msgpcode.IsFixedString(c) {
- return d.string(c)
- }
-
- switch c {
- case msgpcode.Nil:
- return nil, nil
- case msgpcode.False, msgpcode.True:
- return d.bool(c)
- case msgpcode.Float:
- return d.float32(c)
- case msgpcode.Double:
- return d.float64(c)
- case msgpcode.Uint8:
- return d.uint8()
- case msgpcode.Uint16:
- return d.uint16()
- case msgpcode.Uint32:
- return d.uint32()
- case msgpcode.Uint64:
- return d.uint64()
- case msgpcode.Int8:
- return d.int8()
- case msgpcode.Int16:
- return d.int16()
- case msgpcode.Int32:
- return d.int32()
- case msgpcode.Int64:
- return d.int64()
- case msgpcode.Bin8, msgpcode.Bin16, msgpcode.Bin32:
- return d.bytes(c, nil)
- case msgpcode.Str8, msgpcode.Str16, msgpcode.Str32:
- return d.string(c)
- case msgpcode.Array16, msgpcode.Array32:
- return d.decodeSlice(c)
- case msgpcode.Map16, msgpcode.Map32:
- err = d.s.UnreadByte()
- if err != nil {
- return nil, err
- }
- return d.decodeMapDefault()
- case msgpcode.FixExt1, msgpcode.FixExt2, msgpcode.FixExt4, msgpcode.FixExt8, msgpcode.FixExt16,
- msgpcode.Ext8, msgpcode.Ext16, msgpcode.Ext32:
- return d.decodeInterfaceExt(c)
- }
-
- return 0, fmt.Errorf("msgpack: unknown code %x decoding interface{}", c)
-}
-
-// DecodeInterfaceLoose is like DecodeInterface except that:
-// - int8, int16, and int32 are converted to int64,
-// - uint8, uint16, and uint32 are converted to uint64,
-// - float32 is converted to float64.
-// - []byte is converted to string.
-func (d *Decoder) DecodeInterfaceLoose() (interface{}, error) {
- c, err := d.readCode()
- if err != nil {
- return nil, err
- }
-
- if msgpcode.IsFixedNum(c) {
- return int64(int8(c)), nil
- }
- if msgpcode.IsFixedMap(c) {
- err = d.s.UnreadByte()
- if err != nil {
- return nil, err
- }
- return d.decodeMapDefault()
- }
- if msgpcode.IsFixedArray(c) {
- return d.decodeSlice(c)
- }
- if msgpcode.IsFixedString(c) {
- return d.string(c)
- }
-
- switch c {
- case msgpcode.Nil:
- return nil, nil
- case msgpcode.False, msgpcode.True:
- return d.bool(c)
- case msgpcode.Float, msgpcode.Double:
- return d.float64(c)
- case msgpcode.Uint8, msgpcode.Uint16, msgpcode.Uint32, msgpcode.Uint64:
- return d.uint(c)
- case msgpcode.Int8, msgpcode.Int16, msgpcode.Int32, msgpcode.Int64:
- return d.int(c)
- case msgpcode.Str8, msgpcode.Str16, msgpcode.Str32,
- msgpcode.Bin8, msgpcode.Bin16, msgpcode.Bin32:
- return d.string(c)
- case msgpcode.Array16, msgpcode.Array32:
- return d.decodeSlice(c)
- case msgpcode.Map16, msgpcode.Map32:
- err = d.s.UnreadByte()
- if err != nil {
- return nil, err
- }
- return d.decodeMapDefault()
- case msgpcode.FixExt1, msgpcode.FixExt2, msgpcode.FixExt4, msgpcode.FixExt8, msgpcode.FixExt16,
- msgpcode.Ext8, msgpcode.Ext16, msgpcode.Ext32:
- return d.decodeInterfaceExt(c)
- }
-
- return 0, fmt.Errorf("msgpack: unknown code %x decoding interface{}", c)
-}
-
-// Skip skips next value.
-func (d *Decoder) Skip() error {
- c, err := d.readCode()
- if err != nil {
- return err
- }
-
- if msgpcode.IsFixedNum(c) {
- return nil
- }
- if msgpcode.IsFixedMap(c) {
- return d.skipMap(c)
- }
- if msgpcode.IsFixedArray(c) {
- return d.skipSlice(c)
- }
- if msgpcode.IsFixedString(c) {
- return d.skipBytes(c)
- }
-
- switch c {
- case msgpcode.Nil, msgpcode.False, msgpcode.True:
- return nil
- case msgpcode.Uint8, msgpcode.Int8:
- return d.skipN(1)
- case msgpcode.Uint16, msgpcode.Int16:
- return d.skipN(2)
- case msgpcode.Uint32, msgpcode.Int32, msgpcode.Float:
- return d.skipN(4)
- case msgpcode.Uint64, msgpcode.Int64, msgpcode.Double:
- return d.skipN(8)
- case msgpcode.Bin8, msgpcode.Bin16, msgpcode.Bin32:
- return d.skipBytes(c)
- case msgpcode.Str8, msgpcode.Str16, msgpcode.Str32:
- return d.skipBytes(c)
- case msgpcode.Array16, msgpcode.Array32:
- return d.skipSlice(c)
- case msgpcode.Map16, msgpcode.Map32:
- return d.skipMap(c)
- case msgpcode.FixExt1, msgpcode.FixExt2, msgpcode.FixExt4, msgpcode.FixExt8, msgpcode.FixExt16,
- msgpcode.Ext8, msgpcode.Ext16, msgpcode.Ext32:
- return d.skipExt(c)
- }
-
- return fmt.Errorf("msgpack: unknown code %x", c)
-}
-
-func (d *Decoder) DecodeRaw() (RawMessage, error) {
- d.rec = make([]byte, 0)
- if err := d.Skip(); err != nil {
- return nil, err
- }
- msg := RawMessage(d.rec)
- d.rec = nil
- return msg, nil
-}
-
-// PeekCode returns the next MessagePack code without advancing the reader.
-// Subpackage msgpack/codes defines the list of available msgpcode.
-func (d *Decoder) PeekCode() (byte, error) {
- c, err := d.s.ReadByte()
- if err != nil {
- return 0, err
- }
- return c, d.s.UnreadByte()
-}
-
-// ReadFull reads exactly len(buf) bytes into the buf.
-func (d *Decoder) ReadFull(buf []byte) error {
- _, err := readN(d.r, buf, len(buf))
- return err
-}
-
-func (d *Decoder) hasNilCode() bool {
- code, err := d.PeekCode()
- return err == nil && code == msgpcode.Nil
-}
-
-func (d *Decoder) readCode() (byte, error) {
- c, err := d.s.ReadByte()
- if err != nil {
- return 0, err
- }
- if d.rec != nil {
- d.rec = append(d.rec, c)
- }
- return c, nil
-}
-
-func (d *Decoder) readFull(b []byte) error {
- _, err := io.ReadFull(d.r, b)
- if err != nil {
- return err
- }
- if d.rec != nil {
- d.rec = append(d.rec, b...)
- }
- return nil
-}
-
-func (d *Decoder) readN(n int) ([]byte, error) {
- var err error
- if d.flags&disableAllocLimitFlag != 0 {
- d.buf, err = readN(d.r, d.buf, n)
- } else {
- d.buf, err = readNGrow(d.r, d.buf, n)
- }
- if err != nil {
- return nil, err
- }
- if d.rec != nil {
- // TODO: read directly into d.rec?
- d.rec = append(d.rec, d.buf...)
- }
- return d.buf, nil
-}
-
-func readN(r io.Reader, b []byte, n int) ([]byte, error) {
- if b == nil {
- if n == 0 {
- return make([]byte, 0), nil
- }
- b = make([]byte, 0, n)
- }
-
- if n > cap(b) {
- b = append(b, make([]byte, n-len(b))...)
- } else if n <= cap(b) {
- b = b[:n]
- }
-
- _, err := io.ReadFull(r, b)
- return b, err
-}
-
-func readNGrow(r io.Reader, b []byte, n int) ([]byte, error) {
- if b == nil {
- if n == 0 {
- return make([]byte, 0), nil
- }
- switch {
- case n < 64:
- b = make([]byte, 0, 64)
- case n <= bytesAllocLimit:
- b = make([]byte, 0, n)
- default:
- b = make([]byte, 0, bytesAllocLimit)
- }
- }
-
- if n <= cap(b) {
- b = b[:n]
- _, err := io.ReadFull(r, b)
- return b, err
- }
- b = b[:cap(b)]
-
- var pos int
- for {
- alloc := min(n-len(b), bytesAllocLimit)
- b = append(b, make([]byte, alloc)...)
-
- _, err := io.ReadFull(r, b[pos:])
- if err != nil {
- return b, err
- }
-
- if len(b) == n {
- break
- }
- pos = len(b)
- }
-
- return b, nil
-}
-
-func min(a, b int) int { //nolint:unparam
- if a <= b {
- return a
- }
- return b
-}
diff --git a/vendor/github.com/vmihailenco/msgpack/v5/decode_map.go b/vendor/github.com/vmihailenco/msgpack/v5/decode_map.go
deleted file mode 100644
index c54dae374..000000000
--- a/vendor/github.com/vmihailenco/msgpack/v5/decode_map.go
+++ /dev/null
@@ -1,356 +0,0 @@
-package msgpack
-
-import (
- "errors"
- "fmt"
- "reflect"
-
- "github.com/vmihailenco/msgpack/v5/msgpcode"
-)
-
-var errArrayStruct = errors.New("msgpack: number of fields in array-encoded struct has changed")
-
-var (
- mapStringStringPtrType = reflect.TypeOf((*map[string]string)(nil))
- mapStringStringType = mapStringStringPtrType.Elem()
- mapStringBoolPtrType = reflect.TypeOf((*map[string]bool)(nil))
- mapStringBoolType = mapStringBoolPtrType.Elem()
-)
-
-var (
- mapStringInterfacePtrType = reflect.TypeOf((*map[string]interface{})(nil))
- mapStringInterfaceType = mapStringInterfacePtrType.Elem()
-)
-
-func decodeMapValue(d *Decoder, v reflect.Value) error {
- n, err := d.DecodeMapLen()
- if err != nil {
- return err
- }
-
- typ := v.Type()
- if n == -1 {
- v.Set(reflect.Zero(typ))
- return nil
- }
-
- if v.IsNil() {
- ln := n
- if d.flags&disableAllocLimitFlag == 0 {
- ln = min(ln, maxMapSize)
- }
- v.Set(reflect.MakeMapWithSize(typ, ln))
- }
- if n == 0 {
- return nil
- }
-
- return d.decodeTypedMapValue(v, n)
-}
-
-func (d *Decoder) decodeMapDefault() (interface{}, error) {
- if d.mapDecoder != nil {
- return d.mapDecoder(d)
- }
- return d.DecodeMap()
-}
-
-// DecodeMapLen decodes map length. Length is -1 when map is nil.
-func (d *Decoder) DecodeMapLen() (int, error) {
- c, err := d.readCode()
- if err != nil {
- return 0, err
- }
-
- if msgpcode.IsExt(c) {
- if err = d.skipExtHeader(c); err != nil {
- return 0, err
- }
-
- c, err = d.readCode()
- if err != nil {
- return 0, err
- }
- }
- return d.mapLen(c)
-}
-
-func (d *Decoder) mapLen(c byte) (int, error) {
- if c == msgpcode.Nil {
- return -1, nil
- }
- if c >= msgpcode.FixedMapLow && c <= msgpcode.FixedMapHigh {
- return int(c & msgpcode.FixedMapMask), nil
- }
- if c == msgpcode.Map16 {
- size, err := d.uint16()
- return int(size), err
- }
- if c == msgpcode.Map32 {
- size, err := d.uint32()
- return int(size), err
- }
- return 0, unexpectedCodeError{code: c, hint: "map length"}
-}
-
-func decodeMapStringStringValue(d *Decoder, v reflect.Value) error {
- mptr := v.Addr().Convert(mapStringStringPtrType).Interface().(*map[string]string)
- return d.decodeMapStringStringPtr(mptr)
-}
-
-func (d *Decoder) decodeMapStringStringPtr(ptr *map[string]string) error {
- size, err := d.DecodeMapLen()
- if err != nil {
- return err
- }
- if size == -1 {
- *ptr = nil
- return nil
- }
-
- m := *ptr
- if m == nil {
- ln := size
- if d.flags&disableAllocLimitFlag == 0 {
- ln = min(size, maxMapSize)
- }
- *ptr = make(map[string]string, ln)
- m = *ptr
- }
-
- for i := 0; i < size; i++ {
- mk, err := d.DecodeString()
- if err != nil {
- return err
- }
- mv, err := d.DecodeString()
- if err != nil {
- return err
- }
- m[mk] = mv
- }
-
- return nil
-}
-
-func decodeMapStringInterfaceValue(d *Decoder, v reflect.Value) error {
- ptr := v.Addr().Convert(mapStringInterfacePtrType).Interface().(*map[string]interface{})
- return d.decodeMapStringInterfacePtr(ptr)
-}
-
-func (d *Decoder) decodeMapStringInterfacePtr(ptr *map[string]interface{}) error {
- m, err := d.DecodeMap()
- if err != nil {
- return err
- }
- *ptr = m
- return nil
-}
-
-func (d *Decoder) DecodeMap() (map[string]interface{}, error) {
- n, err := d.DecodeMapLen()
- if err != nil {
- return nil, err
- }
-
- if n == -1 {
- return nil, nil
- }
-
- m := make(map[string]interface{}, n)
-
- for i := 0; i < n; i++ {
- mk, err := d.DecodeString()
- if err != nil {
- return nil, err
- }
- mv, err := d.decodeInterfaceCond()
- if err != nil {
- return nil, err
- }
- m[mk] = mv
- }
-
- return m, nil
-}
-
-func (d *Decoder) DecodeUntypedMap() (map[interface{}]interface{}, error) {
- n, err := d.DecodeMapLen()
- if err != nil {
- return nil, err
- }
-
- if n == -1 {
- return nil, nil
- }
-
- m := make(map[interface{}]interface{}, n)
-
- for i := 0; i < n; i++ {
- mk, err := d.decodeInterfaceCond()
- if err != nil {
- return nil, err
- }
-
- mv, err := d.decodeInterfaceCond()
- if err != nil {
- return nil, err
- }
-
- m[mk] = mv
- }
-
- return m, nil
-}
-
-// DecodeTypedMap decodes a typed map. Typed map is a map that has a fixed type for keys and values.
-// Key and value types may be different.
-func (d *Decoder) DecodeTypedMap() (interface{}, error) {
- n, err := d.DecodeMapLen()
- if err != nil {
- return nil, err
- }
- if n <= 0 {
- return nil, nil
- }
-
- key, err := d.decodeInterfaceCond()
- if err != nil {
- return nil, err
- }
-
- value, err := d.decodeInterfaceCond()
- if err != nil {
- return nil, err
- }
-
- keyType := reflect.TypeOf(key)
- valueType := reflect.TypeOf(value)
-
- if !keyType.Comparable() {
- return nil, fmt.Errorf("msgpack: unsupported map key: %s", keyType.String())
- }
-
- mapType := reflect.MapOf(keyType, valueType)
-
- ln := n
- if d.flags&disableAllocLimitFlag == 0 {
- ln = min(ln, maxMapSize)
- }
-
- mapValue := reflect.MakeMapWithSize(mapType, ln)
- mapValue.SetMapIndex(reflect.ValueOf(key), reflect.ValueOf(value))
-
- n--
- if err := d.decodeTypedMapValue(mapValue, n); err != nil {
- return nil, err
- }
-
- return mapValue.Interface(), nil
-}
-
-func (d *Decoder) decodeTypedMapValue(v reflect.Value, n int) error {
- var (
- typ = v.Type()
- keyType = typ.Key()
- valueType = typ.Elem()
- )
- for i := 0; i < n; i++ {
- mk := d.newValue(keyType).Elem()
- if err := d.DecodeValue(mk); err != nil {
- return err
- }
-
- mv := d.newValue(valueType).Elem()
- if err := d.DecodeValue(mv); err != nil {
- return err
- }
-
- v.SetMapIndex(mk, mv)
- }
-
- return nil
-}
-
-func (d *Decoder) skipMap(c byte) error {
- n, err := d.mapLen(c)
- if err != nil {
- return err
- }
- for i := 0; i < n; i++ {
- if err := d.Skip(); err != nil {
- return err
- }
- if err := d.Skip(); err != nil {
- return err
- }
- }
- return nil
-}
-
-func decodeStructValue(d *Decoder, v reflect.Value) error {
- c, err := d.readCode()
- if err != nil {
- return err
- }
-
- n, err := d.mapLen(c)
- if err == nil {
- return d.decodeStruct(v, n)
- }
-
- var err2 error
- n, err2 = d.arrayLen(c)
- if err2 != nil {
- return err
- }
-
- if n <= 0 {
- v.Set(reflect.Zero(v.Type()))
- return nil
- }
-
- fields := structs.Fields(v.Type(), d.structTag)
- if n != len(fields.List) {
- return errArrayStruct
- }
-
- for _, f := range fields.List {
- if err := f.DecodeValue(d, v); err != nil {
- return err
- }
- }
-
- return nil
-}
-
-func (d *Decoder) decodeStruct(v reflect.Value, n int) error {
- if n == -1 {
- v.Set(reflect.Zero(v.Type()))
- return nil
- }
-
- fields := structs.Fields(v.Type(), d.structTag)
- for i := 0; i < n; i++ {
- name, err := d.decodeStringTemp()
- if err != nil {
- return err
- }
-
- if f := fields.Map[name]; f != nil {
- if err := f.DecodeValue(d, v); err != nil {
- return err
- }
- continue
- }
-
- if d.flags&disallowUnknownFieldsFlag != 0 {
- return fmt.Errorf("msgpack: unknown field %q", name)
- }
- if err := d.Skip(); err != nil {
- return err
- }
- }
-
- return nil
-}
diff --git a/vendor/github.com/vmihailenco/msgpack/v5/decode_number.go b/vendor/github.com/vmihailenco/msgpack/v5/decode_number.go
deleted file mode 100644
index 45d6a7418..000000000
--- a/vendor/github.com/vmihailenco/msgpack/v5/decode_number.go
+++ /dev/null
@@ -1,295 +0,0 @@
-package msgpack
-
-import (
- "fmt"
- "math"
- "reflect"
-
- "github.com/vmihailenco/msgpack/v5/msgpcode"
-)
-
-func (d *Decoder) skipN(n int) error {
- _, err := d.readN(n)
- return err
-}
-
-func (d *Decoder) uint8() (uint8, error) {
- c, err := d.readCode()
- if err != nil {
- return 0, err
- }
- return c, nil
-}
-
-func (d *Decoder) int8() (int8, error) {
- n, err := d.uint8()
- return int8(n), err
-}
-
-func (d *Decoder) uint16() (uint16, error) {
- b, err := d.readN(2)
- if err != nil {
- return 0, err
- }
- return (uint16(b[0]) << 8) | uint16(b[1]), nil
-}
-
-func (d *Decoder) int16() (int16, error) {
- n, err := d.uint16()
- return int16(n), err
-}
-
-func (d *Decoder) uint32() (uint32, error) {
- b, err := d.readN(4)
- if err != nil {
- return 0, err
- }
- n := (uint32(b[0]) << 24) |
- (uint32(b[1]) << 16) |
- (uint32(b[2]) << 8) |
- uint32(b[3])
- return n, nil
-}
-
-func (d *Decoder) int32() (int32, error) {
- n, err := d.uint32()
- return int32(n), err
-}
-
-func (d *Decoder) uint64() (uint64, error) {
- b, err := d.readN(8)
- if err != nil {
- return 0, err
- }
- n := (uint64(b[0]) << 56) |
- (uint64(b[1]) << 48) |
- (uint64(b[2]) << 40) |
- (uint64(b[3]) << 32) |
- (uint64(b[4]) << 24) |
- (uint64(b[5]) << 16) |
- (uint64(b[6]) << 8) |
- uint64(b[7])
- return n, nil
-}
-
-func (d *Decoder) int64() (int64, error) {
- n, err := d.uint64()
- return int64(n), err
-}
-
-// DecodeUint64 decodes msgpack int8/16/32/64 and uint8/16/32/64
-// into Go uint64.
-func (d *Decoder) DecodeUint64() (uint64, error) {
- c, err := d.readCode()
- if err != nil {
- return 0, err
- }
- return d.uint(c)
-}
-
-func (d *Decoder) uint(c byte) (uint64, error) {
- if c == msgpcode.Nil {
- return 0, nil
- }
- if msgpcode.IsFixedNum(c) {
- return uint64(int8(c)), nil
- }
- switch c {
- case msgpcode.Uint8:
- n, err := d.uint8()
- return uint64(n), err
- case msgpcode.Int8:
- n, err := d.int8()
- return uint64(n), err
- case msgpcode.Uint16:
- n, err := d.uint16()
- return uint64(n), err
- case msgpcode.Int16:
- n, err := d.int16()
- return uint64(n), err
- case msgpcode.Uint32:
- n, err := d.uint32()
- return uint64(n), err
- case msgpcode.Int32:
- n, err := d.int32()
- return uint64(n), err
- case msgpcode.Uint64, msgpcode.Int64:
- return d.uint64()
- }
- return 0, fmt.Errorf("msgpack: invalid code=%x decoding uint64", c)
-}
-
-// DecodeInt64 decodes msgpack int8/16/32/64 and uint8/16/32/64
-// into Go int64.
-func (d *Decoder) DecodeInt64() (int64, error) {
- c, err := d.readCode()
- if err != nil {
- return 0, err
- }
- return d.int(c)
-}
-
-func (d *Decoder) int(c byte) (int64, error) {
- if c == msgpcode.Nil {
- return 0, nil
- }
- if msgpcode.IsFixedNum(c) {
- return int64(int8(c)), nil
- }
- switch c {
- case msgpcode.Uint8:
- n, err := d.uint8()
- return int64(n), err
- case msgpcode.Int8:
- n, err := d.uint8()
- return int64(int8(n)), err
- case msgpcode.Uint16:
- n, err := d.uint16()
- return int64(n), err
- case msgpcode.Int16:
- n, err := d.uint16()
- return int64(int16(n)), err
- case msgpcode.Uint32:
- n, err := d.uint32()
- return int64(n), err
- case msgpcode.Int32:
- n, err := d.uint32()
- return int64(int32(n)), err
- case msgpcode.Uint64, msgpcode.Int64:
- n, err := d.uint64()
- return int64(n), err
- }
- return 0, fmt.Errorf("msgpack: invalid code=%x decoding int64", c)
-}
-
-func (d *Decoder) DecodeFloat32() (float32, error) {
- c, err := d.readCode()
- if err != nil {
- return 0, err
- }
- return d.float32(c)
-}
-
-func (d *Decoder) float32(c byte) (float32, error) {
- if c == msgpcode.Float {
- n, err := d.uint32()
- if err != nil {
- return 0, err
- }
- return math.Float32frombits(n), nil
- }
-
- n, err := d.int(c)
- if err != nil {
- return 0, fmt.Errorf("msgpack: invalid code=%x decoding float32", c)
- }
- return float32(n), nil
-}
-
-// DecodeFloat64 decodes msgpack float32/64 into Go float64.
-func (d *Decoder) DecodeFloat64() (float64, error) {
- c, err := d.readCode()
- if err != nil {
- return 0, err
- }
- return d.float64(c)
-}
-
-func (d *Decoder) float64(c byte) (float64, error) {
- switch c {
- case msgpcode.Float:
- n, err := d.float32(c)
- if err != nil {
- return 0, err
- }
- return float64(n), nil
- case msgpcode.Double:
- n, err := d.uint64()
- if err != nil {
- return 0, err
- }
- return math.Float64frombits(n), nil
- }
-
- n, err := d.int(c)
- if err != nil {
- return 0, fmt.Errorf("msgpack: invalid code=%x decoding float32", c)
- }
- return float64(n), nil
-}
-
-func (d *Decoder) DecodeUint() (uint, error) {
- n, err := d.DecodeUint64()
- return uint(n), err
-}
-
-func (d *Decoder) DecodeUint8() (uint8, error) {
- n, err := d.DecodeUint64()
- return uint8(n), err
-}
-
-func (d *Decoder) DecodeUint16() (uint16, error) {
- n, err := d.DecodeUint64()
- return uint16(n), err
-}
-
-func (d *Decoder) DecodeUint32() (uint32, error) {
- n, err := d.DecodeUint64()
- return uint32(n), err
-}
-
-func (d *Decoder) DecodeInt() (int, error) {
- n, err := d.DecodeInt64()
- return int(n), err
-}
-
-func (d *Decoder) DecodeInt8() (int8, error) {
- n, err := d.DecodeInt64()
- return int8(n), err
-}
-
-func (d *Decoder) DecodeInt16() (int16, error) {
- n, err := d.DecodeInt64()
- return int16(n), err
-}
-
-func (d *Decoder) DecodeInt32() (int32, error) {
- n, err := d.DecodeInt64()
- return int32(n), err
-}
-
-func decodeFloat32Value(d *Decoder, v reflect.Value) error {
- f, err := d.DecodeFloat32()
- if err != nil {
- return err
- }
- v.SetFloat(float64(f))
- return nil
-}
-
-func decodeFloat64Value(d *Decoder, v reflect.Value) error {
- f, err := d.DecodeFloat64()
- if err != nil {
- return err
- }
- v.SetFloat(f)
- return nil
-}
-
-func decodeInt64Value(d *Decoder, v reflect.Value) error {
- n, err := d.DecodeInt64()
- if err != nil {
- return err
- }
- v.SetInt(n)
- return nil
-}
-
-func decodeUint64Value(d *Decoder, v reflect.Value) error {
- n, err := d.DecodeUint64()
- if err != nil {
- return err
- }
- v.SetUint(n)
- return nil
-}
diff --git a/vendor/github.com/vmihailenco/msgpack/v5/decode_query.go b/vendor/github.com/vmihailenco/msgpack/v5/decode_query.go
deleted file mode 100644
index 4dce0fe5b..000000000
--- a/vendor/github.com/vmihailenco/msgpack/v5/decode_query.go
+++ /dev/null
@@ -1,157 +0,0 @@
-package msgpack
-
-import (
- "fmt"
- "strconv"
- "strings"
-
- "github.com/vmihailenco/msgpack/v5/msgpcode"
-)
-
-type queryResult struct {
- query string
- key string
- values []interface{}
- hasAsterisk bool
-}
-
-func (q *queryResult) nextKey() {
- ind := strings.IndexByte(q.query, '.')
- if ind == -1 {
- q.key = q.query
- q.query = ""
- return
- }
- q.key = q.query[:ind]
- q.query = q.query[ind+1:]
-}
-
-// Query extracts data specified by the query from the msgpack stream skipping
-// any other data. Query consists of map keys and array indexes separated with dot,
-// e.g. key1.0.key2.
-func (d *Decoder) Query(query string) ([]interface{}, error) {
- res := queryResult{
- query: query,
- }
- if err := d.query(&res); err != nil {
- return nil, err
- }
- return res.values, nil
-}
-
-func (d *Decoder) query(q *queryResult) error {
- q.nextKey()
- if q.key == "" {
- v, err := d.decodeInterfaceCond()
- if err != nil {
- return err
- }
- q.values = append(q.values, v)
- return nil
- }
-
- code, err := d.PeekCode()
- if err != nil {
- return err
- }
-
- switch {
- case code == msgpcode.Map16 || code == msgpcode.Map32 || msgpcode.IsFixedMap(code):
- err = d.queryMapKey(q)
- case code == msgpcode.Array16 || code == msgpcode.Array32 || msgpcode.IsFixedArray(code):
- err = d.queryArrayIndex(q)
- default:
- err = fmt.Errorf("msgpack: unsupported code=%x decoding key=%q", code, q.key)
- }
- return err
-}
-
-func (d *Decoder) queryMapKey(q *queryResult) error {
- n, err := d.DecodeMapLen()
- if err != nil {
- return err
- }
- if n == -1 {
- return nil
- }
-
- for i := 0; i < n; i++ {
- key, err := d.decodeStringTemp()
- if err != nil {
- return err
- }
-
- if key == q.key {
- if err := d.query(q); err != nil {
- return err
- }
- if q.hasAsterisk {
- return d.skipNext((n - i - 1) * 2)
- }
- return nil
- }
-
- if err := d.Skip(); err != nil {
- return err
- }
- }
-
- return nil
-}
-
-func (d *Decoder) queryArrayIndex(q *queryResult) error {
- n, err := d.DecodeArrayLen()
- if err != nil {
- return err
- }
- if n == -1 {
- return nil
- }
-
- if q.key == "*" {
- q.hasAsterisk = true
-
- query := q.query
- for i := 0; i < n; i++ {
- q.query = query
- if err := d.query(q); err != nil {
- return err
- }
- }
-
- q.hasAsterisk = false
- return nil
- }
-
- ind, err := strconv.Atoi(q.key)
- if err != nil {
- return err
- }
-
- for i := 0; i < n; i++ {
- if i == ind {
- if err := d.query(q); err != nil {
- return err
- }
- if q.hasAsterisk {
- return d.skipNext(n - i - 1)
- }
- return nil
- }
-
- if err := d.Skip(); err != nil {
- return err
- }
- }
-
- return nil
-}
-
-func (d *Decoder) skipNext(n int) error {
- for i := 0; i < n; i++ {
- if err := d.Skip(); err != nil {
- return err
- }
- }
- return nil
-}
diff --git a/vendor/github.com/vmihailenco/msgpack/v5/decode_slice.go b/vendor/github.com/vmihailenco/msgpack/v5/decode_slice.go
deleted file mode 100644
index 9c155f2ba..000000000
--- a/vendor/github.com/vmihailenco/msgpack/v5/decode_slice.go
+++ /dev/null
@@ -1,198 +0,0 @@
-package msgpack
-
-import (
- "fmt"
- "reflect"
-
- "github.com/vmihailenco/msgpack/v5/msgpcode"
-)
-
-var sliceStringPtrType = reflect.TypeOf((*[]string)(nil))
-
-// DecodeArrayLen decodes array length. Length is -1 when array is nil.
-func (d *Decoder) DecodeArrayLen() (int, error) {
- c, err := d.readCode()
- if err != nil {
- return 0, err
- }
- return d.arrayLen(c)
-}
-
-func (d *Decoder) arrayLen(c byte) (int, error) {
- if c == msgpcode.Nil {
- return -1, nil
- } else if c >= msgpcode.FixedArrayLow && c <= msgpcode.FixedArrayHigh {
- return int(c & msgpcode.FixedArrayMask), nil
- }
- switch c {
- case msgpcode.Array16:
- n, err := d.uint16()
- return int(n), err
- case msgpcode.Array32:
- n, err := d.uint32()
- return int(n), err
- }
- return 0, fmt.Errorf("msgpack: invalid code=%x decoding array length", c)
-}
-
-func decodeStringSliceValue(d *Decoder, v reflect.Value) error {
- ptr := v.Addr().Convert(sliceStringPtrType).Interface().(*[]string)
- return d.decodeStringSlicePtr(ptr)
-}
-
-func (d *Decoder) decodeStringSlicePtr(ptr *[]string) error {
- n, err := d.DecodeArrayLen()
- if err != nil {
- return err
- }
- if n == -1 {
- return nil
- }
-
- ss := makeStrings(*ptr, n, d.flags&disableAllocLimitFlag != 0)
- for i := 0; i < n; i++ {
- s, err := d.DecodeString()
- if err != nil {
- return err
- }
- ss = append(ss, s)
- }
- *ptr = ss
-
- return nil
-}
-
-func makeStrings(s []string, n int, noLimit bool) []string {
- if !noLimit && n > sliceAllocLimit {
- n = sliceAllocLimit
- }
-
- if s == nil {
- return make([]string, 0, n)
- }
-
- if cap(s) >= n {
- return s[:0]
- }
-
- s = s[:cap(s)]
- s = append(s, make([]string, n-len(s))...)
- return s[:0]
-}
-
-func decodeSliceValue(d *Decoder, v reflect.Value) error {
- n, err := d.DecodeArrayLen()
- if err != nil {
- return err
- }
-
- if n == -1 {
- v.Set(reflect.Zero(v.Type()))
- return nil
- }
- if n == 0 && v.IsNil() {
- v.Set(reflect.MakeSlice(v.Type(), 0, 0))
- return nil
- }
-
- if v.Cap() >= n {
- v.Set(v.Slice(0, n))
- } else if v.Len() < v.Cap() {
- v.Set(v.Slice(0, v.Cap()))
- }
-
- noLimit := d.flags&disableAllocLimitFlag != 1
-
- if noLimit && n > v.Len() {
- v.Set(growSliceValue(v, n, noLimit))
- }
-
- for i := 0; i < n; i++ {
- if !noLimit && i >= v.Len() {
- v.Set(growSliceValue(v, n, noLimit))
- }
-
- elem := v.Index(i)
- if err := d.DecodeValue(elem); err != nil {
- return err
- }
- }
-
- return nil
-}
-
-func growSliceValue(v reflect.Value, n int, noLimit bool) reflect.Value {
- diff := n - v.Len()
- if !noLimit && diff > sliceAllocLimit {
- diff = sliceAllocLimit
- }
- v = reflect.AppendSlice(v, reflect.MakeSlice(v.Type(), diff, diff))
- return v
-}
-
-func decodeArrayValue(d *Decoder, v reflect.Value) error {
- n, err := d.DecodeArrayLen()
- if err != nil {
- return err
- }
-
- if n == -1 {
- return nil
- }
- if n > v.Len() {
- return fmt.Errorf("%s len is %d, but msgpack has %d elements", v.Type(), v.Len(), n)
- }
-
- for i := 0; i < n; i++ {
- sv := v.Index(i)
- if err := d.DecodeValue(sv); err != nil {
- return err
- }
- }
-
- return nil
-}
-
-func (d *Decoder) DecodeSlice() ([]interface{}, error) {
- c, err := d.readCode()
- if err != nil {
- return nil, err
- }
- return d.decodeSlice(c)
-}
-
-func (d *Decoder) decodeSlice(c byte) ([]interface{}, error) {
- n, err := d.arrayLen(c)
- if err != nil {
- return nil, err
- }
- if n == -1 {
- return nil, nil
- }
-
- s := make([]interface{}, 0, n)
- for i := 0; i < n; i++ {
- v, err := d.decodeInterfaceCond()
- if err != nil {
- return nil, err
- }
- s = append(s, v)
- }
-
- return s, nil
-}
-
-func (d *Decoder) skipSlice(c byte) error {
- n, err := d.arrayLen(c)
- if err != nil {
- return err
- }
-
- for i := 0; i < n; i++ {
- if err := d.Skip(); err != nil {
- return err
- }
- }
-
- return nil
-}
diff --git a/vendor/github.com/vmihailenco/msgpack/v5/decode_string.go b/vendor/github.com/vmihailenco/msgpack/v5/decode_string.go
deleted file mode 100644
index e837e08bf..000000000
--- a/vendor/github.com/vmihailenco/msgpack/v5/decode_string.go
+++ /dev/null
@@ -1,192 +0,0 @@
-package msgpack
-
-import (
- "fmt"
- "reflect"
-
- "github.com/vmihailenco/msgpack/v5/msgpcode"
-)
-
-func (d *Decoder) bytesLen(c byte) (int, error) {
- if c == msgpcode.Nil {
- return -1, nil
- }
-
- if msgpcode.IsFixedString(c) {
- return int(c & msgpcode.FixedStrMask), nil
- }
-
- switch c {
- case msgpcode.Str8, msgpcode.Bin8:
- n, err := d.uint8()
- return int(n), err
- case msgpcode.Str16, msgpcode.Bin16:
- n, err := d.uint16()
- return int(n), err
- case msgpcode.Str32, msgpcode.Bin32:
- n, err := d.uint32()
- return int(n), err
- }
-
- return 0, fmt.Errorf("msgpack: invalid code=%x decoding string/bytes length", c)
-}
-
-func (d *Decoder) DecodeString() (string, error) {
- if intern := d.flags&useInternedStringsFlag != 0; intern || len(d.dict) > 0 {
- return d.decodeInternedString(intern)
- }
-
- c, err := d.readCode()
- if err != nil {
- return "", err
- }
- return d.string(c)
-}
-
-func (d *Decoder) string(c byte) (string, error) {
- n, err := d.bytesLen(c)
- if err != nil {
- return "", err
- }
- return d.stringWithLen(n)
-}
-
-func (d *Decoder) stringWithLen(n int) (string, error) {
- if n <= 0 {
- return "", nil
- }
- b, err := d.readN(n)
- return string(b), err
-}
-
-func decodeStringValue(d *Decoder, v reflect.Value) error {
- s, err := d.DecodeString()
- if err != nil {
- return err
- }
- v.SetString(s)
- return nil
-}
-
-func (d *Decoder) DecodeBytesLen() (int, error) {
- c, err := d.readCode()
- if err != nil {
- return 0, err
- }
- return d.bytesLen(c)
-}
-
-func (d *Decoder) DecodeBytes() ([]byte, error) {
- c, err := d.readCode()
- if err != nil {
- return nil, err
- }
- return d.bytes(c, nil)
-}
-
-func (d *Decoder) bytes(c byte, b []byte) ([]byte, error) {
- n, err := d.bytesLen(c)
- if err != nil {
- return nil, err
- }
- if n == -1 {
- return nil, nil
- }
- return readN(d.r, b, n)
-}
-
-func (d *Decoder) decodeStringTemp() (string, error) {
- if intern := d.flags&useInternedStringsFlag != 0; intern || len(d.dict) > 0 {
- return d.decodeInternedString(intern)
- }
-
- c, err := d.readCode()
- if err != nil {
- return "", err
- }
-
- n, err := d.bytesLen(c)
- if err != nil {
- return "", err
- }
- if n == -1 {
- return "", nil
- }
-
- b, err := d.readN(n)
- if err != nil {
- return "", err
- }
-
- return bytesToString(b), nil
-}
-
-func (d *Decoder) decodeBytesPtr(ptr *[]byte) error {
- c, err := d.readCode()
- if err != nil {
- return err
- }
- return d.bytesPtr(c, ptr)
-}
-
-func (d *Decoder) bytesPtr(c byte, ptr *[]byte) error {
- n, err := d.bytesLen(c)
- if err != nil {
- return err
- }
- if n == -1 {
- *ptr = nil
- return nil
- }
-
- *ptr, err = readN(d.r, *ptr, n)
- return err
-}
-
-func (d *Decoder) skipBytes(c byte) error {
- n, err := d.bytesLen(c)
- if err != nil {
- return err
- }
- if n <= 0 {
- return nil
- }
- return d.skipN(n)
-}
-
-func decodeBytesValue(d *Decoder, v reflect.Value) error {
- c, err := d.readCode()
- if err != nil {
- return err
- }
-
- b, err := d.bytes(c, v.Bytes())
- if err != nil {
- return err
- }
-
- v.SetBytes(b)
-
- return nil
-}
-
-func decodeByteArrayValue(d *Decoder, v reflect.Value) error {
- c, err := d.readCode()
- if err != nil {
- return err
- }
-
- n, err := d.bytesLen(c)
- if err != nil {
- return err
- }
- if n == -1 {
- return nil
- }
- if n > v.Len() {
- return fmt.Errorf("%s len is %d, but msgpack has %d elements", v.Type(), v.Len(), n)
- }
-
- b := v.Slice(0, n).Bytes()
- return d.readFull(b)
-}
diff --git a/vendor/github.com/vmihailenco/msgpack/v5/decode_typgen.go b/vendor/github.com/vmihailenco/msgpack/v5/decode_typgen.go
deleted file mode 100644
index 0b4c1d04a..000000000
--- a/vendor/github.com/vmihailenco/msgpack/v5/decode_typgen.go
+++ /dev/null
@@ -1,46 +0,0 @@
-package msgpack
-
-import (
- "reflect"
- "sync"
-)
-
-var cachedValues struct {
- m map[reflect.Type]chan reflect.Value
- sync.RWMutex
-}
-
-func cachedValue(t reflect.Type) reflect.Value {
- cachedValues.RLock()
- ch := cachedValues.m[t]
- cachedValues.RUnlock()
- if ch != nil {
- return <-ch
- }
-
- cachedValues.Lock()
- defer cachedValues.Unlock()
- if ch = cachedValues.m[t]; ch != nil {
- return <-ch
- }
-
- ch = make(chan reflect.Value, 256)
- go func() {
- for {
- ch <- reflect.New(t)
- }
- }()
- if cachedValues.m == nil {
- cachedValues.m = make(map[reflect.Type]chan reflect.Value, 8)
- }
- cachedValues.m[t] = ch
- return <-ch
-}
-
-func (d *Decoder) newValue(t reflect.Type) reflect.Value {
- if d.flags&usePreallocateValues == 0 {
- return reflect.New(t)
- }
-
- return cachedValue(t)
-}
diff --git a/vendor/github.com/vmihailenco/msgpack/v5/decode_value.go b/vendor/github.com/vmihailenco/msgpack/v5/decode_value.go
deleted file mode 100644
index c44a674e5..000000000
--- a/vendor/github.com/vmihailenco/msgpack/v5/decode_value.go
+++ /dev/null
@@ -1,251 +0,0 @@
-package msgpack
-
-import (
- "encoding"
- "errors"
- "fmt"
- "reflect"
-)
-
-var (
- interfaceType = reflect.TypeOf((*interface{})(nil)).Elem()
- stringType = reflect.TypeOf((*string)(nil)).Elem()
- boolType = reflect.TypeOf((*bool)(nil)).Elem()
-)
-
-var valueDecoders []decoderFunc
-
-//nolint:gochecknoinits
-func init() {
- valueDecoders = []decoderFunc{
- reflect.Bool: decodeBoolValue,
- reflect.Int: decodeInt64Value,
- reflect.Int8: decodeInt64Value,
- reflect.Int16: decodeInt64Value,
- reflect.Int32: decodeInt64Value,
- reflect.Int64: decodeInt64Value,
- reflect.Uint: decodeUint64Value,
- reflect.Uint8: decodeUint64Value,
- reflect.Uint16: decodeUint64Value,
- reflect.Uint32: decodeUint64Value,
- reflect.Uint64: decodeUint64Value,
- reflect.Float32: decodeFloat32Value,
- reflect.Float64: decodeFloat64Value,
- reflect.Complex64: decodeUnsupportedValue,
- reflect.Complex128: decodeUnsupportedValue,
- reflect.Array: decodeArrayValue,
- reflect.Chan: decodeUnsupportedValue,
- reflect.Func: decodeUnsupportedValue,
- reflect.Interface: decodeInterfaceValue,
- reflect.Map: decodeMapValue,
- reflect.Ptr: decodeUnsupportedValue,
- reflect.Slice: decodeSliceValue,
- reflect.String: decodeStringValue,
- reflect.Struct: decodeStructValue,
- reflect.UnsafePointer: decodeUnsupportedValue,
- }
-}
-
-func getDecoder(typ reflect.Type) decoderFunc {
- if v, ok := typeDecMap.Load(typ); ok {
- return v.(decoderFunc)
- }
- fn := _getDecoder(typ)
- typeDecMap.Store(typ, fn)
- return fn
-}
-
-func _getDecoder(typ reflect.Type) decoderFunc {
- kind := typ.Kind()
-
- if kind == reflect.Ptr {
- if _, ok := typeDecMap.Load(typ.Elem()); ok {
- return ptrValueDecoder(typ)
- }
- }
-
- if typ.Implements(customDecoderType) {
- return nilAwareDecoder(typ, decodeCustomValue)
- }
- if typ.Implements(unmarshalerType) {
- return nilAwareDecoder(typ, unmarshalValue)
- }
- if typ.Implements(binaryUnmarshalerType) {
- return nilAwareDecoder(typ, unmarshalBinaryValue)
- }
- if typ.Implements(textUnmarshalerType) {
- return nilAwareDecoder(typ, unmarshalTextValue)
- }
-
- // Addressable struct field value.
- if kind != reflect.Ptr {
- ptr := reflect.PtrTo(typ)
- if ptr.Implements(customDecoderType) {
- return addrDecoder(nilAwareDecoder(typ, decodeCustomValue))
- }
- if ptr.Implements(unmarshalerType) {
- return addrDecoder(nilAwareDecoder(typ, unmarshalValue))
- }
- if ptr.Implements(binaryUnmarshalerType) {
- return addrDecoder(nilAwareDecoder(typ, unmarshalBinaryValue))
- }
- if ptr.Implements(textUnmarshalerType) {
- return addrDecoder(nilAwareDecoder(typ, unmarshalTextValue))
- }
- }
-
- switch kind {
- case reflect.Ptr:
- return ptrValueDecoder(typ)
- case reflect.Slice:
- elem := typ.Elem()
- if elem.Kind() == reflect.Uint8 {
- return decodeBytesValue
- }
- if elem == stringType {
- return decodeStringSliceValue
- }
- case reflect.Array:
- if typ.Elem().Kind() == reflect.Uint8 {
- return decodeByteArrayValue
- }
- case reflect.Map:
- if typ.Key() == stringType {
- switch typ.Elem() {
- case stringType:
- return decodeMapStringStringValue
- case interfaceType:
- return decodeMapStringInterfaceValue
- }
- }
- }
-
- return valueDecoders[kind]
-}
-
-func ptrValueDecoder(typ reflect.Type) decoderFunc {
- decoder := getDecoder(typ.Elem())
- return func(d *Decoder, v reflect.Value) error {
- if d.hasNilCode() {
- if !v.IsNil() {
- v.Set(d.newValue(typ).Elem())
- }
- return d.DecodeNil()
- }
- if v.IsNil() {
- v.Set(d.newValue(typ.Elem()))
- }
- return decoder(d, v.Elem())
- }
-}
-
-func addrDecoder(fn decoderFunc) decoderFunc {
- return func(d *Decoder, v reflect.Value) error {
- if !v.CanAddr() {
- return fmt.Errorf("msgpack: Decode(nonaddressable %T)", v.Interface())
- }
- return fn(d, v.Addr())
- }
-}
-
-func nilAwareDecoder(typ reflect.Type, fn decoderFunc) decoderFunc {
- if nilable(typ.Kind()) {
- return func(d *Decoder, v reflect.Value) error {
- if d.hasNilCode() {
- return d.decodeNilValue(v)
- }
- if v.IsNil() {
- v.Set(d.newValue(typ.Elem()))
- }
- return fn(d, v)
- }
- }
-
- return func(d *Decoder, v reflect.Value) error {
- if d.hasNilCode() {
- return d.decodeNilValue(v)
- }
- return fn(d, v)
- }
-}
-
-func decodeBoolValue(d *Decoder, v reflect.Value) error {
- flag, err := d.DecodeBool()
- if err != nil {
- return err
- }
- v.SetBool(flag)
- return nil
-}
-
-func decodeInterfaceValue(d *Decoder, v reflect.Value) error {
- if v.IsNil() {
- return d.interfaceValue(v)
- }
- return d.DecodeValue(v.Elem())
-}
-
-func (d *Decoder) interfaceValue(v reflect.Value) error {
- vv, err := d.decodeInterfaceCond()
- if err != nil {
- return err
- }
-
- if vv != nil {
- if v.Type() == errorType {
- if vv, ok := vv.(string); ok {
- v.Set(reflect.ValueOf(errors.New(vv)))
- return nil
- }
- }
-
- v.Set(reflect.ValueOf(vv))
- }
-
- return nil
-}
-
-func decodeUnsupportedValue(d *Decoder, v reflect.Value) error {
- return fmt.Errorf("msgpack: Decode(unsupported %s)", v.Type())
-}
-
-//------------------------------------------------------------------------------
-
-func decodeCustomValue(d *Decoder, v reflect.Value) error {
- decoder := v.Interface().(CustomDecoder)
- return decoder.DecodeMsgpack(d)
-}
-
-func unmarshalValue(d *Decoder, v reflect.Value) error {
- var b []byte
-
- d.rec = make([]byte, 0, 64)
- if err := d.Skip(); err != nil {
- return err
- }
- b = d.rec
- d.rec = nil
-
- unmarshaler := v.Interface().(Unmarshaler)
- return unmarshaler.UnmarshalMsgpack(b)
-}
-
-func unmarshalBinaryValue(d *Decoder, v reflect.Value) error {
- data, err := d.DecodeBytes()
- if err != nil {
- return err
- }
-
- unmarshaler := v.Interface().(encoding.BinaryUnmarshaler)
- return unmarshaler.UnmarshalBinary(data)
-}
-
-func unmarshalTextValue(d *Decoder, v reflect.Value) error {
- data, err := d.DecodeBytes()
- if err != nil {
- return err
- }
-
- unmarshaler := v.Interface().(encoding.TextUnmarshaler)
- return unmarshaler.UnmarshalText(data)
-}
diff --git a/vendor/github.com/vmihailenco/msgpack/v5/encode.go b/vendor/github.com/vmihailenco/msgpack/v5/encode.go
deleted file mode 100644
index 135adc8f3..000000000
--- a/vendor/github.com/vmihailenco/msgpack/v5/encode.go
+++ /dev/null
@@ -1,270 +0,0 @@
-package msgpack
-
-import (
- "bytes"
- "io"
- "reflect"
- "sync"
- "time"
-
- "github.com/vmihailenco/msgpack/v5/msgpcode"
-)
-
-const (
- sortMapKeysFlag uint32 = 1 << iota
- arrayEncodedStructsFlag
- useCompactIntsFlag
- useCompactFloatsFlag
- useInternedStringsFlag
- omitEmptyFlag
-)
-
-type writer interface {
- io.Writer
- WriteByte(byte) error
-}
-
-type byteWriter struct {
- io.Writer
-}
-
-func newByteWriter(w io.Writer) byteWriter {
- return byteWriter{
- Writer: w,
- }
-}
-
-func (bw byteWriter) WriteByte(c byte) error {
- _, err := bw.Write([]byte{c})
- return err
-}
-
-//------------------------------------------------------------------------------
-
-var encPool = sync.Pool{
- New: func() interface{} {
- return NewEncoder(nil)
- },
-}
-
-func GetEncoder() *Encoder {
- return encPool.Get().(*Encoder)
-}
-
-func PutEncoder(enc *Encoder) {
- enc.w = nil
- encPool.Put(enc)
-}
-
-// Marshal returns the MessagePack encoding of v.
-func Marshal(v interface{}) ([]byte, error) {
- enc := GetEncoder()
-
- var buf bytes.Buffer
- enc.Reset(&buf)
-
- err := enc.Encode(v)
- b := buf.Bytes()
-
- PutEncoder(enc)
-
- if err != nil {
- return nil, err
- }
- return b, err
-}
-
-type Encoder struct {
- w writer
- dict map[string]int
- structTag string
- buf []byte
- timeBuf []byte
- flags uint32
-}
-
-// NewEncoder returns a new encoder that writes to w.
-func NewEncoder(w io.Writer) *Encoder {
- e := &Encoder{
- buf: make([]byte, 9),
- }
- e.Reset(w)
- return e
-}
-
-// Writer returns the Encoder's writer.
-func (e *Encoder) Writer() io.Writer {
- return e.w
-}
-
-// Reset discards any buffered data, resets all state, and switches the writer to write to w.
-func (e *Encoder) Reset(w io.Writer) {
- e.ResetDict(w, nil)
-}
-
-// ResetDict is like Reset, but also resets the dict.
-func (e *Encoder) ResetDict(w io.Writer, dict map[string]int) {
- e.ResetWriter(w)
- e.flags = 0
- e.structTag = ""
- e.dict = dict
-}
-
-func (e *Encoder) WithDict(dict map[string]int, fn func(*Encoder) error) error {
- oldDict := e.dict
- e.dict = dict
- err := fn(e)
- e.dict = oldDict
- return err
-}
-
-func (e *Encoder) ResetWriter(w io.Writer) {
- e.dict = nil
- if bw, ok := w.(writer); ok {
- e.w = bw
- } else if w == nil {
- e.w = nil
- } else {
- e.w = newByteWriter(w)
- }
-}
-
-// SetSortMapKeys causes the Encoder to encode map keys in increasing order.
-// Supported map types are:
-// - map[string]string
-// - map[string]bool
-// - map[string]interface{}
-func (e *Encoder) SetSortMapKeys(on bool) *Encoder {
- if on {
- e.flags |= sortMapKeysFlag
- } else {
- e.flags &= ^sortMapKeysFlag
- }
- return e
-}
-
-// SetCustomStructTag causes the Encoder to use a custom struct tag as
-// fallback option if there is no msgpack tag.
-func (e *Encoder) SetCustomStructTag(tag string) {
- e.structTag = tag
-}
-
-// SetOmitEmpty causes the Encoder to omit empty values by default.
-func (e *Encoder) SetOmitEmpty(on bool) {
- if on {
- e.flags |= omitEmptyFlag
- } else {
- e.flags &= ^omitEmptyFlag
- }
-}
-
-// UseArrayEncodedStructs causes the Encoder to encode Go structs as msgpack arrays.
-func (e *Encoder) UseArrayEncodedStructs(on bool) {
- if on {
- e.flags |= arrayEncodedStructsFlag
- } else {
- e.flags &= ^arrayEncodedStructsFlag
- }
-}
-
-// UseCompactEncoding causes the Encoder to chose the most compact encoding.
-// For example, it allows to encode small Go int64 as msgpack int8 saving 7 bytes.
-func (e *Encoder) UseCompactInts(on bool) {
- if on {
- e.flags |= useCompactIntsFlag
- } else {
- e.flags &= ^useCompactIntsFlag
- }
-}
-
-// UseCompactFloats causes the Encoder to chose a compact integer encoding
-// for floats that can be represented as integers.
-func (e *Encoder) UseCompactFloats(on bool) {
- if on {
- e.flags |= useCompactFloatsFlag
- } else {
- e.flags &= ^useCompactFloatsFlag
- }
-}
-
-// UseInternedStrings causes the Encoder to intern strings.
-func (e *Encoder) UseInternedStrings(on bool) {
- if on {
- e.flags |= useInternedStringsFlag
- } else {
- e.flags &= ^useInternedStringsFlag
- }
-}
-
-func (e *Encoder) Encode(v interface{}) error {
- switch v := v.(type) {
- case nil:
- return e.EncodeNil()
- case string:
- return e.EncodeString(v)
- case []byte:
- return e.EncodeBytes(v)
- case int:
- return e.EncodeInt(int64(v))
- case int64:
- return e.encodeInt64Cond(v)
- case uint:
- return e.EncodeUint(uint64(v))
- case uint64:
- return e.encodeUint64Cond(v)
- case bool:
- return e.EncodeBool(v)
- case float32:
- return e.EncodeFloat32(v)
- case float64:
- return e.EncodeFloat64(v)
- case time.Duration:
- return e.encodeInt64Cond(int64(v))
- case time.Time:
- return e.EncodeTime(v)
- }
- return e.EncodeValue(reflect.ValueOf(v))
-}
-
-func (e *Encoder) EncodeMulti(v ...interface{}) error {
- for _, vv := range v {
- if err := e.Encode(vv); err != nil {
- return err
- }
- }
- return nil
-}
-
-func (e *Encoder) EncodeValue(v reflect.Value) error {
- fn := getEncoder(v.Type())
- return fn(e, v)
-}
-
-func (e *Encoder) EncodeNil() error {
- return e.writeCode(msgpcode.Nil)
-}
-
-func (e *Encoder) EncodeBool(value bool) error {
- if value {
- return e.writeCode(msgpcode.True)
- }
- return e.writeCode(msgpcode.False)
-}
-
-func (e *Encoder) EncodeDuration(d time.Duration) error {
- return e.EncodeInt(int64(d))
-}
-
-func (e *Encoder) writeCode(c byte) error {
- return e.w.WriteByte(c)
-}
-
-func (e *Encoder) write(b []byte) error {
- _, err := e.w.Write(b)
- return err
-}
-
-func (e *Encoder) writeString(s string) error {
- _, err := e.w.Write(stringToBytes(s))
- return err
-}
diff --git a/vendor/github.com/vmihailenco/msgpack/v5/encode_map.go b/vendor/github.com/vmihailenco/msgpack/v5/encode_map.go
deleted file mode 100644
index a5aa31bb3..000000000
--- a/vendor/github.com/vmihailenco/msgpack/v5/encode_map.go
+++ /dev/null
@@ -1,225 +0,0 @@
-package msgpack
-
-import (
- "math"
- "reflect"
- "sort"
-
- "github.com/vmihailenco/msgpack/v5/msgpcode"
-)
-
-func encodeMapValue(e *Encoder, v reflect.Value) error {
- if v.IsNil() {
- return e.EncodeNil()
- }
-
- if err := e.EncodeMapLen(v.Len()); err != nil {
- return err
- }
-
- iter := v.MapRange()
- for iter.Next() {
- if err := e.EncodeValue(iter.Key()); err != nil {
- return err
- }
- if err := e.EncodeValue(iter.Value()); err != nil {
- return err
- }
- }
-
- return nil
-}
-
-func encodeMapStringBoolValue(e *Encoder, v reflect.Value) error {
- if v.IsNil() {
- return e.EncodeNil()
- }
-
- if err := e.EncodeMapLen(v.Len()); err != nil {
- return err
- }
-
- m := v.Convert(mapStringBoolType).Interface().(map[string]bool)
- if e.flags&sortMapKeysFlag != 0 {
- return e.encodeSortedMapStringBool(m)
- }
-
- for mk, mv := range m {
- if err := e.EncodeString(mk); err != nil {
- return err
- }
- if err := e.EncodeBool(mv); err != nil {
- return err
- }
- }
-
- return nil
-}
-
-func encodeMapStringStringValue(e *Encoder, v reflect.Value) error {
- if v.IsNil() {
- return e.EncodeNil()
- }
-
- if err := e.EncodeMapLen(v.Len()); err != nil {
- return err
- }
-
- m := v.Convert(mapStringStringType).Interface().(map[string]string)
- if e.flags&sortMapKeysFlag != 0 {
- return e.encodeSortedMapStringString(m)
- }
-
- for mk, mv := range m {
- if err := e.EncodeString(mk); err != nil {
- return err
- }
- if err := e.EncodeString(mv); err != nil {
- return err
- }
- }
-
- return nil
-}
-
-func encodeMapStringInterfaceValue(e *Encoder, v reflect.Value) error {
- if v.IsNil() {
- return e.EncodeNil()
- }
- m := v.Convert(mapStringInterfaceType).Interface().(map[string]interface{})
- if e.flags&sortMapKeysFlag != 0 {
- return e.EncodeMapSorted(m)
- }
- return e.EncodeMap(m)
-}
-
-func (e *Encoder) EncodeMap(m map[string]interface{}) error {
- if m == nil {
- return e.EncodeNil()
- }
- if err := e.EncodeMapLen(len(m)); err != nil {
- return err
- }
- for mk, mv := range m {
- if err := e.EncodeString(mk); err != nil {
- return err
- }
- if err := e.Encode(mv); err != nil {
- return err
- }
- }
- return nil
-}
-
-func (e *Encoder) EncodeMapSorted(m map[string]interface{}) error {
- if m == nil {
- return e.EncodeNil()
- }
- if err := e.EncodeMapLen(len(m)); err != nil {
- return err
- }
-
- keys := make([]string, 0, len(m))
-
- for k := range m {
- keys = append(keys, k)
- }
-
- sort.Strings(keys)
-
- for _, k := range keys {
- if err := e.EncodeString(k); err != nil {
- return err
- }
- if err := e.Encode(m[k]); err != nil {
- return err
- }
- }
-
- return nil
-}
-
-func (e *Encoder) encodeSortedMapStringBool(m map[string]bool) error {
- keys := make([]string, 0, len(m))
- for k := range m {
- keys = append(keys, k)
- }
- sort.Strings(keys)
-
- for _, k := range keys {
- err := e.EncodeString(k)
- if err != nil {
- return err
- }
- if err = e.EncodeBool(m[k]); err != nil {
- return err
- }
- }
-
- return nil
-}
-
-func (e *Encoder) encodeSortedMapStringString(m map[string]string) error {
- keys := make([]string, 0, len(m))
- for k := range m {
- keys = append(keys, k)
- }
- sort.Strings(keys)
-
- for _, k := range keys {
- err := e.EncodeString(k)
- if err != nil {
- return err
- }
- if err = e.EncodeString(m[k]); err != nil {
- return err
- }
- }
-
- return nil
-}
-
-func (e *Encoder) EncodeMapLen(l int) error {
- if l < 16 {
- return e.writeCode(msgpcode.FixedMapLow | byte(l))
- }
- if l <= math.MaxUint16 {
- return e.write2(msgpcode.Map16, uint16(l))
- }
- return e.write4(msgpcode.Map32, uint32(l))
-}
-
-func encodeStructValue(e *Encoder, strct reflect.Value) error {
- structFields := structs.Fields(strct.Type(), e.structTag)
- if e.flags&arrayEncodedStructsFlag != 0 || structFields.AsArray {
- return encodeStructValueAsArray(e, strct, structFields.List)
- }
- fields := structFields.OmitEmpty(e, strct)
-
- if err := e.EncodeMapLen(len(fields)); err != nil {
- return err
- }
-
- for _, f := range fields {
- if err := e.EncodeString(f.name); err != nil {
- return err
- }
- if err := f.EncodeValue(e, strct); err != nil {
- return err
- }
- }
-
- return nil
-}
-
-func encodeStructValueAsArray(e *Encoder, strct reflect.Value, fields []*field) error {
- if err := e.EncodeArrayLen(len(fields)); err != nil {
- return err
- }
- for _, f := range fields {
- if err := f.EncodeValue(e, strct); err != nil {
- return err
- }
- }
- return nil
-}
diff --git a/vendor/github.com/vmihailenco/msgpack/v5/encode_number.go b/vendor/github.com/vmihailenco/msgpack/v5/encode_number.go
deleted file mode 100644
index 63c311bfa..000000000
--- a/vendor/github.com/vmihailenco/msgpack/v5/encode_number.go
+++ /dev/null
@@ -1,252 +0,0 @@
-package msgpack
-
-import (
- "math"
- "reflect"
-
- "github.com/vmihailenco/msgpack/v5/msgpcode"
-)
-
-// EncodeUint8 encodes an uint8 in 2 bytes preserving type of the number.
-func (e *Encoder) EncodeUint8(n uint8) error {
- return e.write1(msgpcode.Uint8, n)
-}
-
-func (e *Encoder) encodeUint8Cond(n uint8) error {
- if e.flags&useCompactIntsFlag != 0 {
- return e.EncodeUint(uint64(n))
- }
- return e.EncodeUint8(n)
-}
-
-// EncodeUint16 encodes an uint16 in 3 bytes preserving type of the number.
-func (e *Encoder) EncodeUint16(n uint16) error {
- return e.write2(msgpcode.Uint16, n)
-}
-
-func (e *Encoder) encodeUint16Cond(n uint16) error {
- if e.flags&useCompactIntsFlag != 0 {
- return e.EncodeUint(uint64(n))
- }
- return e.EncodeUint16(n)
-}
-
-// EncodeUint32 encodes an uint16 in 5 bytes preserving type of the number.
-func (e *Encoder) EncodeUint32(n uint32) error {
- return e.write4(msgpcode.Uint32, n)
-}
-
-func (e *Encoder) encodeUint32Cond(n uint32) error {
- if e.flags&useCompactIntsFlag != 0 {
- return e.EncodeUint(uint64(n))
- }
- return e.EncodeUint32(n)
-}
-
-// EncodeUint64 encodes an uint16 in 9 bytes preserving type of the number.
-func (e *Encoder) EncodeUint64(n uint64) error {
- return e.write8(msgpcode.Uint64, n)
-}
-
-func (e *Encoder) encodeUint64Cond(n uint64) error {
- if e.flags&useCompactIntsFlag != 0 {
- return e.EncodeUint(n)
- }
- return e.EncodeUint64(n)
-}
-
-// EncodeInt8 encodes an int8 in 2 bytes preserving type of the number.
-func (e *Encoder) EncodeInt8(n int8) error {
- return e.write1(msgpcode.Int8, uint8(n))
-}
-
-func (e *Encoder) encodeInt8Cond(n int8) error {
- if e.flags&useCompactIntsFlag != 0 {
- return e.EncodeInt(int64(n))
- }
- return e.EncodeInt8(n)
-}
-
-// EncodeInt16 encodes an int16 in 3 bytes preserving type of the number.
-func (e *Encoder) EncodeInt16(n int16) error {
- return e.write2(msgpcode.Int16, uint16(n))
-}
-
-func (e *Encoder) encodeInt16Cond(n int16) error {
- if e.flags&useCompactIntsFlag != 0 {
- return e.EncodeInt(int64(n))
- }
- return e.EncodeInt16(n)
-}
-
-// EncodeInt32 encodes an int32 in 5 bytes preserving type of the number.
-func (e *Encoder) EncodeInt32(n int32) error {
- return e.write4(msgpcode.Int32, uint32(n))
-}
-
-func (e *Encoder) encodeInt32Cond(n int32) error {
- if e.flags&useCompactIntsFlag != 0 {
- return e.EncodeInt(int64(n))
- }
- return e.EncodeInt32(n)
-}
-
-// EncodeInt64 encodes an int64 in 9 bytes preserving type of the number.
-func (e *Encoder) EncodeInt64(n int64) error {
- return e.write8(msgpcode.Int64, uint64(n))
-}
-
-func (e *Encoder) encodeInt64Cond(n int64) error {
- if e.flags&useCompactIntsFlag != 0 {
- return e.EncodeInt(n)
- }
- return e.EncodeInt64(n)
-}
-
-// EncodeUnsignedNumber encodes an uint64 in 1, 2, 3, 5, or 9 bytes.
-// Type of the number is lost during encoding.
-func (e *Encoder) EncodeUint(n uint64) error {
- if n <= math.MaxInt8 {
- return e.w.WriteByte(byte(n))
- }
- if n <= math.MaxUint8 {
- return e.EncodeUint8(uint8(n))
- }
- if n <= math.MaxUint16 {
- return e.EncodeUint16(uint16(n))
- }
- if n <= math.MaxUint32 {
- return e.EncodeUint32(uint32(n))
- }
- return e.EncodeUint64(n)
-}
-
-// EncodeNumber encodes an int64 in 1, 2, 3, 5, or 9 bytes.
-// Type of the number is lost during encoding.
-func (e *Encoder) EncodeInt(n int64) error {
- if n >= 0 {
- return e.EncodeUint(uint64(n))
- }
- if n >= int64(int8(msgpcode.NegFixedNumLow)) {
- return e.w.WriteByte(byte(n))
- }
- if n >= math.MinInt8 {
- return e.EncodeInt8(int8(n))
- }
- if n >= math.MinInt16 {
- return e.EncodeInt16(int16(n))
- }
- if n >= math.MinInt32 {
- return e.EncodeInt32(int32(n))
- }
- return e.EncodeInt64(n)
-}
-
-func (e *Encoder) EncodeFloat32(n float32) error {
- if e.flags&useCompactFloatsFlag != 0 {
- if float32(int64(n)) == n {
- return e.EncodeInt(int64(n))
- }
- }
- return e.write4(msgpcode.Float, math.Float32bits(n))
-}
-
-func (e *Encoder) EncodeFloat64(n float64) error {
- if e.flags&useCompactFloatsFlag != 0 {
- // Both NaN and Inf convert to int64(-0x8000000000000000)
- // If n is NaN then it never compares true with any other value
- // If n is Inf then it doesn't convert from int64 back to +/-Inf
- // In both cases the comparison works.
- if float64(int64(n)) == n {
- return e.EncodeInt(int64(n))
- }
- }
- return e.write8(msgpcode.Double, math.Float64bits(n))
-}
-
-func (e *Encoder) write1(code byte, n uint8) error {
- e.buf = e.buf[:2]
- e.buf[0] = code
- e.buf[1] = n
- return e.write(e.buf)
-}
-
-func (e *Encoder) write2(code byte, n uint16) error {
- e.buf = e.buf[:3]
- e.buf[0] = code
- e.buf[1] = byte(n >> 8)
- e.buf[2] = byte(n)
- return e.write(e.buf)
-}
-
-func (e *Encoder) write4(code byte, n uint32) error {
- e.buf = e.buf[:5]
- e.buf[0] = code
- e.buf[1] = byte(n >> 24)
- e.buf[2] = byte(n >> 16)
- e.buf[3] = byte(n >> 8)
- e.buf[4] = byte(n)
- return e.write(e.buf)
-}
-
-func (e *Encoder) write8(code byte, n uint64) error {
- e.buf = e.buf[:9]
- e.buf[0] = code
- e.buf[1] = byte(n >> 56)
- e.buf[2] = byte(n >> 48)
- e.buf[3] = byte(n >> 40)
- e.buf[4] = byte(n >> 32)
- e.buf[5] = byte(n >> 24)
- e.buf[6] = byte(n >> 16)
- e.buf[7] = byte(n >> 8)
- e.buf[8] = byte(n)
- return e.write(e.buf)
-}
-
-func encodeUintValue(e *Encoder, v reflect.Value) error {
- return e.EncodeUint(v.Uint())
-}
-
-func encodeIntValue(e *Encoder, v reflect.Value) error {
- return e.EncodeInt(v.Int())
-}
-
-func encodeUint8CondValue(e *Encoder, v reflect.Value) error {
- return e.encodeUint8Cond(uint8(v.Uint()))
-}
-
-func encodeUint16CondValue(e *Encoder, v reflect.Value) error {
- return e.encodeUint16Cond(uint16(v.Uint()))
-}
-
-func encodeUint32CondValue(e *Encoder, v reflect.Value) error {
- return e.encodeUint32Cond(uint32(v.Uint()))
-}
-
-func encodeUint64CondValue(e *Encoder, v reflect.Value) error {
- return e.encodeUint64Cond(v.Uint())
-}
-
-func encodeInt8CondValue(e *Encoder, v reflect.Value) error {
- return e.encodeInt8Cond(int8(v.Int()))
-}
-
-func encodeInt16CondValue(e *Encoder, v reflect.Value) error {
- return e.encodeInt16Cond(int16(v.Int()))
-}
-
-func encodeInt32CondValue(e *Encoder, v reflect.Value) error {
- return e.encodeInt32Cond(int32(v.Int()))
-}
-
-func encodeInt64CondValue(e *Encoder, v reflect.Value) error {
- return e.encodeInt64Cond(v.Int())
-}
-
-func encodeFloat32Value(e *Encoder, v reflect.Value) error {
- return e.EncodeFloat32(float32(v.Float()))
-}
-
-func encodeFloat64Value(e *Encoder, v reflect.Value) error {
- return e.EncodeFloat64(v.Float())
-}
diff --git a/vendor/github.com/vmihailenco/msgpack/v5/encode_slice.go b/vendor/github.com/vmihailenco/msgpack/v5/encode_slice.go
deleted file mode 100644
index ca46eadae..000000000
--- a/vendor/github.com/vmihailenco/msgpack/v5/encode_slice.go
+++ /dev/null
@@ -1,139 +0,0 @@
-package msgpack
-
-import (
- "math"
- "reflect"
-
- "github.com/vmihailenco/msgpack/v5/msgpcode"
-)
-
-var stringSliceType = reflect.TypeOf(([]string)(nil))
-
-func encodeStringValue(e *Encoder, v reflect.Value) error {
- return e.EncodeString(v.String())
-}
-
-func encodeByteSliceValue(e *Encoder, v reflect.Value) error {
- return e.EncodeBytes(v.Bytes())
-}
-
-func encodeByteArrayValue(e *Encoder, v reflect.Value) error {
- if err := e.EncodeBytesLen(v.Len()); err != nil {
- return err
- }
-
- if v.CanAddr() {
- b := v.Slice(0, v.Len()).Bytes()
- return e.write(b)
- }
-
- e.buf = grow(e.buf, v.Len())
- reflect.Copy(reflect.ValueOf(e.buf), v)
- return e.write(e.buf)
-}
-
-func grow(b []byte, n int) []byte {
- if cap(b) >= n {
- return b[:n]
- }
- b = b[:cap(b)]
- b = append(b, make([]byte, n-len(b))...)
- return b
-}
-
-func (e *Encoder) EncodeBytesLen(l int) error {
- if l < 256 {
- return e.write1(msgpcode.Bin8, uint8(l))
- }
- if l <= math.MaxUint16 {
- return e.write2(msgpcode.Bin16, uint16(l))
- }
- return e.write4(msgpcode.Bin32, uint32(l))
-}
-
-func (e *Encoder) encodeStringLen(l int) error {
- if l < 32 {
- return e.writeCode(msgpcode.FixedStrLow | byte(l))
- }
- if l < 256 {
- return e.write1(msgpcode.Str8, uint8(l))
- }
- if l <= math.MaxUint16 {
- return e.write2(msgpcode.Str16, uint16(l))
- }
- return e.write4(msgpcode.Str32, uint32(l))
-}
-
-func (e *Encoder) EncodeString(v string) error {
- if intern := e.flags&useInternedStringsFlag != 0; intern || len(e.dict) > 0 {
- return e.encodeInternedString(v, intern)
- }
- return e.encodeNormalString(v)
-}
-
-func (e *Encoder) encodeNormalString(v string) error {
- if err := e.encodeStringLen(len(v)); err != nil {
- return err
- }
- return e.writeString(v)
-}
-
-func (e *Encoder) EncodeBytes(v []byte) error {
- if v == nil {
- return e.EncodeNil()
- }
- if err := e.EncodeBytesLen(len(v)); err != nil {
- return err
- }
- return e.write(v)
-}
-
-func (e *Encoder) EncodeArrayLen(l int) error {
- if l < 16 {
- return e.writeCode(msgpcode.FixedArrayLow | byte(l))
- }
- if l <= math.MaxUint16 {
- return e.write2(msgpcode.Array16, uint16(l))
- }
- return e.write4(msgpcode.Array32, uint32(l))
-}
-
-func encodeStringSliceValue(e *Encoder, v reflect.Value) error {
- ss := v.Convert(stringSliceType).Interface().([]string)
- return e.encodeStringSlice(ss)
-}
-
-func (e *Encoder) encodeStringSlice(s []string) error {
- if s == nil {
- return e.EncodeNil()
- }
- if err := e.EncodeArrayLen(len(s)); err != nil {
- return err
- }
- for _, v := range s {
- if err := e.EncodeString(v); err != nil {
- return err
- }
- }
- return nil
-}
-
-func encodeSliceValue(e *Encoder, v reflect.Value) error {
- if v.IsNil() {
- return e.EncodeNil()
- }
- return encodeArrayValue(e, v)
-}
-
-func encodeArrayValue(e *Encoder, v reflect.Value) error {
- l := v.Len()
- if err := e.EncodeArrayLen(l); err != nil {
- return err
- }
- for i := 0; i < l; i++ {
- if err := e.EncodeValue(v.Index(i)); err != nil {
- return err
- }
- }
- return nil
-}
diff --git a/vendor/github.com/vmihailenco/msgpack/v5/encode_value.go b/vendor/github.com/vmihailenco/msgpack/v5/encode_value.go
deleted file mode 100644
index 1d6303a25..000000000
--- a/vendor/github.com/vmihailenco/msgpack/v5/encode_value.go
+++ /dev/null
@@ -1,254 +0,0 @@
-package msgpack
-
-import (
- "encoding"
- "fmt"
- "reflect"
-)
-
-var valueEncoders []encoderFunc
-
-//nolint:gochecknoinits
-func init() {
- valueEncoders = []encoderFunc{
- reflect.Bool: encodeBoolValue,
- reflect.Int: encodeIntValue,
- reflect.Int8: encodeInt8CondValue,
- reflect.Int16: encodeInt16CondValue,
- reflect.Int32: encodeInt32CondValue,
- reflect.Int64: encodeInt64CondValue,
- reflect.Uint: encodeUintValue,
- reflect.Uint8: encodeUint8CondValue,
- reflect.Uint16: encodeUint16CondValue,
- reflect.Uint32: encodeUint32CondValue,
- reflect.Uint64: encodeUint64CondValue,
- reflect.Float32: encodeFloat32Value,
- reflect.Float64: encodeFloat64Value,
- reflect.Complex64: encodeUnsupportedValue,
- reflect.Complex128: encodeUnsupportedValue,
- reflect.Array: encodeArrayValue,
- reflect.Chan: encodeUnsupportedValue,
- reflect.Func: encodeUnsupportedValue,
- reflect.Interface: encodeInterfaceValue,
- reflect.Map: encodeMapValue,
- reflect.Ptr: encodeUnsupportedValue,
- reflect.Slice: encodeSliceValue,
- reflect.String: encodeStringValue,
- reflect.Struct: encodeStructValue,
- reflect.UnsafePointer: encodeUnsupportedValue,
- }
-}
-
-func getEncoder(typ reflect.Type) encoderFunc {
- if v, ok := typeEncMap.Load(typ); ok {
- return v.(encoderFunc)
- }
- fn := _getEncoder(typ)
- typeEncMap.Store(typ, fn)
- return fn
-}
-
-func _getEncoder(typ reflect.Type) encoderFunc {
- kind := typ.Kind()
-
- if kind == reflect.Ptr {
- if _, ok := typeEncMap.Load(typ.Elem()); ok {
- return ptrEncoderFunc(typ)
- }
- }
-
- if typ.Implements(customEncoderType) {
- return encodeCustomValue
- }
- if typ.Implements(marshalerType) {
- return marshalValue
- }
- if typ.Implements(binaryMarshalerType) {
- return marshalBinaryValue
- }
- if typ.Implements(textMarshalerType) {
- return marshalTextValue
- }
-
- // Addressable struct field value.
- if kind != reflect.Ptr {
- ptr := reflect.PtrTo(typ)
- if ptr.Implements(customEncoderType) {
- return encodeCustomValuePtr
- }
- if ptr.Implements(marshalerType) {
- return marshalValuePtr
- }
- if ptr.Implements(binaryMarshalerType) {
- return marshalBinaryValueAddr
- }
- if ptr.Implements(textMarshalerType) {
- return marshalTextValueAddr
- }
- }
-
- if typ == errorType {
- return encodeErrorValue
- }
-
- switch kind {
- case reflect.Ptr:
- return ptrEncoderFunc(typ)
- case reflect.Slice:
- elem := typ.Elem()
- if elem.Kind() == reflect.Uint8 {
- return encodeByteSliceValue
- }
- if elem == stringType {
- return encodeStringSliceValue
- }
- case reflect.Array:
- if typ.Elem().Kind() == reflect.Uint8 {
- return encodeByteArrayValue
- }
- case reflect.Map:
- if typ.Key() == stringType {
- switch typ.Elem() {
- case stringType:
- return encodeMapStringStringValue
- case boolType:
- return encodeMapStringBoolValue
- case interfaceType:
- return encodeMapStringInterfaceValue
- }
- }
- }
-
- return valueEncoders[kind]
-}
-
-func ptrEncoderFunc(typ reflect.Type) encoderFunc {
- encoder := getEncoder(typ.Elem())
- return func(e *Encoder, v reflect.Value) error {
- if v.IsNil() {
- return e.EncodeNil()
- }
- return encoder(e, v.Elem())
- }
-}
-
-func encodeCustomValuePtr(e *Encoder, v reflect.Value) error {
- if !v.CanAddr() {
- return fmt.Errorf("msgpack: Encode(non-addressable %T)", v.Interface())
- }
- encoder := v.Addr().Interface().(CustomEncoder)
- return encoder.EncodeMsgpack(e)
-}
-
-func encodeCustomValue(e *Encoder, v reflect.Value) error {
- if nilable(v.Kind()) && v.IsNil() {
- return e.EncodeNil()
- }
-
- encoder := v.Interface().(CustomEncoder)
- return encoder.EncodeMsgpack(e)
-}
-
-func marshalValuePtr(e *Encoder, v reflect.Value) error {
- if !v.CanAddr() {
- return fmt.Errorf("msgpack: Encode(non-addressable %T)", v.Interface())
- }
- return marshalValue(e, v.Addr())
-}
-
-func marshalValue(e *Encoder, v reflect.Value) error {
- if nilable(v.Kind()) && v.IsNil() {
- return e.EncodeNil()
- }
-
- marshaler := v.Interface().(Marshaler)
- b, err := marshaler.MarshalMsgpack()
- if err != nil {
- return err
- }
- _, err = e.w.Write(b)
- return err
-}
-
-func encodeBoolValue(e *Encoder, v reflect.Value) error {
- return e.EncodeBool(v.Bool())
-}
-
-func encodeInterfaceValue(e *Encoder, v reflect.Value) error {
- if v.IsNil() {
- return e.EncodeNil()
- }
- return e.EncodeValue(v.Elem())
-}
-
-func encodeErrorValue(e *Encoder, v reflect.Value) error {
- if v.IsNil() {
- return e.EncodeNil()
- }
- return e.EncodeString(v.Interface().(error).Error())
-}
-
-func encodeUnsupportedValue(e *Encoder, v reflect.Value) error {
- return fmt.Errorf("msgpack: Encode(unsupported %s)", v.Type())
-}
-
-func nilable(kind reflect.Kind) bool {
- switch kind {
- case reflect.Chan, reflect.Func, reflect.Interface, reflect.Map, reflect.Ptr, reflect.Slice:
- return true
- }
- return false
-}
-
-func nilableType(t reflect.Type) bool {
- if t.Kind() == reflect.Ptr {
- t = t.Elem()
- }
- return nilable(t.Kind())
-}
-
-//------------------------------------------------------------------------------
-
-func marshalBinaryValueAddr(e *Encoder, v reflect.Value) error {
- if !v.CanAddr() {
- return fmt.Errorf("msgpack: Encode(non-addressable %T)", v.Interface())
- }
- return marshalBinaryValue(e, v.Addr())
-}
-
-func marshalBinaryValue(e *Encoder, v reflect.Value) error {
- if nilable(v.Kind()) && v.IsNil() {
- return e.EncodeNil()
- }
-
- marshaler := v.Interface().(encoding.BinaryMarshaler)
- data, err := marshaler.MarshalBinary()
- if err != nil {
- return err
- }
-
- return e.EncodeBytes(data)
-}
-
-//------------------------------------------------------------------------------
-
-func marshalTextValueAddr(e *Encoder, v reflect.Value) error {
- if !v.CanAddr() {
- return fmt.Errorf("msgpack: Encode(non-addressable %T)", v.Interface())
- }
- return marshalTextValue(e, v.Addr())
-}
-
-func marshalTextValue(e *Encoder, v reflect.Value) error {
- if nilable(v.Kind()) && v.IsNil() {
- return e.EncodeNil()
- }
-
- marshaler := v.Interface().(encoding.TextMarshaler)
- data, err := marshaler.MarshalText()
- if err != nil {
- return err
- }
-
- return e.EncodeBytes(data)
-}
diff --git a/vendor/github.com/vmihailenco/msgpack/v5/ext.go b/vendor/github.com/vmihailenco/msgpack/v5/ext.go
deleted file mode 100644
index 354b9d92d..000000000
--- a/vendor/github.com/vmihailenco/msgpack/v5/ext.go
+++ /dev/null
@@ -1,303 +0,0 @@
-package msgpack
-
-import (
- "fmt"
- "math"
- "reflect"
-
- "github.com/vmihailenco/msgpack/v5/msgpcode"
-)
-
-type extInfo struct {
- Type reflect.Type
- Decoder func(d *Decoder, v reflect.Value, extLen int) error
-}
-
-var extTypes = make(map[int8]*extInfo)
-
-type MarshalerUnmarshaler interface {
- Marshaler
- Unmarshaler
-}
-
-func RegisterExt(extID int8, value MarshalerUnmarshaler) {
- RegisterExtEncoder(extID, value, func(e *Encoder, v reflect.Value) ([]byte, error) {
- marshaler := v.Interface().(Marshaler)
- return marshaler.MarshalMsgpack()
- })
- RegisterExtDecoder(extID, value, func(d *Decoder, v reflect.Value, extLen int) error {
- b, err := d.readN(extLen)
- if err != nil {
- return err
- }
- return v.Interface().(Unmarshaler).UnmarshalMsgpack(b)
- })
-}
-
-func UnregisterExt(extID int8) {
- unregisterExtEncoder(extID)
- unregisterExtDecoder(extID)
-}
-
-func RegisterExtEncoder(
- extID int8,
- value interface{},
- encoder func(enc *Encoder, v reflect.Value) ([]byte, error),
-) {
- unregisterExtEncoder(extID)
-
- typ := reflect.TypeOf(value)
- extEncoder := makeExtEncoder(extID, typ, encoder)
- typeEncMap.Store(extID, typ)
- typeEncMap.Store(typ, extEncoder)
- if typ.Kind() == reflect.Ptr {
- typeEncMap.Store(typ.Elem(), makeExtEncoderAddr(extEncoder))
- }
-}
-
-func unregisterExtEncoder(extID int8) {
- t, ok := typeEncMap.Load(extID)
- if !ok {
- return
- }
- typeEncMap.Delete(extID)
- typ := t.(reflect.Type)
- typeEncMap.Delete(typ)
- if typ.Kind() == reflect.Ptr {
- typeEncMap.Delete(typ.Elem())
- }
-}
-
-func makeExtEncoder(
- extID int8,
- typ reflect.Type,
- encoder func(enc *Encoder, v reflect.Value) ([]byte, error),
-) encoderFunc {
- nilable := typ.Kind() == reflect.Ptr
-
- return func(e *Encoder, v reflect.Value) error {
- if nilable && v.IsNil() {
- return e.EncodeNil()
- }
-
- b, err := encoder(e, v)
- if err != nil {
- return err
- }
-
- if err := e.EncodeExtHeader(extID, len(b)); err != nil {
- return err
- }
-
- return e.write(b)
- }
-}
-
-func makeExtEncoderAddr(extEncoder encoderFunc) encoderFunc {
- return func(e *Encoder, v reflect.Value) error {
- if !v.CanAddr() {
- return fmt.Errorf("msgpack: EncodeExt(nonaddressable %T)", v.Interface())
- }
- return extEncoder(e, v.Addr())
- }
-}
-
-func RegisterExtDecoder(
- extID int8,
- value interface{},
- decoder func(dec *Decoder, v reflect.Value, extLen int) error,
-) {
- unregisterExtDecoder(extID)
-
- typ := reflect.TypeOf(value)
- extDecoder := makeExtDecoder(extID, typ, decoder)
- extTypes[extID] = &extInfo{
- Type: typ,
- Decoder: decoder,
- }
-
- typeDecMap.Store(extID, typ)
- typeDecMap.Store(typ, extDecoder)
- if typ.Kind() == reflect.Ptr {
- typeDecMap.Store(typ.Elem(), makeExtDecoderAddr(extDecoder))
- }
-}
-
-func unregisterExtDecoder(extID int8) {
- t, ok := typeDecMap.Load(extID)
- if !ok {
- return
- }
- typeDecMap.Delete(extID)
- delete(extTypes, extID)
- typ := t.(reflect.Type)
- typeDecMap.Delete(typ)
- if typ.Kind() == reflect.Ptr {
- typeDecMap.Delete(typ.Elem())
- }
-}
-
-func makeExtDecoder(
- wantedExtID int8,
- typ reflect.Type,
- decoder func(d *Decoder, v reflect.Value, extLen int) error,
-) decoderFunc {
- return nilAwareDecoder(typ, func(d *Decoder, v reflect.Value) error {
- extID, extLen, err := d.DecodeExtHeader()
- if err != nil {
- return err
- }
- if extID != wantedExtID {
- return fmt.Errorf("msgpack: got ext type=%d, wanted %d", extID, wantedExtID)
- }
- return decoder(d, v, extLen)
- })
-}
-
-func makeExtDecoderAddr(extDecoder decoderFunc) decoderFunc {
- return func(d *Decoder, v reflect.Value) error {
- if !v.CanAddr() {
- return fmt.Errorf("msgpack: DecodeExt(nonaddressable %T)", v.Interface())
- }
- return extDecoder(d, v.Addr())
- }
-}
-
-func (e *Encoder) EncodeExtHeader(extID int8, extLen int) error {
- if err := e.encodeExtLen(extLen); err != nil {
- return err
- }
- if err := e.w.WriteByte(byte(extID)); err != nil {
- return err
- }
- return nil
-}
-
-func (e *Encoder) encodeExtLen(l int) error {
- switch l {
- case 1:
- return e.writeCode(msgpcode.FixExt1)
- case 2:
- return e.writeCode(msgpcode.FixExt2)
- case 4:
- return e.writeCode(msgpcode.FixExt4)
- case 8:
- return e.writeCode(msgpcode.FixExt8)
- case 16:
- return e.writeCode(msgpcode.FixExt16)
- }
- if l <= math.MaxUint8 {
- return e.write1(msgpcode.Ext8, uint8(l))
- }
- if l <= math.MaxUint16 {
- return e.write2(msgpcode.Ext16, uint16(l))
- }
- return e.write4(msgpcode.Ext32, uint32(l))
-}
-
-func (d *Decoder) DecodeExtHeader() (extID int8, extLen int, err error) {
- c, err := d.readCode()
- if err != nil {
- return
- }
- return d.extHeader(c)
-}
-
-func (d *Decoder) extHeader(c byte) (int8, int, error) {
- extLen, err := d.parseExtLen(c)
- if err != nil {
- return 0, 0, err
- }
-
- extID, err := d.readCode()
- if err != nil {
- return 0, 0, err
- }
-
- return int8(extID), extLen, nil
-}
-
-func (d *Decoder) parseExtLen(c byte) (int, error) {
- switch c {
- case msgpcode.FixExt1:
- return 1, nil
- case msgpcode.FixExt2:
- return 2, nil
- case msgpcode.FixExt4:
- return 4, nil
- case msgpcode.FixExt8:
- return 8, nil
- case msgpcode.FixExt16:
- return 16, nil
- case msgpcode.Ext8:
- n, err := d.uint8()
- return int(n), err
- case msgpcode.Ext16:
- n, err := d.uint16()
- return int(n), err
- case msgpcode.Ext32:
- n, err := d.uint32()
- return int(n), err
- default:
- return 0, fmt.Errorf("msgpack: invalid code=%x decoding ext len", c)
- }
-}
-
-func (d *Decoder) decodeInterfaceExt(c byte) (interface{}, error) {
- extID, extLen, err := d.extHeader(c)
- if err != nil {
- return nil, err
- }
-
- info, ok := extTypes[extID]
- if !ok {
- return nil, fmt.Errorf("msgpack: unknown ext id=%d", extID)
- }
-
- v := d.newValue(info.Type).Elem()
- if nilable(v.Kind()) && v.IsNil() {
- v.Set(d.newValue(info.Type.Elem()))
- }
-
- if err := info.Decoder(d, v, extLen); err != nil {
- return nil, err
- }
-
- return v.Interface(), nil
-}
-
-func (d *Decoder) skipExt(c byte) error {
- n, err := d.parseExtLen(c)
- if err != nil {
- return err
- }
- return d.skipN(n + 1)
-}
-
-func (d *Decoder) skipExtHeader(c byte) error {
- // Read ext type.
- _, err := d.readCode()
- if err != nil {
- return err
- }
- // Read ext body len.
- for i := 0; i < extHeaderLen(c); i++ {
- _, err := d.readCode()
- if err != nil {
- return err
- }
- }
- return nil
-}
-
-func extHeaderLen(c byte) int {
- switch c {
- case msgpcode.Ext8:
- return 1
- case msgpcode.Ext16:
- return 2
- case msgpcode.Ext32:
- return 4
- }
- return 0
-}
diff --git a/vendor/github.com/vmihailenco/msgpack/v5/intern.go b/vendor/github.com/vmihailenco/msgpack/v5/intern.go
deleted file mode 100644
index 7f019aaac..000000000
--- a/vendor/github.com/vmihailenco/msgpack/v5/intern.go
+++ /dev/null
@@ -1,236 +0,0 @@
-package msgpack
-
-import (
- "fmt"
- "math"
- "reflect"
-
- "github.com/vmihailenco/msgpack/v5/msgpcode"
-)
-
-const (
- minInternedStringLen = 3
- maxDictLen = math.MaxUint16
-)
-
-var internedStringExtID = int8(math.MinInt8)
-
-func init() {
- extTypes[internedStringExtID] = &extInfo{
- Type: stringType,
- Decoder: decodeInternedStringExt,
- }
-}
-
-func decodeInternedStringExt(d *Decoder, v reflect.Value, extLen int) error {
- idx, err := d.decodeInternedStringIndex(extLen)
- if err != nil {
- return err
- }
-
- s, err := d.internedStringAtIndex(idx)
- if err != nil {
- return err
- }
-
- v.SetString(s)
- return nil
-}
-
-//------------------------------------------------------------------------------
-
-func encodeInternedInterfaceValue(e *Encoder, v reflect.Value) error {
- if v.IsNil() {
- return e.EncodeNil()
- }
-
- v = v.Elem()
- if v.Kind() == reflect.String {
- return e.encodeInternedString(v.String(), true)
- }
- return e.EncodeValue(v)
-}
-
-func encodeInternedStringValue(e *Encoder, v reflect.Value) error {
- return e.encodeInternedString(v.String(), true)
-}
-
-func (e *Encoder) encodeInternedString(s string, intern bool) error {
- // Interned string takes at least 3 bytes. Plain string 1 byte + string len.
- if idx, ok := e.dict[s]; ok {
- return e.encodeInternedStringIndex(idx)
- }
-
- if intern && len(s) >= minInternedStringLen && len(e.dict) < maxDictLen {
- if e.dict == nil {
- e.dict = make(map[string]int)
- }
- idx := len(e.dict)
- e.dict[s] = idx
- }
-
- return e.encodeNormalString(s)
-}
-
-func (e *Encoder) encodeInternedStringIndex(idx int) error {
- if idx <= math.MaxUint8 {
- if err := e.writeCode(msgpcode.FixExt1); err != nil {
- return err
- }
- return e.write1(byte(internedStringExtID), uint8(idx))
- }
-
- if idx <= math.MaxUint16 {
- if err := e.writeCode(msgpcode.FixExt2); err != nil {
- return err
- }
- return e.write2(byte(internedStringExtID), uint16(idx))
- }
-
- if uint64(idx) <= math.MaxUint32 {
- if err := e.writeCode(msgpcode.FixExt4); err != nil {
- return err
- }
- return e.write4(byte(internedStringExtID), uint32(idx))
- }
-
- return fmt.Errorf("msgpack: interned string index=%d is too large", idx)
-}
-
-//------------------------------------------------------------------------------
-
-func decodeInternedInterfaceValue(d *Decoder, v reflect.Value) error {
- s, err := d.decodeInternedString(true)
- if err == nil {
- v.Set(reflect.ValueOf(s))
- return nil
- }
- if err != nil {
- if _, ok := err.(unexpectedCodeError); !ok {
- return err
- }
- }
-
- if err := d.s.UnreadByte(); err != nil {
- return err
- }
- return decodeInterfaceValue(d, v)
-}
-
-func decodeInternedStringValue(d *Decoder, v reflect.Value) error {
- s, err := d.decodeInternedString(true)
- if err != nil {
- return err
- }
-
- v.SetString(s)
- return nil
-}
-
-func (d *Decoder) decodeInternedString(intern bool) (string, error) {
- c, err := d.readCode()
- if err != nil {
- return "", err
- }
-
- if msgpcode.IsFixedString(c) {
- n := int(c & msgpcode.FixedStrMask)
- return d.decodeInternedStringWithLen(n, intern)
- }
-
- switch c {
- case msgpcode.Nil:
- return "", nil
- case msgpcode.FixExt1, msgpcode.FixExt2, msgpcode.FixExt4:
- typeID, extLen, err := d.extHeader(c)
- if err != nil {
- return "", err
- }
- if typeID != internedStringExtID {
- err := fmt.Errorf("msgpack: got ext type=%d, wanted %d",
- typeID, internedStringExtID)
- return "", err
- }
-
- idx, err := d.decodeInternedStringIndex(extLen)
- if err != nil {
- return "", err
- }
-
- return d.internedStringAtIndex(idx)
- case msgpcode.Str8, msgpcode.Bin8:
- n, err := d.uint8()
- if err != nil {
- return "", err
- }
- return d.decodeInternedStringWithLen(int(n), intern)
- case msgpcode.Str16, msgpcode.Bin16:
- n, err := d.uint16()
- if err != nil {
- return "", err
- }
- return d.decodeInternedStringWithLen(int(n), intern)
- case msgpcode.Str32, msgpcode.Bin32:
- n, err := d.uint32()
- if err != nil {
- return "", err
- }
- return d.decodeInternedStringWithLen(int(n), intern)
- }
-
- return "", unexpectedCodeError{
- code: c,
- hint: "interned string",
- }
-}
-
-func (d *Decoder) decodeInternedStringIndex(extLen int) (int, error) {
- switch extLen {
- case 1:
- n, err := d.uint8()
- if err != nil {
- return 0, err
- }
- return int(n), nil
- case 2:
- n, err := d.uint16()
- if err != nil {
- return 0, err
- }
- return int(n), nil
- case 4:
- n, err := d.uint32()
- if err != nil {
- return 0, err
- }
- return int(n), nil
- }
-
- err := fmt.Errorf("msgpack: unsupported ext len=%d decoding interned string", extLen)
- return 0, err
-}
-
-func (d *Decoder) internedStringAtIndex(idx int) (string, error) {
- if idx >= len(d.dict) {
- err := fmt.Errorf("msgpack: interned string at index=%d does not exist", idx)
- return "", err
- }
- return d.dict[idx], nil
-}
-
-func (d *Decoder) decodeInternedStringWithLen(n int, intern bool) (string, error) {
- if n <= 0 {
- return "", nil
- }
-
- s, err := d.stringWithLen(n)
- if err != nil {
- return "", err
- }
-
- if intern && len(s) >= minInternedStringLen && len(d.dict) < maxDictLen {
- d.dict = append(d.dict, s)
- }
-
- return s, nil
-}
diff --git a/vendor/github.com/vmihailenco/msgpack/v5/msgpack.go b/vendor/github.com/vmihailenco/msgpack/v5/msgpack.go
deleted file mode 100644
index 4fa000b82..000000000
--- a/vendor/github.com/vmihailenco/msgpack/v5/msgpack.go
+++ /dev/null
@@ -1,52 +0,0 @@
-package msgpack
-
-import "fmt"
-
-type Marshaler interface {
- MarshalMsgpack() ([]byte, error)
-}
-
-type Unmarshaler interface {
- UnmarshalMsgpack([]byte) error
-}
-
-type CustomEncoder interface {
- EncodeMsgpack(*Encoder) error
-}
-
-type CustomDecoder interface {
- DecodeMsgpack(*Decoder) error
-}
-
-//------------------------------------------------------------------------------
-
-type RawMessage []byte
-
-var (
- _ CustomEncoder = (RawMessage)(nil)
- _ CustomDecoder = (*RawMessage)(nil)
-)
-
-func (m RawMessage) EncodeMsgpack(enc *Encoder) error {
- return enc.write(m)
-}
-
-func (m *RawMessage) DecodeMsgpack(dec *Decoder) error {
- msg, err := dec.DecodeRaw()
- if err != nil {
- return err
- }
- *m = msg
- return nil
-}
-
-//------------------------------------------------------------------------------
-
-type unexpectedCodeError struct {
- hint string
- code byte
-}
-
-func (err unexpectedCodeError) Error() string {
- return fmt.Sprintf("msgpack: unexpected code=%x decoding %s", err.code, err.hint)
-}
diff --git a/vendor/github.com/vmihailenco/msgpack/v5/msgpcode/msgpcode.go b/vendor/github.com/vmihailenco/msgpack/v5/msgpcode/msgpcode.go
deleted file mode 100644
index e35389ccc..000000000
--- a/vendor/github.com/vmihailenco/msgpack/v5/msgpcode/msgpcode.go
+++ /dev/null
@@ -1,88 +0,0 @@
-package msgpcode
-
-var (
- PosFixedNumHigh byte = 0x7f
- NegFixedNumLow byte = 0xe0
-
- Nil byte = 0xc0
-
- False byte = 0xc2
- True byte = 0xc3
-
- Float byte = 0xca
- Double byte = 0xcb
-
- Uint8 byte = 0xcc
- Uint16 byte = 0xcd
- Uint32 byte = 0xce
- Uint64 byte = 0xcf
-
- Int8 byte = 0xd0
- Int16 byte = 0xd1
- Int32 byte = 0xd2
- Int64 byte = 0xd3
-
- FixedStrLow byte = 0xa0
- FixedStrHigh byte = 0xbf
- FixedStrMask byte = 0x1f
- Str8 byte = 0xd9
- Str16 byte = 0xda
- Str32 byte = 0xdb
-
- Bin8 byte = 0xc4
- Bin16 byte = 0xc5
- Bin32 byte = 0xc6
-
- FixedArrayLow byte = 0x90
- FixedArrayHigh byte = 0x9f
- FixedArrayMask byte = 0xf
- Array16 byte = 0xdc
- Array32 byte = 0xdd
-
- FixedMapLow byte = 0x80
- FixedMapHigh byte = 0x8f
- FixedMapMask byte = 0xf
- Map16 byte = 0xde
- Map32 byte = 0xdf
-
- FixExt1 byte = 0xd4
- FixExt2 byte = 0xd5
- FixExt4 byte = 0xd6
- FixExt8 byte = 0xd7
- FixExt16 byte = 0xd8
- Ext8 byte = 0xc7
- Ext16 byte = 0xc8
- Ext32 byte = 0xc9
-)
-
-func IsFixedNum(c byte) bool {
- return c <= PosFixedNumHigh || c >= NegFixedNumLow
-}
-
-func IsFixedMap(c byte) bool {
- return c >= FixedMapLow && c <= FixedMapHigh
-}
-
-func IsFixedArray(c byte) bool {
- return c >= FixedArrayLow && c <= FixedArrayHigh
-}
-
-func IsFixedString(c byte) bool {
- return c >= FixedStrLow && c <= FixedStrHigh
-}
-
-func IsString(c byte) bool {
- return IsFixedString(c) || c == Str8 || c == Str16 || c == Str32
-}
-
-func IsBin(c byte) bool {
- return c == Bin8 || c == Bin16 || c == Bin32
-}
-
-func IsFixedExt(c byte) bool {
- return c >= FixExt1 && c <= FixExt16
-}
-
-func IsExt(c byte) bool {
- return IsFixedExt(c) || c == Ext8 || c == Ext16 || c == Ext32
-}
diff --git a/vendor/github.com/vmihailenco/msgpack/v5/package.json b/vendor/github.com/vmihailenco/msgpack/v5/package.json
deleted file mode 100644
index 921f8eab2..000000000
--- a/vendor/github.com/vmihailenco/msgpack/v5/package.json
+++ /dev/null
@@ -1,4 +0,0 @@
-{
- "name": "msgpack",
- "version": "5.4.1"
-}
diff --git a/vendor/github.com/vmihailenco/msgpack/v5/safe.go b/vendor/github.com/vmihailenco/msgpack/v5/safe.go
deleted file mode 100644
index 8352c9dce..000000000
--- a/vendor/github.com/vmihailenco/msgpack/v5/safe.go
+++ /dev/null
@@ -1,13 +0,0 @@
-// +build appengine
-
-package msgpack
-
-// bytesToString converts byte slice to string.
-func bytesToString(b []byte) string {
- return string(b)
-}
-
-// stringToBytes converts string to byte slice.
-func stringToBytes(s string) []byte {
- return []byte(s)
-}
diff --git a/vendor/github.com/vmihailenco/msgpack/v5/time.go b/vendor/github.com/vmihailenco/msgpack/v5/time.go
deleted file mode 100644
index 1a4ba1265..000000000
--- a/vendor/github.com/vmihailenco/msgpack/v5/time.go
+++ /dev/null
@@ -1,151 +0,0 @@
-package msgpack
-
-import (
- "encoding/binary"
- "fmt"
- "reflect"
- "time"
-
- "github.com/vmihailenco/msgpack/v5/msgpcode"
-)
-
-var timeExtID int8 = -1
-
-func init() {
- RegisterExtEncoder(timeExtID, time.Time{}, timeEncoder)
- RegisterExtDecoder(timeExtID, time.Time{}, timeDecoder)
-}
-
-func timeEncoder(e *Encoder, v reflect.Value) ([]byte, error) {
- return e.encodeTime(v.Interface().(time.Time)), nil
-}
-
-func timeDecoder(d *Decoder, v reflect.Value, extLen int) error {
- tm, err := d.decodeTime(extLen)
- if err != nil {
- return err
- }
-
- if tm.IsZero() {
- // Zero time does not have timezone information.
- tm = tm.UTC()
- }
-
- ptr := v.Addr().Interface().(*time.Time)
- *ptr = tm
-
- return nil
-}
-
-func (e *Encoder) EncodeTime(tm time.Time) error {
- b := e.encodeTime(tm)
- if err := e.encodeExtLen(len(b)); err != nil {
- return err
- }
- if err := e.w.WriteByte(byte(timeExtID)); err != nil {
- return err
- }
- return e.write(b)
-}
-
-func (e *Encoder) encodeTime(tm time.Time) []byte {
- if e.timeBuf == nil {
- e.timeBuf = make([]byte, 12)
- }
-
- secs := uint64(tm.Unix())
- if secs>>34 == 0 {
- data := uint64(tm.Nanosecond())<<34 | secs
-
- if data&0xffffffff00000000 == 0 {
- b := e.timeBuf[:4]
- binary.BigEndian.PutUint32(b, uint32(data))
- return b
- }
-
- b := e.timeBuf[:8]
- binary.BigEndian.PutUint64(b, data)
- return b
- }
-
- b := e.timeBuf[:12]
- binary.BigEndian.PutUint32(b, uint32(tm.Nanosecond()))
- binary.BigEndian.PutUint64(b[4:], secs)
- return b
-}
-
-func (d *Decoder) DecodeTime() (time.Time, error) {
- c, err := d.readCode()
- if err != nil {
- return time.Time{}, err
- }
-
- // Legacy format.
- if c == msgpcode.FixedArrayLow|2 {
- sec, err := d.DecodeInt64()
- if err != nil {
- return time.Time{}, err
- }
-
- nsec, err := d.DecodeInt64()
- if err != nil {
- return time.Time{}, err
- }
-
- return time.Unix(sec, nsec), nil
- }
-
- if msgpcode.IsString(c) {
- s, err := d.string(c)
- if err != nil {
- return time.Time{}, err
- }
- return time.Parse(time.RFC3339Nano, s)
- }
-
- extID, extLen, err := d.extHeader(c)
- if err != nil {
- return time.Time{}, err
- }
-
- // NodeJS seems to use extID 13.
- if extID != timeExtID && extID != 13 {
- return time.Time{}, fmt.Errorf("msgpack: invalid time ext id=%d", extID)
- }
-
- tm, err := d.decodeTime(extLen)
- if err != nil {
- return tm, err
- }
-
- if tm.IsZero() {
- // Zero time does not have timezone information.
- return tm.UTC(), nil
- }
- return tm, nil
-}
-
-func (d *Decoder) decodeTime(extLen int) (time.Time, error) {
- b, err := d.readN(extLen)
- if err != nil {
- return time.Time{}, err
- }
-
- switch len(b) {
- case 4:
- sec := binary.BigEndian.Uint32(b)
- return time.Unix(int64(sec), 0), nil
- case 8:
- sec := binary.BigEndian.Uint64(b)
- nsec := int64(sec >> 34)
- sec &= 0x00000003ffffffff
- return time.Unix(int64(sec), nsec), nil
- case 12:
- nsec := binary.BigEndian.Uint32(b)
- sec := binary.BigEndian.Uint64(b[4:])
- return time.Unix(int64(sec), int64(nsec)), nil
- default:
- err = fmt.Errorf("msgpack: invalid ext len=%d decoding time", extLen)
- return time.Time{}, err
- }
-}
diff --git a/vendor/github.com/vmihailenco/msgpack/v5/types.go b/vendor/github.com/vmihailenco/msgpack/v5/types.go
deleted file mode 100644
index d212e098e..000000000
--- a/vendor/github.com/vmihailenco/msgpack/v5/types.go
+++ /dev/null
@@ -1,413 +0,0 @@
-package msgpack
-
-import (
- "encoding"
- "fmt"
- "log"
- "reflect"
- "sync"
-
- "github.com/vmihailenco/tagparser/v2"
-)
-
-var errorType = reflect.TypeOf((*error)(nil)).Elem()
-
-var (
- customEncoderType = reflect.TypeOf((*CustomEncoder)(nil)).Elem()
- customDecoderType = reflect.TypeOf((*CustomDecoder)(nil)).Elem()
-)
-
-var (
- marshalerType = reflect.TypeOf((*Marshaler)(nil)).Elem()
- unmarshalerType = reflect.TypeOf((*Unmarshaler)(nil)).Elem()
-)
-
-var (
- binaryMarshalerType = reflect.TypeOf((*encoding.BinaryMarshaler)(nil)).Elem()
- binaryUnmarshalerType = reflect.TypeOf((*encoding.BinaryUnmarshaler)(nil)).Elem()
-)
-
-var (
- textMarshalerType = reflect.TypeOf((*encoding.TextMarshaler)(nil)).Elem()
- textUnmarshalerType = reflect.TypeOf((*encoding.TextUnmarshaler)(nil)).Elem()
-)
-
-type (
- encoderFunc func(*Encoder, reflect.Value) error
- decoderFunc func(*Decoder, reflect.Value) error
-)
-
-var (
- typeEncMap sync.Map
- typeDecMap sync.Map
-)
-
-// Register registers encoder and decoder functions for a value.
-// This is low level API and in most cases you should prefer implementing
-// CustomEncoder/CustomDecoder or Marshaler/Unmarshaler interfaces.
-func Register(value interface{}, enc encoderFunc, dec decoderFunc) {
- typ := reflect.TypeOf(value)
- if enc != nil {
- typeEncMap.Store(typ, enc)
- }
- if dec != nil {
- typeDecMap.Store(typ, dec)
- }
-}
-
-//------------------------------------------------------------------------------
-
-const defaultStructTag = "msgpack"
-
-var structs = newStructCache()
-
-type structCache struct {
- m sync.Map
-}
-
-type structCacheKey struct {
- typ reflect.Type
- tag string
-}
-
-func newStructCache() *structCache {
- return new(structCache)
-}
-
-func (m *structCache) Fields(typ reflect.Type, tag string) *fields {
- key := structCacheKey{tag: tag, typ: typ}
-
- if v, ok := m.m.Load(key); ok {
- return v.(*fields)
- }
-
- fs := getFields(typ, tag)
- m.m.Store(key, fs)
-
- return fs
-}
-
-//------------------------------------------------------------------------------
-
-type field struct {
- encoder encoderFunc
- decoder decoderFunc
- name string
- index []int
- omitEmpty bool
-}
-
-func (f *field) Omit(e *Encoder, strct reflect.Value) bool {
- v, ok := fieldByIndex(strct, f.index)
- if !ok {
- return true
- }
- forced := e.flags&omitEmptyFlag != 0
- return (f.omitEmpty || forced) && e.isEmptyValue(v)
-}
-
-func (f *field) EncodeValue(e *Encoder, strct reflect.Value) error {
- v, ok := fieldByIndex(strct, f.index)
- if !ok {
- return e.EncodeNil()
- }
- return f.encoder(e, v)
-}
-
-func (f *field) DecodeValue(d *Decoder, strct reflect.Value) error {
- v := fieldByIndexAlloc(strct, f.index)
- return f.decoder(d, v)
-}
-
-//------------------------------------------------------------------------------
-
-type fields struct {
- Type reflect.Type
- Map map[string]*field
- List []*field
- AsArray bool
-
- hasOmitEmpty bool
-}
-
-func newFields(typ reflect.Type) *fields {
- return &fields{
- Type: typ,
- Map: make(map[string]*field, typ.NumField()),
- List: make([]*field, 0, typ.NumField()),
- }
-}
-
-func (fs *fields) Add(field *field) {
- fs.warnIfFieldExists(field.name)
- fs.Map[field.name] = field
- fs.List = append(fs.List, field)
- if field.omitEmpty {
- fs.hasOmitEmpty = true
- }
-}
-
-func (fs *fields) warnIfFieldExists(name string) {
- if _, ok := fs.Map[name]; ok {
- log.Printf("msgpack: %s already has field=%s", fs.Type, name)
- }
-}
-
-func (fs *fields) OmitEmpty(e *Encoder, strct reflect.Value) []*field {
- forced := e.flags&omitEmptyFlag != 0
- if !fs.hasOmitEmpty && !forced {
- return fs.List
- }
-
- fields := make([]*field, 0, len(fs.List))
-
- for _, f := range fs.List {
- if !f.Omit(e, strct) {
- fields = append(fields, f)
- }
- }
-
- return fields
-}
-
-func getFields(typ reflect.Type, fallbackTag string) *fields {
- fs := newFields(typ)
-
- var omitEmpty bool
- for i := 0; i < typ.NumField(); i++ {
- f := typ.Field(i)
-
- tagStr := f.Tag.Get(defaultStructTag)
- if tagStr == "" && fallbackTag != "" {
- tagStr = f.Tag.Get(fallbackTag)
- }
-
- tag := tagparser.Parse(tagStr)
- if tag.Name == "-" {
- continue
- }
-
- if f.Name == "_msgpack" {
- fs.AsArray = tag.HasOption("as_array") || tag.HasOption("asArray")
- if tag.HasOption("omitempty") {
- omitEmpty = true
- }
- }
-
- if f.PkgPath != "" && !f.Anonymous {
- continue
- }
-
- field := &field{
- name: tag.Name,
- index: f.Index,
- omitEmpty: omitEmpty || tag.HasOption("omitempty"),
- }
-
- if tag.HasOption("intern") {
- switch f.Type.Kind() {
- case reflect.Interface:
- field.encoder = encodeInternedInterfaceValue
- field.decoder = decodeInternedInterfaceValue
- case reflect.String:
- field.encoder = encodeInternedStringValue
- field.decoder = decodeInternedStringValue
- default:
- err := fmt.Errorf("msgpack: intern strings are not supported on %s", f.Type)
- panic(err)
- }
- } else {
- field.encoder = getEncoder(f.Type)
- field.decoder = getDecoder(f.Type)
- }
-
- if field.name == "" {
- field.name = f.Name
- }
-
- if f.Anonymous && !tag.HasOption("noinline") {
- inline := tag.HasOption("inline")
- if inline {
- inlineFields(fs, f.Type, field, fallbackTag)
- } else {
- inline = shouldInline(fs, f.Type, field, fallbackTag)
- }
-
- if inline {
- if _, ok := fs.Map[field.name]; ok {
- log.Printf("msgpack: %s already has field=%s", fs.Type, field.name)
- }
- fs.Map[field.name] = field
- continue
- }
- }
-
- fs.Add(field)
-
- if alias, ok := tag.Options["alias"]; ok {
- fs.warnIfFieldExists(alias)
- fs.Map[alias] = field
- }
- }
- return fs
-}
-
-var (
- encodeStructValuePtr uintptr
- decodeStructValuePtr uintptr
-)
-
-//nolint:gochecknoinits
-func init() {
- encodeStructValuePtr = reflect.ValueOf(encodeStructValue).Pointer()
- decodeStructValuePtr = reflect.ValueOf(decodeStructValue).Pointer()
-}
-
-func inlineFields(fs *fields, typ reflect.Type, f *field, tag string) {
- inlinedFields := getFields(typ, tag).List
- for _, field := range inlinedFields {
- if _, ok := fs.Map[field.name]; ok {
- // Don't inline shadowed fields.
- continue
- }
- field.index = append(f.index, field.index...)
- fs.Add(field)
- }
-}
-
-func shouldInline(fs *fields, typ reflect.Type, f *field, tag string) bool {
- var encoder encoderFunc
- var decoder decoderFunc
-
- if typ.Kind() == reflect.Struct {
- encoder = f.encoder
- decoder = f.decoder
- } else {
- for typ.Kind() == reflect.Ptr {
- typ = typ.Elem()
- encoder = getEncoder(typ)
- decoder = getDecoder(typ)
- }
- if typ.Kind() != reflect.Struct {
- return false
- }
- }
-
- if reflect.ValueOf(encoder).Pointer() != encodeStructValuePtr {
- return false
- }
- if reflect.ValueOf(decoder).Pointer() != decodeStructValuePtr {
- return false
- }
-
- inlinedFields := getFields(typ, tag).List
- for _, field := range inlinedFields {
- if _, ok := fs.Map[field.name]; ok {
- // Don't auto inline if there are shadowed fields.
- return false
- }
- }
-
- for _, field := range inlinedFields {
- field.index = append(f.index, field.index...)
- fs.Add(field)
- }
- return true
-}
-
-type isZeroer interface {
- IsZero() bool
-}
-
-func (e *Encoder) isEmptyValue(v reflect.Value) bool {
- kind := v.Kind()
-
- for kind == reflect.Interface {
- if v.IsNil() {
- return true
- }
- v = v.Elem()
- kind = v.Kind()
- }
-
- if z, ok := v.Interface().(isZeroer); ok {
- return nilable(kind) && v.IsNil() || z.IsZero()
- }
-
- switch kind {
- case reflect.Array, reflect.Map, reflect.Slice, reflect.String:
- return v.Len() == 0
- case reflect.Struct:
- structFields := structs.Fields(v.Type(), e.structTag)
- fields := structFields.OmitEmpty(e, v)
- return len(fields) == 0
- case reflect.Bool:
- return !v.Bool()
- case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
- return v.Int() == 0
- case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
- return v.Uint() == 0
- case reflect.Float32, reflect.Float64:
- return v.Float() == 0
- case reflect.Ptr:
- return v.IsNil()
- default:
- return false
- }
-}
-
-func fieldByIndex(v reflect.Value, index []int) (_ reflect.Value, ok bool) {
- if len(index) == 1 {
- return v.Field(index[0]), true
- }
-
- for i, idx := range index {
- if i > 0 {
- if v.Kind() == reflect.Ptr {
- if v.IsNil() {
- return v, false
- }
- v = v.Elem()
- }
- }
- v = v.Field(idx)
- }
-
- return v, true
-}
-
-func fieldByIndexAlloc(v reflect.Value, index []int) reflect.Value {
- if len(index) == 1 {
- return v.Field(index[0])
- }
-
- for i, idx := range index {
- if i > 0 {
- var ok bool
- v, ok = indirectNil(v)
- if !ok {
- return v
- }
- }
- v = v.Field(idx)
- }
-
- return v
-}
-
-func indirectNil(v reflect.Value) (reflect.Value, bool) {
- if v.Kind() == reflect.Ptr {
- if v.IsNil() {
- if !v.CanSet() {
- return v, false
- }
- elemType := v.Type().Elem()
- if elemType.Kind() != reflect.Struct {
- return v, false
- }
- v.Set(cachedValue(elemType))
- }
- v = v.Elem()
- }
- return v, true
-}
diff --git a/vendor/github.com/vmihailenco/msgpack/v5/unsafe.go b/vendor/github.com/vmihailenco/msgpack/v5/unsafe.go
deleted file mode 100644
index 192ac4792..000000000
--- a/vendor/github.com/vmihailenco/msgpack/v5/unsafe.go
+++ /dev/null
@@ -1,22 +0,0 @@
-// +build !appengine
-
-package msgpack
-
-import (
- "unsafe"
-)
-
-// bytesToString converts byte slice to string.
-func bytesToString(b []byte) string {
- return *(*string)(unsafe.Pointer(&b))
-}
-
-// stringToBytes converts string to byte slice.
-func stringToBytes(s string) []byte {
- return *(*[]byte)(unsafe.Pointer(
- &struct {
- string
- Cap int
- }{s, len(s)},
- ))
-}
diff --git a/vendor/github.com/vmihailenco/msgpack/v5/version.go b/vendor/github.com/vmihailenco/msgpack/v5/version.go
deleted file mode 100644
index ca10205f2..000000000
--- a/vendor/github.com/vmihailenco/msgpack/v5/version.go
+++ /dev/null
@@ -1,6 +0,0 @@
-package msgpack
-
-// Version is the current release version.
-func Version() string {
- return "5.4.1"
-}