mirrors/mostlymatter
1
0
Форкнуть 0
Код Задачи Запросы на слияние Действия Пакеты Проекты Релизы Вики Активность

MM-31436: Upgrade dependencies (#16605)

Просмотр исходного кода 
* MM-31436: Upgrade dependencies

Ran make update-dependencies

https://mattermost.atlassian.net/browse/MM-31436

```release-note
NONE
```

* add missing dep

* fix lru marshaling
Этот коммит содержится в:
Agniva De Sarker
2021-01-07 14:39:17 +05:30
коммит произвёл GitHub
родитель 09d2f698cc
Коммит 091659c8ad
808 изменённых файлов: 57414 добавлений и 46282 удалений
Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

6
vendor/github.com/vmihailenco/msgpack/v5/.golangci.yml сгенерированный поставляемый
Просмотреть файл

@@ -10,3 +10,9 @@ linters:
- godox
- wsl
- funlen
- gochecknoinits
- gomnd
- nlreturn
- goerr113
- exhaustive
- nestif

2
vendor/github.com/vmihailenco/msgpack/v5/.prettierrc сгенерированный поставляемый
Просмотреть файл

@@ -1,4 +1,4 @@
semi: false
singleQuote: true
proseWrap: always
printWidth: 80
printWidth: 100

7
vendor/github.com/vmihailenco/msgpack/v5/.travis.yml сгенерированный поставляемый
Просмотреть файл

@@ -2,10 +2,8 @@ sudo: false
language: go
go:
- 1.11.x
- 1.12.x
- 1.13.x
- 1.14.x
- 1.15.x
- tip
matrix:
@@ -18,4 +16,5 @@ env:
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.21.0
- curl -sfL https://install.goreleaser.com/github.com/golangci/golangci-lint.sh | sh -s -- -b $(go
env GOPATH)/bin v1.31.0

25
vendor/github.com/vmihailenco/msgpack/v5/CHANGELOG.md сгенерированный поставляемый
Просмотреть файл

@@ -1,24 +1,3 @@
## v4
# Changelog
- 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.
See https://msgpack.uptrace.dev/changelog/

1
vendor/github.com/vmihailenco/msgpack/v5/Makefile сгенерированный поставляемый
Просмотреть файл

@@ -3,4 +3,5 @@ all:
go test ./... -short -race
go test ./... -run=NONE -bench=. -benchmem
env GOOS=linux GOARCH=386 go test ./...
go vet
golangci-lint run

72
vendor/github.com/vmihailenco/msgpack/v5/README.md сгенерированный поставляемый
Просмотреть файл

@@ -1,47 +1,56 @@
# MessagePack encoding for Golang
[![Build Status](https://travis-ci.org/vmihailenco/msgpack.svg)](https://travis-ci.org/vmihailenco/msgpack)
[![GoDoc](https://godoc.org/github.com/vmihailenco/msgpack?status.svg)](https://pkg.go.dev/github.com/vmihailenco/msgpack/v5?tab=doc)
[![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)
## Sponsors
> :heart: [**Uptrace.dev** - distributed traces, logs, and errors in one place](https://uptrace.dev)
- [**Uptrace.dev** - distributed traces and metrics](https://uptrace.dev)
- Join [Discord](https://discord.gg/rWtp5Aj) to ask questions.
- [Documentation](https://msgpack.uptrace.dev)
- [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](https://pkg.go.dev/github.com/vmihailenco/msgpack/v5?tab=doc#example-CustomEncoder)/CustomDecoder
interfaces for custom encoding.
- [Extensions](https://pkg.go.dev/github.com/vmihailenco/msgpack/v5?tab=doc#example-RegisterExt)
to encode type information.
- Renaming fields via `msgpack:"my_field_name"` and alias via
`msgpack:"alias:another_name"`.
- [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?tab=doc#example-Marshal--OmitEmpty).
- [Map keys sorting](https://pkg.go.dev/github.com/vmihailenco/msgpack/v5?tab=doc#Encoder.SortMapKeys).
[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?tab=doc#Encoder.UseArrayForStructs)
[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?tab=doc#example-Marshal--AsArray).
- [Encoder.UseJSONTag](https://pkg.go.dev/github.com/vmihailenco/msgpack/v5?tab=doc#Encoder.UseJSONTag)
with
[Decoder.UseJSONTag](https://pkg.go.dev/github.com/vmihailenco/msgpack/v5?tab=doc#Decoder.UseJSONTag)
can turn msgpack into drop-in replacement for JSON.
[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?tab=doc#example-Decoder-Query).
[queries](https://pkg.go.dev/github.com/vmihailenco/msgpack/v5#example-Decoder.Query).
API docs: https://pkg.go.dev/github.com/vmihailenco/msgpack/v5?tab=doc.
Examples:
https://pkg.go.dev/github.com/vmihailenco/msgpack/v5?tab=doc#pkg-examples.
[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
This project uses [Go Modules](https://github.com/golang/go/wiki/Modules) and
semantic import versioning since v4:
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
```
@@ -70,23 +79,8 @@ func ExampleMarshal() {
}
```
## Benchmark
```
BenchmarkStructVmihailencoMsgpack-4 200000 12814 ns/op 2128 B/op 26 allocs/op
BenchmarkStructUgorjiGoMsgpack-4 100000 17678 ns/op 3616 B/op 70 allocs/op
BenchmarkStructUgorjiGoCodec-4 100000 19053 ns/op 7346 B/op 23 allocs/op
BenchmarkStructJSON-4 20000 69438 ns/op 7864 B/op 26 allocs/op
BenchmarkStructGOB-4 10000 104331 ns/op 14664 B/op 278 allocs/op
```
## Howto
Please go through
[examples](https://pkg.go.dev/github.com/vmihailenco/msgpack/v5?tab=doc#pkg-examples)
to get an idea how to use this package.
## See also
- [Fast and flexible HTTP router](https://github.com/vmihailenco/treemux)
- [Golang PostgreSQL ORM](https://github.com/go-pg/pg)
- [Golang message task queue](https://github.com/vmihailenco/taskq)

64
vendor/github.com/vmihailenco/msgpack/v5/appengine.go сгенерированный поставляемый
Просмотреть файл

@@ -1,64 +0,0 @@
// +build appengine
package msgpack
import (
"reflect"
ds "google.golang.org/appengine/datastore"
)
func init() {
Register((*ds.Key)(nil), encodeDatastoreKeyValue, decodeDatastoreKeyValue)
Register((*ds.Cursor)(nil), encodeDatastoreCursorValue, decodeDatastoreCursorValue)
}
func EncodeDatastoreKey(e *Encoder, key *ds.Key) error {
if key == nil {
return e.EncodeNil()
}
return e.EncodeString(key.Encode())
}
func encodeDatastoreKeyValue(e *Encoder, v reflect.Value) error {
key := v.Interface().(*ds.Key)
return EncodeDatastoreKey(e, key)
}
func DecodeDatastoreKey(d *Decoder) (*ds.Key, error) {
v, err := d.DecodeString()
if err != nil {
return nil, err
}
if v == "" {
return nil, nil
}
return ds.DecodeKey(v)
}
func decodeDatastoreKeyValue(d *Decoder, v reflect.Value) error {
key, err := DecodeDatastoreKey(d)
if err != nil {
return err
}
v.Set(reflect.ValueOf(key))
return nil
}
func encodeDatastoreCursorValue(e *Encoder, v reflect.Value) error {
cursor := v.Interface().(ds.Cursor)
return e.Encode(cursor.String())
}
func decodeDatastoreCursorValue(d *Decoder, v reflect.Value) error {
s, err := d.DecodeString()
if err != nil {
return err
}
cursor, err := ds.DecodeCursor(s)
if err != nil {
return err
}
v.Set(reflect.ValueOf(cursor))
return nil
}

90
vendor/github.com/vmihailenco/msgpack/v5/codes/codes.go сгенерированный поставляемый
Просмотреть файл

@@ -1,90 +0,0 @@
package codes
type Code byte
var (
PosFixedNumHigh Code = 0x7f
NegFixedNumLow Code = 0xe0
Nil Code = 0xc0
False Code = 0xc2
True Code = 0xc3
Float Code = 0xca
Double Code = 0xcb
Uint8 Code = 0xcc
Uint16 Code = 0xcd
Uint32 Code = 0xce
Uint64 Code = 0xcf
Int8 Code = 0xd0
Int16 Code = 0xd1
Int32 Code = 0xd2
Int64 Code = 0xd3
FixedStrLow Code = 0xa0
FixedStrHigh Code = 0xbf
FixedStrMask Code = 0x1f
Str8 Code = 0xd9
Str16 Code = 0xda
Str32 Code = 0xdb
Bin8 Code = 0xc4
Bin16 Code = 0xc5
Bin32 Code = 0xc6
FixedArrayLow Code = 0x90
FixedArrayHigh Code = 0x9f
FixedArrayMask Code = 0xf
Array16 Code = 0xdc
Array32 Code = 0xdd
FixedMapLow Code = 0x80
FixedMapHigh Code = 0x8f
FixedMapMask Code = 0xf
Map16 Code = 0xde
Map32 Code = 0xdf
FixExt1 Code = 0xd4
FixExt2 Code = 0xd5
FixExt4 Code = 0xd6
FixExt8 Code = 0xd7
FixExt16 Code = 0xd8
Ext8 Code = 0xc7
Ext16 Code = 0xc8
Ext32 Code = 0xc9
)
func IsFixedNum(c Code) bool {
return c <= PosFixedNumHigh || c >= NegFixedNumLow
}
func IsFixedMap(c Code) bool {
return c >= FixedMapLow && c <= FixedMapHigh
}
func IsFixedArray(c Code) bool {
return c >= FixedArrayLow && c <= FixedArrayHigh
}
func IsFixedString(c Code) bool {
return c >= FixedStrLow && c <= FixedStrHigh
}
func IsString(c Code) bool {
return IsFixedString(c) || c == Str8 || c == Str16 || c == Str32
}
func IsBin(c Code) bool {
return c == Bin8 || c == Bin16 || c == Bin32
}
func IsFixedExt(c Code) bool {
return c >= FixExt1 && c <= FixExt16
}
func IsExt(c Code) bool {
return IsFixedExt(c) || c == Ext8 || c == Ext16 || c == Ext32
}

237
vendor/github.com/vmihailenco/msgpack/v5/decode.go сгенерированный поставляемый
Просмотреть файл

@@ -10,11 +10,11 @@ import (
"sync"
"time"
"github.com/vmihailenco/msgpack/v5/codes"
"github.com/vmihailenco/msgpack/v5/msgpcode"
)
const (
looseIfaceFlag uint32 = 1 << iota
looseInterfaceDecodingFlag uint32 = 1 << iota
disallowUnknownFieldsFlag
)
@@ -54,7 +54,7 @@ func PutDecoder(dec *Decoder) {
func Unmarshal(data []byte, v interface{}) error {
dec := GetDecoder()
dec.ResetBytes(data)
dec.Reset(bytes.NewReader(data))
err := dec.Decode(v)
PutDecoder(dec)
@@ -68,19 +68,18 @@ type Decoder struct {
s io.ByteScanner
buf []byte
extLen int
rec []byte // accumulates read data if not nil
rec []byte // accumulates read data if not nil
intern []string
flags uint32
structTag string
decodeMapFunc func(*Decoder) (interface{}, error)
dict []string
flags uint32
structTag string
mapDecoder func(*Decoder) (interface{}, error)
}
// NewDecoder returns a new decoder that reads from r.
//
// The decoder introduces its own buffering and may read data from r
// beyond the MessagePack values requested. Buffering can be disabled
// 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)
@@ -88,67 +87,57 @@ func NewDecoder(r io.Reader) *Decoder {
return d
}
type resetter interface {
Reset([]byte)
}
func (d *Decoder) ResetBytes(data []byte) {
if r, ok := d.r.(resetter); ok {
r.Reset(data)
} else {
d.Reset(bytes.NewReader(data))
}
}
// 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.mapDecoder = nil
d.SetDict(dict)
}
func (d *Decoder) SetDict(dict []string) {
if len(dict) > 0 {
d.dict = dict
} else {
d.dict = d.dict[:0]
}
}
func (d *Decoder) resetReader(r io.Reader) {
if br, ok := r.(bufReader); ok {
d.r = br
d.s = br
} else if br, ok := d.r.(*bufio.Reader); ok {
br.Reset(r)
} else {
br := bufio.NewReader(r)
d.r = br
d.s = br
}
if d.intern != nil {
d.intern = d.intern[:0]
}
d.flags = 0
d.decodeMapFunc = nil
}
func (d *Decoder) SetDecodeMapFunc(fn func(*Decoder) (interface{}, error)) {
d.decodeMapFunc = fn
func (d *Decoder) SetMapDecoder(fn func(*Decoder) (interface{}, error)) {
d.mapDecoder = fn
}
// UseDecodeInterfaceLoose causes decoder to use DecodeInterfaceLoose
// UseLooseInterfaceDecoding causes decoder to use DecodeInterfaceLoose
// to decode msgpack value into Go interface{}.
func (d *Decoder) UseDecodeInterfaceLoose(on bool) {
func (d *Decoder) UseLooseInterfaceDecoding(on bool) {
if on {
d.flags |= looseIfaceFlag
d.flags |= looseInterfaceDecodingFlag
} else {
d.flags &= ^looseIfaceFlag
d.flags &= ^looseInterfaceDecodingFlag
}
}
// UseJSONTag causes the Decoder to use json struct tag as fallback option
// SetCustomStructTag causes the decoder to use the supplied tag as a fallback option
// if there is no msgpack tag.
func (d *Decoder) UseJSONTag(on bool) {
if on {
d.UseCustomStructTag("json")
} else {
d.UseCustomStructTag("")
}
}
// UseCustomStructTag causes the decoder to use the supplied tag as a fallback option
// if there is no msgpack tag.
func (d *Decoder) UseCustomStructTag(tag string) {
func (d *Decoder) SetCustomStructTag(tag string) {
d.structTag = tag
}
@@ -163,6 +152,15 @@ func (d *Decoder) DisallowUnknownFields(on bool) {
}
}
// UseInternedStrings enables support for decoding interned strings.
func (d *Decoder) UseInternedStrings(on bool) {
if on {
d.flags |= useInternedStringsFlag
} else {
d.flags &= ^useInternedStringsFlag
}
}
// 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 {
@@ -300,7 +298,7 @@ func (d *Decoder) DecodeMulti(v ...interface{}) error {
}
func (d *Decoder) decodeInterfaceCond() (interface{}, error) {
if d.flags&looseIfaceFlag != 0 {
if d.flags&looseInterfaceDecodingFlag != 0 {
return d.DecodeInterfaceLoose()
}
return d.DecodeInterface()
@@ -316,7 +314,7 @@ func (d *Decoder) DecodeNil() error {
if err != nil {
return err
}
if c != codes.Nil {
if c != msgpcode.Nil {
return fmt.Errorf("msgpack: invalid code=%x decoding nil", c)
}
return nil
@@ -342,11 +340,11 @@ func (d *Decoder) DecodeBool() (bool, error) {
return d.bool(c)
}
func (d *Decoder) bool(c codes.Code) (bool, error) {
if c == codes.False {
func (d *Decoder) bool(c byte) (bool, error) {
if c == msgpcode.False {
return false, nil
}
if c == codes.True {
if c == msgpcode.True {
return true, nil
}
return false, fmt.Errorf("msgpack: invalid code=%x decoding bool", c)
@@ -380,63 +378,63 @@ func (d *Decoder) DecodeInterface() (interface{}, error) {
return nil, err
}
if codes.IsFixedNum(c) {
if msgpcode.IsFixedNum(c) {
return int8(c), nil
}
if codes.IsFixedMap(c) {
if msgpcode.IsFixedMap(c) {
err = d.s.UnreadByte()
if err != nil {
return nil, err
}
return d.DecodeMap()
return d.decodeMapDefault()
}
if codes.IsFixedArray(c) {
if msgpcode.IsFixedArray(c) {
return d.decodeSlice(c)
}
if codes.IsFixedString(c) {
if msgpcode.IsFixedString(c) {
return d.string(c)
}
switch c {
case codes.Nil:
case msgpcode.Nil:
return nil, nil
case codes.False, codes.True:
case msgpcode.False, msgpcode.True:
return d.bool(c)
case codes.Float:
case msgpcode.Float:
return d.float32(c)
case codes.Double:
case msgpcode.Double:
return d.float64(c)
case codes.Uint8:
case msgpcode.Uint8:
return d.uint8()
case codes.Uint16:
case msgpcode.Uint16:
return d.uint16()
case codes.Uint32:
case msgpcode.Uint32:
return d.uint32()
case codes.Uint64:
case msgpcode.Uint64:
return d.uint64()
case codes.Int8:
case msgpcode.Int8:
return d.int8()
case codes.Int16:
case msgpcode.Int16:
return d.int16()
case codes.Int32:
case msgpcode.Int32:
return d.int32()
case codes.Int64:
case msgpcode.Int64:
return d.int64()
case codes.Bin8, codes.Bin16, codes.Bin32:
case msgpcode.Bin8, msgpcode.Bin16, msgpcode.Bin32:
return d.bytes(c, nil)
case codes.Str8, codes.Str16, codes.Str32:
case msgpcode.Str8, msgpcode.Str16, msgpcode.Str32:
return d.string(c)
case codes.Array16, codes.Array32:
case msgpcode.Array16, msgpcode.Array32:
return d.decodeSlice(c)
case codes.Map16, codes.Map32:
case msgpcode.Map16, msgpcode.Map32:
err = d.s.UnreadByte()
if err != nil {
return nil, err
}
return d.DecodeMap()
case codes.FixExt1, codes.FixExt2, codes.FixExt4, codes.FixExt8, codes.FixExt16,
codes.Ext8, codes.Ext16, codes.Ext32:
return d.extInterface(c)
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)
@@ -452,49 +450,49 @@ func (d *Decoder) DecodeInterfaceLoose() (interface{}, error) {
return nil, err
}
if codes.IsFixedNum(c) {
if msgpcode.IsFixedNum(c) {
return int64(int8(c)), nil
}
if codes.IsFixedMap(c) {
if msgpcode.IsFixedMap(c) {
err = d.s.UnreadByte()
if err != nil {
return nil, err
}
return d.DecodeMap()
return d.decodeMapDefault()
}
if codes.IsFixedArray(c) {
if msgpcode.IsFixedArray(c) {
return d.decodeSlice(c)
}
if codes.IsFixedString(c) {
if msgpcode.IsFixedString(c) {
return d.string(c)
}
switch c {
case codes.Nil:
case msgpcode.Nil:
return nil, nil
case codes.False, codes.True:
case msgpcode.False, msgpcode.True:
return d.bool(c)
case codes.Float, codes.Double:
case msgpcode.Float, msgpcode.Double:
return d.float64(c)
case codes.Uint8, codes.Uint16, codes.Uint32, codes.Uint64:
case msgpcode.Uint8, msgpcode.Uint16, msgpcode.Uint32, msgpcode.Uint64:
return d.uint(c)
case codes.Int8, codes.Int16, codes.Int32, codes.Int64:
case msgpcode.Int8, msgpcode.Int16, msgpcode.Int32, msgpcode.Int64:
return d.int(c)
case codes.Bin8, codes.Bin16, codes.Bin32:
case msgpcode.Bin8, msgpcode.Bin16, msgpcode.Bin32:
return d.bytes(c, nil)
case codes.Str8, codes.Str16, codes.Str32:
case msgpcode.Str8, msgpcode.Str16, msgpcode.Str32:
return d.string(c)
case codes.Array16, codes.Array32:
case msgpcode.Array16, msgpcode.Array32:
return d.decodeSlice(c)
case codes.Map16, codes.Map32:
case msgpcode.Map16, msgpcode.Map32:
err = d.s.UnreadByte()
if err != nil {
return nil, err
}
return d.DecodeMap()
case codes.FixExt1, codes.FixExt2, codes.FixExt4, codes.FixExt8, codes.FixExt16,
codes.Ext8, codes.Ext16, codes.Ext32:
return d.extInterface(c)
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)
@@ -507,40 +505,40 @@ func (d *Decoder) Skip() error {
return err
}
if codes.IsFixedNum(c) {
if msgpcode.IsFixedNum(c) {
return nil
}
if codes.IsFixedMap(c) {
if msgpcode.IsFixedMap(c) {
return d.skipMap(c)
}
if codes.IsFixedArray(c) {
if msgpcode.IsFixedArray(c) {
return d.skipSlice(c)
}
if codes.IsFixedString(c) {
if msgpcode.IsFixedString(c) {
return d.skipBytes(c)
}
switch c {
case codes.Nil, codes.False, codes.True:
case msgpcode.Nil, msgpcode.False, msgpcode.True:
return nil
case codes.Uint8, codes.Int8:
case msgpcode.Uint8, msgpcode.Int8:
return d.skipN(1)
case codes.Uint16, codes.Int16:
case msgpcode.Uint16, msgpcode.Int16:
return d.skipN(2)
case codes.Uint32, codes.Int32, codes.Float:
case msgpcode.Uint32, msgpcode.Int32, msgpcode.Float:
return d.skipN(4)
case codes.Uint64, codes.Int64, codes.Double:
case msgpcode.Uint64, msgpcode.Int64, msgpcode.Double:
return d.skipN(8)
case codes.Bin8, codes.Bin16, codes.Bin32:
case msgpcode.Bin8, msgpcode.Bin16, msgpcode.Bin32:
return d.skipBytes(c)
case codes.Str8, codes.Str16, codes.Str32:
case msgpcode.Str8, msgpcode.Str16, msgpcode.Str32:
return d.skipBytes(c)
case codes.Array16, codes.Array32:
case msgpcode.Array16, msgpcode.Array32:
return d.skipSlice(c)
case codes.Map16, codes.Map32:
case msgpcode.Map16, msgpcode.Map32:
return d.skipMap(c)
case codes.FixExt1, codes.FixExt2, codes.FixExt4, codes.FixExt8, codes.FixExt16,
codes.Ext8, codes.Ext16, codes.Ext32:
case msgpcode.FixExt1, msgpcode.FixExt2, msgpcode.FixExt4, msgpcode.FixExt8, msgpcode.FixExt16,
msgpcode.Ext8, msgpcode.Ext16, msgpcode.Ext32:
return d.skipExt(c)
}
@@ -558,13 +556,13 @@ func (d *Decoder) DecodeRaw() (RawMessage, error) {
}
// PeekCode returns the next MessagePack code without advancing the reader.
// Subpackage msgpack/codes defines list of available codes.
func (d *Decoder) PeekCode() (codes.Code, error) {
// 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 codes.Code(c), d.s.UnreadByte()
return c, d.s.UnreadByte()
}
// ReadFull reads exactly len(buf) bytes into the buf.
@@ -575,11 +573,10 @@ func (d *Decoder) ReadFull(buf []byte) error {
func (d *Decoder) hasNilCode() bool {
code, err := d.PeekCode()
return err == nil && code == codes.Nil
return err == nil && code == msgpcode.Nil
}
func (d *Decoder) readCode() (codes.Code, error) {
d.extLen = 0
func (d *Decoder) readCode() (byte, error) {
c, err := d.s.ReadByte()
if err != nil {
return 0, err
@@ -587,7 +584,7 @@ func (d *Decoder) readCode() (codes.Code, error) {
if d.rec != nil {
d.rec = append(d.rec, c)
}
return codes.Code(c), nil
return c, nil
}
func (d *Decoder) readFull(b []byte) error {
@@ -608,7 +605,7 @@ func (d *Decoder) readN(n int) ([]byte, error) {
return nil, err
}
if d.rec != nil {
//TODO: read directly into d.rec?
// TODO: read directly into d.rec?
d.rec = append(d.rec, d.buf...)
}
return d.buf, nil

177
vendor/github.com/vmihailenco/msgpack/v5/decode_map.go сгенерированный поставляемый
Просмотреть файл

@@ -1,11 +1,10 @@
package msgpack
import (
"errors"
"fmt"
"reflect"
"github.com/vmihailenco/msgpack/v5/codes"
"github.com/vmihailenco/msgpack/v5/msgpcode"
)
var (
@@ -19,13 +18,13 @@ var (
)
func decodeMapValue(d *Decoder, v reflect.Value) error {
size, err := d.DecodeMapLen()
n, err := d.DecodeMapLen()
if err != nil {
return err
}
typ := v.Type()
if size == -1 {
if n == -1 {
v.Set(reflect.Zero(typ))
return nil
}
@@ -33,33 +32,18 @@ func decodeMapValue(d *Decoder, v reflect.Value) error {
if v.IsNil() {
v.Set(reflect.MakeMap(typ))
}
if size == 0 {
if n == 0 {
return nil
}
return decodeMapValueSize(d, v, size)
return d.decodeTypedMapValue(v, n)
}
func decodeMapValueSize(d *Decoder, v reflect.Value, size int) error {
typ := v.Type()
keyType := typ.Key()
valueType := typ.Elem()
for i := 0; i < size; i++ {
mk := reflect.New(keyType).Elem()
if err := d.DecodeValue(mk); err != nil {
return err
}
mv := reflect.New(valueType).Elem()
if err := d.DecodeValue(mv); err != nil {
return err
}
v.SetMapIndex(mk, mv)
func (d *Decoder) decodeMapDefault() (interface{}, error) {
if d.mapDecoder != nil {
return d.mapDecoder(d)
}
return nil
return d.DecodeMap()
}
// DecodeMapLen decodes map length. Length is -1 when map is nil.
@@ -69,7 +53,7 @@ func (d *Decoder) DecodeMapLen() (int, error) {
return 0, err
}
if codes.IsExt(c) {
if msgpcode.IsExt(c) {
if err = d.skipExtHeader(c); err != nil {
return 0, err
}
@@ -82,37 +66,22 @@ func (d *Decoder) DecodeMapLen() (int, error) {
return d.mapLen(c)
}
func (d *Decoder) mapLen(c codes.Code) (int, error) {
size, err := d._mapLen(c)
err = expandInvalidCodeMapLenError(c, err)
return size, err
}
func (d *Decoder) _mapLen(c codes.Code) (int, error) {
if c == codes.Nil {
func (d *Decoder) mapLen(c byte) (int, error) {
if c == msgpcode.Nil {
return -1, nil
}
if c >= codes.FixedMapLow && c <= codes.FixedMapHigh {
return int(c & codes.FixedMapMask), nil
if c >= msgpcode.FixedMapLow && c <= msgpcode.FixedMapHigh {
return int(c & msgpcode.FixedMapMask), nil
}
if c == codes.Map16 {
if c == msgpcode.Map16 {
size, err := d.uint16()
return int(size), err
}
if c == codes.Map32 {
if c == msgpcode.Map32 {
size, err := d.uint32()
return int(size), err
}
return 0, errInvalidCode
}
var errInvalidCode = errors.New("invalid code")
func expandInvalidCodeMapLenError(c codes.Code, err error) error {
if err == errInvalidCode {
return fmt.Errorf("msgpack: invalid code=%x decoding map length", c)
}
return err
return 0, unexpectedCodeError{code: c, hint: "map length"}
}
func decodeMapStringStringValue(d *Decoder, v reflect.Value) error {
@@ -157,59 +126,79 @@ func decodeMapStringInterfaceValue(d *Decoder, v reflect.Value) error {
}
func (d *Decoder) decodeMapStringInterfacePtr(ptr *map[string]interface{}) error {
n, err := d.DecodeMapLen()
m, err := d.DecodeMap()
if err != nil {
return err
}
if n == -1 {
*ptr = nil
return nil
*ptr = m
return nil
}
func (d *Decoder) DecodeMap() (map[string]interface{}, error) {
n, err := d.DecodeMapLen()
if err != nil {
return nil, err
}
m := *ptr
if m == nil {
*ptr = make(map[string]interface{}, min(n, maxMapSize))
m = *ptr
if n == -1 {
return nil, nil
}
m := make(map[string]interface{}, min(n, maxMapSize))
for i := 0; i < n; i++ {
mk, err := d.DecodeString()
if err != nil {
return err
return nil, err
}
mv, err := d.decodeInterfaceCond()
if err != nil {
return err
return nil, err
}
m[mk] = mv
}
return nil
return m, nil
}
func (d *Decoder) DecodeMap() (interface{}, error) {
if d.decodeMapFunc != nil {
return d.decodeMapFunc(d)
}
size, err := d.DecodeMapLen()
func (d *Decoder) DecodeUntypedMap() (map[interface{}]interface{}, error) {
n, err := d.DecodeMapLen()
if err != nil {
return nil, err
}
if size == -1 {
if n == -1 {
return nil, nil
}
if size == 0 {
return make(map[string]interface{}), nil
m := make(map[interface{}]interface{}, min(n, maxMapSize))
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
}
code, err := d.PeekCode()
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 codes.IsString(code) || codes.IsBin(code) {
return d.decodeMapStringInterfaceSize(size)
if n <= 0 {
return nil, nil
}
key, err := d.decodeInterfaceCond()
@@ -225,37 +214,45 @@ func (d *Decoder) DecodeMap() (interface{}, error) {
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)
mapValue := reflect.MakeMap(mapType)
mapValue.SetMapIndex(reflect.ValueOf(key), reflect.ValueOf(value))
size--
err = decodeMapValueSize(d, mapValue, size)
if err != nil {
n--
if err := d.decodeTypedMapValue(mapValue, n); err != nil {
return nil, err
}
return mapValue.Interface(), nil
}
func (d *Decoder) decodeMapStringInterfaceSize(size int) (map[string]interface{}, error) {
m := make(map[string]interface{}, min(size, maxMapSize))
for i := 0; i < size; i++ {
mk, err := d.DecodeString()
if err != nil {
return nil, err
func (d *Decoder) decodeTypedMapValue(v reflect.Value, n int) error {
typ := v.Type()
keyType := typ.Key()
valueType := typ.Elem()
for i := 0; i < n; i++ {
mk := reflect.New(keyType).Elem()
if err := d.DecodeValue(mk); err != nil {
return err
}
mv, err := d.decodeInterfaceCond()
if err != nil {
return nil, err
mv := reflect.New(valueType).Elem()
if err := d.DecodeValue(mv); err != nil {
return err
}
m[mk] = mv
v.SetMapIndex(mk, mv)
}
return m, nil
return nil
}
func (d *Decoder) skipMap(c codes.Code) error {
func (d *Decoder) skipMap(c byte) error {
n, err := d.mapLen(c)
if err != nil {
return err
@@ -279,12 +276,12 @@ func decodeStructValue(d *Decoder, v reflect.Value) error {
var isArray bool
n, err := d._mapLen(c)
n, err := d.mapLen(c)
if err != nil {
var err2 error
n, err2 = d.arrayLen(c)
if err2 != nil {
return expandInvalidCodeMapLenError(c, err)
return err
}
isArray = true
}

54
vendor/github.com/vmihailenco/msgpack/v5/decode_number.go сгенерированный поставляемый
Просмотреть файл

@@ -5,7 +5,7 @@ import (
"math"
"reflect"
"github.com/vmihailenco/msgpack/v5/codes"
"github.com/vmihailenco/msgpack/v5/msgpcode"
)
func (d *Decoder) skipN(n int) error {
@@ -18,7 +18,7 @@ func (d *Decoder) uint8() (uint8, error) {
if err != nil {
return 0, err
}
return uint8(c), nil
return c, nil
}
func (d *Decoder) int8() (int8, error) {
@@ -87,33 +87,33 @@ func (d *Decoder) DecodeUint64() (uint64, error) {
return d.uint(c)
}
func (d *Decoder) uint(c codes.Code) (uint64, error) {
if c == codes.Nil {
func (d *Decoder) uint(c byte) (uint64, error) {
if c == msgpcode.Nil {
return 0, nil
}
if codes.IsFixedNum(c) {
if msgpcode.IsFixedNum(c) {
return uint64(int8(c)), nil
}
switch c {
case codes.Uint8:
case msgpcode.Uint8:
n, err := d.uint8()
return uint64(n), err
case codes.Int8:
case msgpcode.Int8:
n, err := d.int8()
return uint64(n), err
case codes.Uint16:
case msgpcode.Uint16:
n, err := d.uint16()
return uint64(n), err
case codes.Int16:
case msgpcode.Int16:
n, err := d.int16()
return uint64(n), err
case codes.Uint32:
case msgpcode.Uint32:
n, err := d.uint32()
return uint64(n), err
case codes.Int32:
case msgpcode.Int32:
n, err := d.int32()
return uint64(n), err
case codes.Uint64, codes.Int64:
case msgpcode.Uint64, msgpcode.Int64:
return d.uint64()
}
return 0, fmt.Errorf("msgpack: invalid code=%x decoding uint64", c)
@@ -129,33 +129,33 @@ func (d *Decoder) DecodeInt64() (int64, error) {
return d.int(c)
}
func (d *Decoder) int(c codes.Code) (int64, error) {
if c == codes.Nil {
func (d *Decoder) int(c byte) (int64, error) {
if c == msgpcode.Nil {
return 0, nil
}
if codes.IsFixedNum(c) {
if msgpcode.IsFixedNum(c) {
return int64(int8(c)), nil
}
switch c {
case codes.Uint8:
case msgpcode.Uint8:
n, err := d.uint8()
return int64(n), err
case codes.Int8:
case msgpcode.Int8:
n, err := d.uint8()
return int64(int8(n)), err
case codes.Uint16:
case msgpcode.Uint16:
n, err := d.uint16()
return int64(n), err
case codes.Int16:
case msgpcode.Int16:
n, err := d.uint16()
return int64(int16(n)), err
case codes.Uint32:
case msgpcode.Uint32:
n, err := d.uint32()
return int64(n), err
case codes.Int32:
case msgpcode.Int32:
n, err := d.uint32()
return int64(int32(n)), err
case codes.Uint64, codes.Int64:
case msgpcode.Uint64, msgpcode.Int64:
n, err := d.uint64()
return int64(n), err
}
@@ -170,8 +170,8 @@ func (d *Decoder) DecodeFloat32() (float32, error) {
return d.float32(c)
}
func (d *Decoder) float32(c codes.Code) (float32, error) {
if c == codes.Float {
func (d *Decoder) float32(c byte) (float32, error) {
if c == msgpcode.Float {
n, err := d.uint32()
if err != nil {
return 0, err
@@ -195,15 +195,15 @@ func (d *Decoder) DecodeFloat64() (float64, error) {
return d.float64(c)
}
func (d *Decoder) float64(c codes.Code) (float64, error) {
func (d *Decoder) float64(c byte) (float64, error) {
switch c {
case codes.Float:
case msgpcode.Float:
n, err := d.float32(c)
if err != nil {
return 0, err
}
return float64(n), nil
case codes.Double:
case msgpcode.Double:
n, err := d.uint64()
if err != nil {
return 0, err

6
vendor/github.com/vmihailenco/msgpack/v5/decode_query.go сгенерированный поставляемый
Просмотреть файл

@@ -5,7 +5,7 @@ import (
"strconv"
"strings"
"github.com/vmihailenco/msgpack/v5/codes"
"github.com/vmihailenco/msgpack/v5/msgpcode"
)
type queryResult struct {
@@ -57,9 +57,9 @@ func (d *Decoder) query(q *queryResult) error {
}
switch {
case code == codes.Map16 || code == codes.Map32 || codes.IsFixedMap(code):
case code == msgpcode.Map16 || code == msgpcode.Map32 || msgpcode.IsFixedMap(code):
err = d.queryMapKey(q)
case code == codes.Array16 || code == codes.Array32 || codes.IsFixedArray(code):
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)

18
vendor/github.com/vmihailenco/msgpack/v5/decode_slice.go сгенерированный поставляемый
Просмотреть файл

@@ -4,7 +4,7 @@ import (
"fmt"
"reflect"
"github.com/vmihailenco/msgpack/v5/codes"
"github.com/vmihailenco/msgpack/v5/msgpcode"
)
var sliceStringPtrType = reflect.TypeOf((*[]string)(nil))
@@ -18,17 +18,17 @@ func (d *Decoder) DecodeArrayLen() (int, error) {
return d.arrayLen(c)
}
func (d *Decoder) arrayLen(c codes.Code) (int, error) {
if c == codes.Nil {
func (d *Decoder) arrayLen(c byte) (int, error) {
if c == msgpcode.Nil {
return -1, nil
} else if c >= codes.FixedArrayLow && c <= codes.FixedArrayHigh {
return int(c & codes.FixedArrayMask), nil
} else if c >= msgpcode.FixedArrayLow && c <= msgpcode.FixedArrayHigh {
return int(c & msgpcode.FixedArrayMask), nil
}
switch c {
case codes.Array16:
case msgpcode.Array16:
n, err := d.uint16()
return int(n), err
case codes.Array32:
case msgpcode.Array32:
n, err := d.uint32()
return int(n), err
}
@@ -154,7 +154,7 @@ func (d *Decoder) DecodeSlice() ([]interface{}, error) {
return d.decodeSlice(c)
}
func (d *Decoder) decodeSlice(c codes.Code) ([]interface{}, error) {
func (d *Decoder) decodeSlice(c byte) ([]interface{}, error) {
n, err := d.arrayLen(c)
if err != nil {
return nil, err
@@ -175,7 +175,7 @@ func (d *Decoder) decodeSlice(c codes.Code) ([]interface{}, error) {
return s, nil
}
func (d *Decoder) skipSlice(c codes.Code) error {
func (d *Decoder) skipSlice(c byte) error {
n, err := d.arrayLen(c)
if err != nil {
return err

30
vendor/github.com/vmihailenco/msgpack/v5/decode_string.go сгенерированный поставляемый
Просмотреть файл

@@ -4,34 +4,38 @@ import (
"fmt"
"reflect"
"github.com/vmihailenco/msgpack/v5/codes"
"github.com/vmihailenco/msgpack/v5/msgpcode"
)
func (d *Decoder) bytesLen(c codes.Code) (int, error) {
if c == codes.Nil {
func (d *Decoder) bytesLen(c byte) (int, error) {
if c == msgpcode.Nil {
return -1, nil
}
if codes.IsFixedString(c) {
return int(c & codes.FixedStrMask), nil
if msgpcode.IsFixedString(c) {
return int(c & msgpcode.FixedStrMask), nil
}
switch c {
case codes.Str8, codes.Bin8:
case msgpcode.Str8, msgpcode.Bin8:
n, err := d.uint8()
return int(n), err
case codes.Str16, codes.Bin16:
case msgpcode.Str16, msgpcode.Bin16:
n, err := d.uint16()
return int(n), err
case codes.Str32, codes.Bin32:
case msgpcode.Str32, msgpcode.Bin32:
n, err := d.uint32()
return int(n), err
}
return 0, fmt.Errorf("msgpack: invalid code=%x decoding bytes length", c)
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
@@ -39,7 +43,7 @@ func (d *Decoder) DecodeString() (string, error) {
return d.string(c)
}
func (d *Decoder) string(c codes.Code) (string, error) {
func (d *Decoder) string(c byte) (string, error) {
n, err := d.bytesLen(c)
if err != nil {
return "", err
@@ -80,7 +84,7 @@ func (d *Decoder) DecodeBytes() ([]byte, error) {
return d.bytes(c, nil)
}
func (d *Decoder) bytes(c codes.Code, b []byte) ([]byte, error) {
func (d *Decoder) bytes(c byte, b []byte) ([]byte, error) {
n, err := d.bytesLen(c)
if err != nil {
return nil, err
@@ -114,7 +118,7 @@ func (d *Decoder) decodeBytesPtr(ptr *[]byte) error {
return d.bytesPtr(c, ptr)
}
func (d *Decoder) bytesPtr(c codes.Code, ptr *[]byte) error {
func (d *Decoder) bytesPtr(c byte, ptr *[]byte) error {
n, err := d.bytesLen(c)
if err != nil {
return err
@@ -128,7 +132,7 @@ func (d *Decoder) bytesPtr(c codes.Code, ptr *[]byte) error {
return err
}
func (d *Decoder) skipBytes(c codes.Code) error {
func (d *Decoder) skipBytes(c byte) error {
n, err := d.bytesLen(c)
if err != nil {
return err

71
vendor/github.com/vmihailenco/msgpack/v5/decode_value.go сгенерированный поставляемый
Просмотреть файл

@@ -7,8 +7,10 @@ import (
"reflect"
)
var interfaceType = reflect.TypeOf((*interface{})(nil)).Elem()
var stringType = reflect.TypeOf((*string)(nil)).Elem()
var (
interfaceType = reflect.TypeOf((*interface{})(nil)).Elem()
stringType = reflect.TypeOf((*string)(nil)).Elem()
)
var valueDecoders []decoderFunc
@@ -70,6 +72,9 @@ func _getDecoder(typ reflect.Type) decoderFunc {
if typ.Implements(binaryUnmarshalerType) {
return unmarshalBinaryValue
}
if typ.Implements(textUnmarshalerType) {
return unmarshalTextValue
}
// Addressable struct field value.
if kind != reflect.Ptr {
@@ -83,6 +88,9 @@ func _getDecoder(typ reflect.Type) decoderFunc {
if ptr.Implements(binaryUnmarshalerType) {
return unmarshalBinaryValueAddr
}
if ptr.Implements(textUnmarshalerType) {
return unmarshalTextValueAddr
}
}
switch kind {
@@ -158,10 +166,8 @@ func unmarshalValueAddr(d *Decoder, v reflect.Value) error {
}
func unmarshalValue(d *Decoder, v reflect.Value) error {
if d.extLen == 0 || d.extLen == 1 {
if d.hasNilCode() {
return d.decodeNilValue(v)
}
if d.hasNilCode() {
return d.decodeNilValue(v)
}
if v.IsNil() {
@@ -170,20 +176,12 @@ func unmarshalValue(d *Decoder, v reflect.Value) error {
var b []byte
if d.extLen != 0 {
var err error
b, err = d.readN(d.extLen)
if err != nil {
return err
}
} else {
d.rec = make([]byte, 0, 64)
if err := d.Skip(); err != nil {
return err
}
b = d.rec
d.rec = nil
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)
@@ -202,13 +200,7 @@ func decodeInterfaceValue(d *Decoder, v reflect.Value) error {
if v.IsNil() {
return d.interfaceValue(v)
}
elem := v.Elem()
if !elem.CanSet() {
return d.interfaceValue(v)
}
return d.DecodeValue(elem)
return d.DecodeValue(v.Elem())
}
func (d *Decoder) interfaceValue(v reflect.Value) error {
@@ -261,3 +253,30 @@ func unmarshalBinaryValue(d *Decoder, v reflect.Value) error {
unmarshaler := v.Interface().(encoding.BinaryUnmarshaler)
return unmarshaler.UnmarshalBinary(data)
}
//------------------------------------------------------------------------------
func unmarshalTextValueAddr(d *Decoder, v reflect.Value) error {
if !v.CanAddr() {
return fmt.Errorf("msgpack: Decode(nonaddressable %T)", v.Interface())
}
return unmarshalTextValue(d, v.Addr())
}
func unmarshalTextValue(d *Decoder, v reflect.Value) error {
if d.hasNilCode() {
return d.decodeNilValue(v)
}
if v.IsNil() {
v.Set(reflect.New(v.Type().Elem()))
}
data, err := d.DecodeBytes()
if err != nil {
return err
}
unmarshaler := v.Interface().(encoding.TextUnmarshaler)
return unmarshaler.UnmarshalText(data)
}

116
vendor/github.com/vmihailenco/msgpack/v5/encode.go сгенерированный поставляемый
Просмотреть файл

@@ -7,14 +7,15 @@ import (
"sync"
"time"
"github.com/vmihailenco/msgpack/v5/codes"
"github.com/vmihailenco/msgpack/v5/msgpcode"
)
const (
sortMapKeysFlag uint32 = 1 << iota
structAsArrayFlag
arrayEncodedStructsFlag
useCompactIntsFlag
useCompactFloatsFlag
useInternedStringsFlag
)
type writer interface {
@@ -24,23 +25,16 @@ type writer interface {
type byteWriter struct {
io.Writer
buf [1]byte
}
func newByteWriter(w io.Writer) *byteWriter {
bw := new(byteWriter)
bw.Reset(w)
return bw
func newByteWriter(w io.Writer) byteWriter {
return byteWriter{
Writer: w,
}
}
func (bw *byteWriter) Reset(w io.Writer) {
bw.Writer = w
}
func (bw *byteWriter) WriteByte(c byte) error {
bw.buf[0] = c
_, err := bw.Write(bw.buf[:])
func (bw byteWriter) WriteByte(c byte) error {
_, err := bw.Write([]byte{c})
return err
}
@@ -85,7 +79,7 @@ type Encoder struct {
buf []byte
timeBuf []byte
intern map[string]int
dict map[string]int
flags uint32
structTag string
@@ -105,27 +99,42 @@ 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.SetDict(dict)
}
func (e *Encoder) SetDict(dict map[string]int) {
if len(dict) > 0 {
e.dict = dict
} else {
for k := range e.dict {
delete(e.dict, k)
}
}
}
func (e *Encoder) resetWriter(w io.Writer) {
if bw, ok := w.(writer); ok {
e.w = bw
} else if bw, ok := e.w.(*byteWriter); ok {
bw.Reset(w)
} else {
e.w = newByteWriter(w)
}
for k := range e.intern {
delete(e.intern, k)
}
e.flags = 0
}
// SortMapKeys causes the Encoder to encode map keys in increasing order.
// SetSortMapKeys causes the Encoder to encode map keys in increasing order.
// Supported map types are:
// - map[string]string
// - map[string]interface{}
func (e *Encoder) SortMapKeys(on bool) *Encoder {
func (e *Encoder) SetSortMapKeys(on bool) *Encoder {
if on {
e.flags |= sortMapKeysFlag
} else {
@@ -134,31 +143,21 @@ func (e *Encoder) SortMapKeys(on bool) *Encoder {
return e
}
// StructAsArray causes the Encoder to encode Go structs as msgpack arrays.
func (e *Encoder) StructAsArray(on bool) {
if on {
e.flags |= structAsArrayFlag
} else {
e.flags &= ^structAsArrayFlag
}
}
// UseJSONTag causes the Encoder to use json struct tag as fallback option
// if there is no msgpack tag.
func (e *Encoder) UseJSONTag(on bool) {
if on {
e.UseCustomStructTag("json")
} else {
e.UseCustomStructTag("")
}
}
// UseCustomStructTag causes the Encoder to use a custom struct tag as
// SetCustomStructTag causes the Encoder to use a custom struct tag as
// fallback option if there is no msgpack tag.
func (e *Encoder) UseCustomStructTag(tag string) {
func (e *Encoder) SetCustomStructTag(tag string) {
e.structTag = tag
}
// 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) {
@@ -179,6 +178,15 @@ func (e *Encoder) UseCompactFloats(on bool) {
}
}
// 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:
@@ -188,11 +196,11 @@ func (e *Encoder) Encode(v interface{}) error {
case []byte:
return e.EncodeBytes(v)
case int:
return e.encodeInt64Cond(int64(v))
return e.EncodeInt(int64(v))
case int64:
return e.encodeInt64Cond(v)
case uint:
return e.encodeUint64Cond(uint64(v))
return e.EncodeUint(uint64(v))
case uint64:
return e.encodeUint64Cond(v)
case bool:
@@ -224,22 +232,22 @@ func (e *Encoder) EncodeValue(v reflect.Value) error {
}
func (e *Encoder) EncodeNil() error {
return e.writeCode(codes.Nil)
return e.writeCode(msgpcode.Nil)
}
func (e *Encoder) EncodeBool(value bool) error {
if value {
return e.writeCode(codes.True)
return e.writeCode(msgpcode.True)
}
return e.writeCode(codes.False)
return e.writeCode(msgpcode.False)
}
func (e *Encoder) EncodeDuration(d time.Duration) error {
return e.EncodeInt(int64(d))
}
func (e *Encoder) writeCode(c codes.Code) error {
return e.w.WriteByte(byte(c))
func (e *Encoder) writeCode(c byte) error {
return e.w.WriteByte(c)
}
func (e *Encoder) write(b []byte) error {

76
vendor/github.com/vmihailenco/msgpack/v5/encode_map.go сгенерированный поставляемый
Просмотреть файл

@@ -1,10 +1,11 @@
package msgpack
import (
"math"
"reflect"
"sort"
"github.com/vmihailenco/msgpack/v5/codes"
"github.com/vmihailenco/msgpack/v5/msgpcode"
)
func encodeMapValue(e *Encoder, v reflect.Value) error {
@@ -58,16 +59,20 @@ func encodeMapStringInterfaceValue(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(mapStringInterfaceType).Interface().(map[string]interface{})
if e.flags&sortMapKeysFlag != 0 {
return e.encodeSortedMapStringInterface(m)
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
@@ -76,6 +81,33 @@ func encodeMapStringInterfaceValue(e *Encoder, v reflect.Value) error {
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
}
@@ -100,39 +132,19 @@ func (e *Encoder) encodeSortedMapStringString(m map[string]string) error {
return nil
}
func (e *Encoder) encodeSortedMapStringInterface(m map[string]interface{}) 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.Encode(m[k]); err != nil {
return err
}
}
return nil
}
func (e *Encoder) EncodeMapLen(l int) error {
if l < 16 {
return e.writeCode(codes.FixedMapLow | codes.Code(l))
return e.writeCode(msgpcode.FixedMapLow | byte(l))
}
if l < 65536 {
return e.write2(codes.Map16, uint16(l))
if l <= math.MaxUint16 {
return e.write2(msgpcode.Map16, uint16(l))
}
return e.write4(codes.Map32, uint32(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&structAsArrayFlag != 0 || structFields.AsArray {
if e.flags&arrayEncodedStructsFlag != 0 || structFields.AsArray {
return encodeStructValueAsArray(e, strct, structFields.List)
}
fields := structFields.OmitEmpty(strct)

48
vendor/github.com/vmihailenco/msgpack/v5/encode_number.go сгенерированный поставляемый
Просмотреть файл

@@ -4,12 +4,12 @@ import (
"math"
"reflect"
"github.com/vmihailenco/msgpack/v5/codes"
"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(codes.Uint8, n)
return e.write1(msgpcode.Uint8, n)
}
func (e *Encoder) encodeUint8Cond(n uint8) error {
@@ -21,7 +21,7 @@ func (e *Encoder) encodeUint8Cond(n uint8) error {
// EncodeUint16 encodes an uint16 in 3 bytes preserving type of the number.
func (e *Encoder) EncodeUint16(n uint16) error {
return e.write2(codes.Uint16, n)
return e.write2(msgpcode.Uint16, n)
}
func (e *Encoder) encodeUint16Cond(n uint16) error {
@@ -33,7 +33,7 @@ func (e *Encoder) encodeUint16Cond(n uint16) error {
// EncodeUint32 encodes an uint16 in 5 bytes preserving type of the number.
func (e *Encoder) EncodeUint32(n uint32) error {
return e.write4(codes.Uint32, n)
return e.write4(msgpcode.Uint32, n)
}
func (e *Encoder) encodeUint32Cond(n uint32) error {
@@ -45,7 +45,7 @@ func (e *Encoder) encodeUint32Cond(n uint32) error {
// EncodeUint64 encodes an uint16 in 9 bytes preserving type of the number.
func (e *Encoder) EncodeUint64(n uint64) error {
return e.write8(codes.Uint64, n)
return e.write8(msgpcode.Uint64, n)
}
func (e *Encoder) encodeUint64Cond(n uint64) error {
@@ -57,7 +57,7 @@ func (e *Encoder) encodeUint64Cond(n uint64) error {
// EncodeInt8 encodes an int8 in 2 bytes preserving type of the number.
func (e *Encoder) EncodeInt8(n int8) error {
return e.write1(codes.Int8, uint8(n))
return e.write1(msgpcode.Int8, uint8(n))
}
func (e *Encoder) encodeInt8Cond(n int8) error {
@@ -69,7 +69,7 @@ func (e *Encoder) encodeInt8Cond(n int8) error {
// EncodeInt16 encodes an int16 in 3 bytes preserving type of the number.
func (e *Encoder) EncodeInt16(n int16) error {
return e.write2(codes.Int16, uint16(n))
return e.write2(msgpcode.Int16, uint16(n))
}
func (e *Encoder) encodeInt16Cond(n int16) error {
@@ -81,7 +81,7 @@ func (e *Encoder) encodeInt16Cond(n int16) error {
// EncodeInt32 encodes an int32 in 5 bytes preserving type of the number.
func (e *Encoder) EncodeInt32(n int32) error {
return e.write4(codes.Int32, uint32(n))
return e.write4(msgpcode.Int32, uint32(n))
}
func (e *Encoder) encodeInt32Cond(n int32) error {
@@ -93,7 +93,7 @@ func (e *Encoder) encodeInt32Cond(n int32) error {
// EncodeInt64 encodes an int64 in 9 bytes preserving type of the number.
func (e *Encoder) EncodeInt64(n int64) error {
return e.write8(codes.Int64, uint64(n))
return e.write8(msgpcode.Int64, uint64(n))
}
func (e *Encoder) encodeInt64Cond(n int64) error {
@@ -127,7 +127,7 @@ func (e *Encoder) EncodeInt(n int64) error {
if n >= 0 {
return e.EncodeUint(uint64(n))
}
if n >= int64(int8(codes.NegFixedNumLow)) {
if n >= int64(int8(msgpcode.NegFixedNumLow)) {
return e.w.WriteByte(byte(n))
}
if n >= math.MinInt8 {
@@ -148,7 +148,7 @@ func (e *Encoder) EncodeFloat32(n float32) error {
return e.EncodeInt(int64(n))
}
}
return e.write4(codes.Float, math.Float32bits(n))
return e.write4(msgpcode.Float, math.Float32bits(n))
}
func (e *Encoder) EncodeFloat64(n float64) error {
@@ -161,27 +161,27 @@ func (e *Encoder) EncodeFloat64(n float64) error {
return e.EncodeInt(int64(n))
}
}
return e.write8(codes.Double, math.Float64bits(n))
return e.write8(msgpcode.Double, math.Float64bits(n))
}
func (e *Encoder) write1(code codes.Code, n uint8) error {
func (e *Encoder) write1(code byte, n uint8) error {
e.buf = e.buf[:2]
e.buf[0] = byte(code)
e.buf[0] = code
e.buf[1] = n
return e.write(e.buf)
}
func (e *Encoder) write2(code codes.Code, n uint16) error {
func (e *Encoder) write2(code byte, n uint16) error {
e.buf = e.buf[:3]
e.buf[0] = byte(code)
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 codes.Code, n uint32) error {
func (e *Encoder) write4(code byte, n uint32) error {
e.buf = e.buf[:5]
e.buf[0] = byte(code)
e.buf[0] = code
e.buf[1] = byte(n >> 24)
e.buf[2] = byte(n >> 16)
e.buf[3] = byte(n >> 8)
@@ -189,9 +189,9 @@ func (e *Encoder) write4(code codes.Code, n uint32) error {
return e.write(e.buf)
}
func (e *Encoder) write8(code codes.Code, n uint64) error {
func (e *Encoder) write8(code byte, n uint64) error {
e.buf = e.buf[:9]
e.buf[0] = byte(code)
e.buf[0] = code
e.buf[1] = byte(n >> 56)
e.buf[2] = byte(n >> 48)
e.buf[3] = byte(n >> 40)
@@ -203,6 +203,14 @@ func (e *Encoder) write8(code codes.Code, n uint64) error {
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()))
}

40
vendor/github.com/vmihailenco/msgpack/v5/encode_slice.go сгенерированный поставляемый
Просмотреть файл

@@ -1,9 +1,10 @@
package msgpack
import (
"math"
"reflect"
"github.com/vmihailenco/msgpack/v5/codes"
"github.com/vmihailenco/msgpack/v5/msgpcode"
)
var stringSliceType = reflect.TypeOf(([]string)(nil))
@@ -42,29 +43,36 @@ func grow(b []byte, n int) []byte {
func (e *Encoder) EncodeBytesLen(l int) error {
if l < 256 {
return e.write1(codes.Bin8, uint8(l))
return e.write1(msgpcode.Bin8, uint8(l))
}
if l < 65536 {
return e.write2(codes.Bin16, uint16(l))
if l <= math.MaxUint16 {
return e.write2(msgpcode.Bin16, uint16(l))
}
return e.write4(codes.Bin32, uint32(l))
return e.write4(msgpcode.Bin32, uint32(l))
}
func (e *Encoder) encodeStrLen(l int) error {
func (e *Encoder) encodeStringLen(l int) error {
if l < 32 {
return e.writeCode(codes.FixedStrLow | codes.Code(l))
return e.writeCode(msgpcode.FixedStrLow | byte(l))
}
if l < 256 {
return e.write1(codes.Str8, uint8(l))
return e.write1(msgpcode.Str8, uint8(l))
}
if l < 65536 {
return e.write2(codes.Str16, uint16(l))
if l <= math.MaxUint16 {
return e.write2(msgpcode.Str16, uint16(l))
}
return e.write4(codes.Str32, uint32(l))
return e.write4(msgpcode.Str32, uint32(l))
}
func (e *Encoder) EncodeString(v string) error {
if err := e.encodeStrLen(len(v)); err != nil {
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)
@@ -82,12 +90,12 @@ func (e *Encoder) EncodeBytes(v []byte) error {
func (e *Encoder) EncodeArrayLen(l int) error {
if l < 16 {
return e.writeCode(codes.FixedArrayLow | codes.Code(l))
return e.writeCode(msgpcode.FixedArrayLow | byte(l))
}
if l < 65536 {
return e.write2(codes.Array16, uint16(l))
if l <= math.MaxUint16 {
return e.write2(msgpcode.Array16, uint16(l))
}
return e.write4(codes.Array32, uint32(l))
return e.write4(msgpcode.Array32, uint32(l))
}
func encodeStringSliceValue(e *Encoder, v reflect.Value) error {

37
vendor/github.com/vmihailenco/msgpack/v5/encode_value.go сгенерированный поставляемый
Просмотреть файл

@@ -12,12 +12,12 @@ var valueEncoders []encoderFunc
func init() {
valueEncoders = []encoderFunc{
reflect.Bool: encodeBoolValue,
reflect.Int: encodeInt64CondValue,
reflect.Int: encodeIntValue,
reflect.Int8: encodeInt8CondValue,
reflect.Int16: encodeInt16CondValue,
reflect.Int32: encodeInt32CondValue,
reflect.Int64: encodeInt64CondValue,
reflect.Uint: encodeUint64CondValue,
reflect.Uint: encodeUintValue,
reflect.Uint8: encodeUint8CondValue,
reflect.Uint16: encodeUint16CondValue,
reflect.Uint32: encodeUint32CondValue,
@@ -66,6 +66,9 @@ func _getEncoder(typ reflect.Type) encoderFunc {
if typ.Implements(binaryMarshalerType) {
return marshalBinaryValue
}
if typ.Implements(textMarshalerType) {
return marshalTextValue
}
// Addressable struct field value.
if kind != reflect.Ptr {
@@ -77,7 +80,10 @@ func _getEncoder(typ reflect.Type) encoderFunc {
return marshalValuePtr
}
if ptr.Implements(binaryMarshalerType) {
return marshalBinaryValuePtr
return marshalBinaryValueAddr
}
if ptr.Implements(textMarshalerType) {
return marshalTextValueAddr
}
}
@@ -194,7 +200,7 @@ func nilable(v reflect.Value) bool {
//------------------------------------------------------------------------------
func marshalBinaryValuePtr(e *Encoder, v reflect.Value) error {
func marshalBinaryValueAddr(e *Encoder, v reflect.Value) error {
if !v.CanAddr() {
return fmt.Errorf("msgpack: Encode(non-addressable %T)", v.Interface())
}
@@ -214,3 +220,26 @@ func marshalBinaryValue(e *Encoder, v reflect.Value) error {
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) && v.IsNil() {
return e.EncodeNil()
}
marshaler := v.Interface().(encoding.TextMarshaler)
data, err := marshaler.MarshalText()
if err != nil {
return err
}
return e.EncodeBytes(data)
}

374
vendor/github.com/vmihailenco/msgpack/v5/ext.go сгенерированный поставляемый
Просмотреть файл

@@ -1,182 +1,212 @@
package msgpack
import (
"bytes"
"fmt"
"math"
"reflect"
"sync"
"github.com/vmihailenco/msgpack/v5/codes"
"github.com/vmihailenco/msgpack/v5/msgpcode"
)
type extInfo struct {
Type reflect.Type
Decoder decoderFunc
Decoder func(d *Decoder, v reflect.Value, extLen int) error
}
var extTypes = make(map[int8]*extInfo)
var bufferPool = &sync.Pool{
New: func() interface{} {
return new(bytes.Buffer)
},
type MarshalerUnmarshaler interface {
Marshaler
Unmarshaler
}
// RegisterExt records a type, identified by a value for that type,
// under the provided id. That id will identify the concrete type of a value
// sent or received as an interface variable. Only types that will be
// transferred as implementations of interface values need to be registered.
// Expecting to be used only during initialization, it panics if the mapping
// between types and ids is not a bijection.
func RegisterExt(id int8, value interface{}) {
typ := reflect.TypeOf(value)
if typ.Kind() == reflect.Ptr {
typ = typ.Elem()
}
ptr := reflect.PtrTo(typ)
if _, ok := extTypes[id]; ok {
panic(fmt.Errorf("msgpack: ext with id=%d is already registered", id))
}
registerExt(id, ptr, getEncoder(ptr), getDecoder(ptr))
registerExt(id, typ, getEncoder(typ), getDecoder(typ))
}
func registerExt(id int8, typ reflect.Type, enc encoderFunc, dec decoderFunc) {
if enc != nil {
typeEncMap.Store(typ, makeExtEncoder(id, enc))
}
if dec != nil {
extTypes[id] = &extInfo{
Type: typ,
Decoder: dec,
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
}
typeDecMap.Store(typ, makeExtDecoder(id, dec))
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 (e *Encoder) EncodeExtHeader(typeID int8, length int) error {
if err := e.encodeExtLen(length); err != nil {
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: Decode(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 {
nilable := typ.Kind() == reflect.Ptr
return func(d *Decoder, v reflect.Value) error {
if d.hasNilCode() {
v.Set(reflect.Zero(typ))
return d.DecodeNil()
}
if nilable && v.IsNil() {
v.Set(reflect.New(typ.Elem()))
}
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: Decode(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(typeID)); err != nil {
if err := e.w.WriteByte(byte(extID)); err != nil {
return err
}
return nil
}
func makeExtEncoder(typeID int8, enc encoderFunc) encoderFunc {
return func(e *Encoder, v reflect.Value) error {
buf := bufferPool.Get().(*bytes.Buffer)
defer bufferPool.Put(buf)
buf.Reset()
oldw := e.w
e.w = buf
err := enc(e, v)
e.w = oldw
if err != nil {
return err
}
err = e.EncodeExtHeader(typeID, buf.Len())
if err != nil {
return err
}
return e.write(buf.Bytes())
}
}
func makeExtDecoder(typeID int8, dec decoderFunc) decoderFunc {
return func(d *Decoder, v reflect.Value) error {
c, err := d.PeekCode()
if err != nil {
return err
}
if !codes.IsExt(c) {
return dec(d, v)
}
id, extLen, err := d.DecodeExtHeader()
if err != nil {
return err
}
if id != typeID {
return fmt.Errorf("msgpack: got ext type=%d, wanted %d", id, typeID)
}
d.extLen = extLen
return dec(d, v)
}
}
func (e *Encoder) encodeExtLen(l int) error {
switch l {
case 1:
return e.writeCode(codes.FixExt1)
return e.writeCode(msgpcode.FixExt1)
case 2:
return e.writeCode(codes.FixExt2)
return e.writeCode(msgpcode.FixExt2)
case 4:
return e.writeCode(codes.FixExt4)
return e.writeCode(msgpcode.FixExt4)
case 8:
return e.writeCode(codes.FixExt8)
return e.writeCode(msgpcode.FixExt8)
case 16:
return e.writeCode(codes.FixExt16)
return e.writeCode(msgpcode.FixExt16)
}
if l < 256 {
return e.write1(codes.Ext8, uint8(l))
if l <= math.MaxUint8 {
return e.write1(msgpcode.Ext8, uint8(l))
}
if l < 65536 {
return e.write2(codes.Ext16, uint16(l))
if l <= math.MaxUint16 {
return e.write2(msgpcode.Ext16, uint16(l))
}
return e.write4(codes.Ext32, uint32(l))
return e.write4(msgpcode.Ext32, uint32(l))
}
func (d *Decoder) parseExtLen(c codes.Code) (int, error) {
switch c {
case codes.FixExt1:
return 1, nil
case codes.FixExt2:
return 2, nil
case codes.FixExt4:
return 4, nil
case codes.FixExt8:
return 8, nil
case codes.FixExt16:
return 16, nil
case codes.Ext8:
n, err := d.uint8()
return int(n), err
case codes.Ext16:
n, err := d.uint16()
return int(n), err
case codes.Ext32:
n, err := d.uint32()
return int(n), err
default:
return 0, fmt.Errorf("msgpack: invalid code=%x decoding ext length", c)
}
}
func (d *Decoder) extHeader(c codes.Code) (int8, int, error) {
length, err := d.parseExtLen(c)
if err != nil {
return 0, 0, err
}
typeID, err := d.readCode()
if err != nil {
return 0, 0, err
}
return int8(typeID), length, nil
}
func (d *Decoder) DecodeExtHeader() (typeID int8, length int, err error) {
func (d *Decoder) DecodeExtHeader() (extID int8, extLen int, err error) {
c, err := d.readCode()
if err != nil {
return
@@ -184,7 +214,47 @@ func (d *Decoder) DecodeExtHeader() (typeID int8, length int, err error) {
return d.extHeader(c)
}
func (d *Decoder) extInterface(c codes.Code) (interface{}, error) {
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
@@ -195,19 +265,19 @@ func (d *Decoder) extInterface(c codes.Code) (interface{}, error) {
return nil, fmt.Errorf("msgpack: unknown ext id=%d", extID)
}
v := reflect.New(info.Type)
v := reflect.New(info.Type).Elem()
if nilable(v) && v.IsNil() {
v.Set(reflect.New(info.Type.Elem()))
}
d.extLen = extLen
err = info.Decoder(d, v.Elem())
d.extLen = 0
if err != nil {
if err := info.Decoder(d, v, extLen); err != nil {
return nil, err
}
return v.Interface(), nil
}
func (d *Decoder) skipExt(c codes.Code) error {
func (d *Decoder) skipExt(c byte) error {
n, err := d.parseExtLen(c)
if err != nil {
return err
@@ -215,7 +285,7 @@ func (d *Decoder) skipExt(c codes.Code) error {
return d.skipN(n + 1)
}
func (d *Decoder) skipExtHeader(c codes.Code) error {
func (d *Decoder) skipExtHeader(c byte) error {
// Read ext type.
_, err := d.readCode()
if err != nil {
@@ -231,13 +301,13 @@ func (d *Decoder) skipExtHeader(c codes.Code) error {
return nil
}
func extHeaderLen(c codes.Code) int {
func extHeaderLen(c byte) int {
switch c {
case codes.Ext8:
case msgpcode.Ext8:
return 1
case codes.Ext16:
case msgpcode.Ext16:
return 2
case codes.Ext32:
case msgpcode.Ext32:
return 4
}
return 0

11
vendor/github.com/vmihailenco/msgpack/v5/go.mod сгенерированный поставляемый
Просмотреть файл

@@ -1,15 +1,8 @@
module github.com/vmihailenco/msgpack/v5
require (
github.com/davecgh/go-spew v1.1.1
github.com/golang/protobuf v1.3.4 // indirect
github.com/kr/pretty v0.1.0 // indirect
github.com/stretchr/testify v1.5.1
github.com/vmihailenco/msgpack/v4 v4.3.11
github.com/vmihailenco/tagparser v0.1.1
golang.org/x/net v0.0.0-20200301022130-244492dfa37a // indirect
google.golang.org/appengine v1.6.5
gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127
github.com/stretchr/testify v1.6.1
github.com/vmihailenco/tagparser v0.1.2
)
go 1.11

39
vendor/github.com/vmihailenco/msgpack/v5/go.sum сгенерированный поставляемый
Просмотреть файл

@@ -1,36 +1,13 @@
github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8=
github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/golang/protobuf v1.3.1/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
github.com/golang/protobuf v1.3.4 h1:87PNWwrRvUSnqS4dlcBU/ftvOIBep4sYuBLlh6rX2wk=
github.com/golang/protobuf v1.3.4/go.mod h1:vzj43D7+SQXF/4pzW/hwtAqwc6iTitCiVSaWz5lYuqw=
github.com/kr/pretty v0.1.0 h1:L/CwN0zerZDmRFUapSPitk6f+Q3+0za1rQkzVuMiMFI=
github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE=
github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
github.com/stretchr/testify v1.5.1 h1:nOGnQDM7FYENwehXlg/kFVnos3rEvtKTjRvOWSzb6H4=
github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA=
github.com/vmihailenco/msgpack v4.0.4+incompatible h1:dSLoQfGFAo3F6OoNhwUmLwVgaUXK79GlxNBwueZn0xI=
github.com/vmihailenco/msgpack/v4 v4.3.11 h1:Q47CePddpNGNhk4GCnAx9DDtASi2rasatE0cd26cZoE=
github.com/vmihailenco/msgpack/v4 v4.3.11/go.mod h1:gborTTJjAo/GWTqqRjrLCn9pgNN+NXzzngzBKDPIqw4=
github.com/vmihailenco/tagparser v0.1.1 h1:quXMXlA39OCbd2wAdTsGDlK9RkOk6Wuw+x37wVyIuWY=
github.com/vmihailenco/tagparser v0.1.1/go.mod h1:OeAg3pn3UbLjkWt+rN9oFYB6u/cQgqMEUPoW2WPyhdI=
golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
golang.org/x/net v0.0.0-20190603091049-60506f45cf65/go.mod h1:HSz+uSET+XFnRR8LxR5pz3Of3rY3CfYBVs4xY44aLks=
golang.org/x/net v0.0.0-20200301022130-244492dfa37a h1:GuSPYbZzB5/dcLNCwLQLsg3obCJtX9IJhpXkvY7kzk0=
golang.org/x/net v0.0.0-20200301022130-244492dfa37a/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
google.golang.org/appengine v1.6.5 h1:tycE03LOZYQNhDpS27tcQdAzLCVMaj7QT2SXxebnpCM=
google.golang.org/appengine v1.6.5/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc=
github.com/stretchr/testify v1.6.1 h1:hDPOHmpOpP40lSULcqw7IrRb/u7w6RpDC9399XyoNd0=
github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
github.com/vmihailenco/tagparser v0.1.2 h1:gnjoVuB/kljJ5wICEEOpx98oXMWPLj22G67Vbd1qPqc=
github.com/vmihailenco/tagparser v0.1.2/go.mod h1:OeAg3pn3UbLjkWt+rN9oFYB6u/cQgqMEUPoW2WPyhdI=
gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 h1:qIbj1fsPNlZgppZ+VLlY7N33q108Sa+fhmuc+sWQYwY=
gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
gopkg.in/yaml.v2 v2.2.2 h1:ZCJp+EgiOT7lHqUV2J862kp8Qj64Jo6az82+3Td9dZw=
gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c h1:dUUwHk2QECo/6vqA44rthZ8ie2QXMNeKRTHCNY2nXvo=
gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

288
vendor/github.com/vmihailenco/msgpack/v5/intern.go сгенерированный поставляемый
Просмотреть файл

@@ -1,222 +1,226 @@
package msgpack
import (
"encoding/binary"
"errors"
"fmt"
"math"
"reflect"
"github.com/vmihailenco/msgpack/v5/codes"
"github.com/vmihailenco/msgpack/v5/msgpcode"
)
var internStringExtID int8 = -128
const (
minInternedStringLen = 3
maxDictLen = math.MaxUint16
)
var errUnexpectedCode = errors.New("msgpack: unexpected code")
var internedStringExtID = int8(math.MinInt8)
func encodeInternInterfaceValue(e *Encoder, v reflect.Value) error {
if v.IsNil() {
return e.EncodeNil()
func init() {
extTypes[internedStringExtID] = &extInfo{
Type: stringType,
Decoder: decodeInternedStringExt,
}
v = v.Elem()
if v.Kind() == reflect.String {
return encodeInternStringValue(e, v)
}
return e.EncodeValue(v)
}
func encodeInternStringValue(e *Encoder, v reflect.Value) error {
s := v.String()
if s != "" {
if idx, ok := e.intern[s]; ok {
return e.internStringIndex(idx)
}
if e.intern == nil {
e.intern = make(map[string]int)
}
idx := len(e.intern)
e.intern[s] = idx
}
return e.EncodeString(s)
}
func (e *Encoder) internStringIndex(idx int) error {
if idx < math.MaxUint8 {
if err := e.writeCode(codes.FixExt1); err != nil {
return err
}
if err := e.w.WriteByte(byte(internStringExtID)); err != nil {
return err
}
return e.w.WriteByte(byte(idx))
}
if idx < math.MaxUint16 {
if err := e.writeCode(codes.FixExt2); err != nil {
return err
}
if err := e.w.WriteByte(byte(internStringExtID)); err != nil {
return err
}
if err := e.w.WriteByte(byte(idx >> 8)); err != nil {
return err
}
return e.w.WriteByte(byte(idx))
}
if int64(idx) < math.MaxUint32 {
if err := e.writeCode(codes.FixExt4); err != nil {
return err
}
if err := e.w.WriteByte(byte(internStringExtID)); err != nil {
return err
}
if err := e.w.WriteByte(byte(idx >> 24)); err != nil {
return err
}
if err := e.w.WriteByte(byte(idx >> 16)); err != nil {
return err
}
if err := e.w.WriteByte(byte(idx >> 8)); err != nil {
return err
}
return e.w.WriteByte(byte(idx))
}
return fmt.Errorf("msgpack: intern string index=%d is too large", idx)
}
//------------------------------------------------------------------------------
func decodeInternInterfaceValue(d *Decoder, v reflect.Value) error {
c, err := d.readCode()
func decodeInternedStringExt(d *Decoder, v reflect.Value, extLen int) error {
idx, err := d.decodeInternedStringIndex(extLen)
if err != nil {
return err
}
s, err := d.internString(c)
if err == nil {
v.Set(reflect.ValueOf(s))
return nil
}
if err != nil && err != errUnexpectedCode {
return err
}
if err := d.s.UnreadByte(); err != nil {
return err
}
return decodeInterfaceValue(d, v)
}
func decodeInternStringValue(d *Decoder, v reflect.Value) error {
c, err := d.readCode()
s, err := d.internedStringAtIndex(idx)
if err != nil {
return err
}
s, err := d.internString(c)
if err != nil {
if err == errUnexpectedCode {
return fmt.Errorf("msgpack: invalid code=%x decoding intern string", c)
}
return err
}
v.SetString(s)
return nil
}
func (d *Decoder) internString(c codes.Code) (string, error) {
if codes.IsFixedString(c) {
n := int(c & codes.FixedStrMask)
return d.internStringWithLen(n)
//------------------------------------------------------------------------------
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 len(s) >= minInternedStringLen {
if idx, ok := e.dict[s]; ok {
return e.encodeInternedStringIndex(idx)
}
if intern && 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 codes.FixExt1, codes.FixExt2, codes.FixExt4:
typeID, length, err := d.extHeader(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 != internStringExtID {
if typeID != internedStringExtID {
err := fmt.Errorf("msgpack: got ext type=%d, wanted %d",
typeID, internStringExtID)
typeID, internedStringExtID)
return "", err
}
idx, err := d.internStringIndex(length)
idx, err := d.decodeInternedStringIndex(extLen)
if err != nil {
return "", err
}
return d.internStringAtIndex(idx)
case codes.Str8, codes.Bin8:
return d.internedStringAtIndex(idx)
case msgpcode.Str8, msgpcode.Bin8:
n, err := d.uint8()
if err != nil {
return "", err
}
return d.internStringWithLen(int(n))
case codes.Str16, codes.Bin16:
return d.decodeInternedStringWithLen(int(n), intern)
case msgpcode.Str16, msgpcode.Bin16:
n, err := d.uint16()
if err != nil {
return "", err
}
return d.internStringWithLen(int(n))
case codes.Str32, codes.Bin32:
return d.decodeInternedStringWithLen(int(n), intern)
case msgpcode.Str32, msgpcode.Bin32:
n, err := d.uint32()
if err != nil {
return "", err
}
return d.internStringWithLen(int(n))
return d.decodeInternedStringWithLen(int(n), intern)
}
return "", errUnexpectedCode
return "", unexpectedCodeError{
code: c,
hint: "interned string",
}
}
func (d *Decoder) internStringIndex(length int) (int, error) {
switch length {
func (d *Decoder) decodeInternedStringIndex(extLen int) (int, error) {
switch extLen {
case 1:
c, err := d.s.ReadByte()
n, err := d.uint8()
if err != nil {
return 0, err
}
return int(c), nil
return int(n), nil
case 2:
b, err := d.readN(2)
n, err := d.uint16()
if err != nil {
return 0, err
}
n := binary.BigEndian.Uint16(b)
return int(n), nil
case 4:
b, err := d.readN(4)
n, err := d.uint32()
if err != nil {
return 0, err
}
n := binary.BigEndian.Uint32(b)
return int(n), nil
}
err := fmt.Errorf("msgpack: unsupported intern string index length=%d", length)
err := fmt.Errorf("msgpack: unsupported ext len=%d decoding interned string", extLen)
return 0, err
}
func (d *Decoder) internStringAtIndex(idx int) (string, error) {
if idx >= len(d.intern) {
err := fmt.Errorf("msgpack: intern string with index=%d does not exist", idx)
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.intern[idx], nil
return d.dict[idx], nil
}
func (d *Decoder) internStringWithLen(n int) (string, error) {
func (d *Decoder) decodeInternedStringWithLen(n int, intern bool) (string, error) {
if n <= 0 {
return "", nil
}
@@ -226,7 +230,9 @@ func (d *Decoder) internStringWithLen(n int) (string, error) {
return "", err
}
d.intern = append(d.intern, s)
if intern && len(s) >= minInternedStringLen && len(d.dict) < maxDictLen {
d.dict = append(d.dict, s)
}
return s, nil
}

19
vendor/github.com/vmihailenco/msgpack/v5/msgpack.go сгенерированный поставляемый
Просмотреть файл

@@ -1,5 +1,7 @@
package msgpack
import "fmt"
type Marshaler interface {
MarshalMsgpack() ([]byte, error)
}
@@ -20,8 +22,10 @@ type CustomDecoder interface {
type RawMessage []byte
var _ CustomEncoder = (RawMessage)(nil)
var _ CustomDecoder = (*RawMessage)(nil)
var (
_ CustomEncoder = (RawMessage)(nil)
_ CustomDecoder = (*RawMessage)(nil)
)
func (m RawMessage) EncodeMsgpack(enc *Encoder) error {
return enc.write(m)
@@ -35,3 +39,14 @@ func (m *RawMessage) DecodeMsgpack(dec *Decoder) error {
*m = msg
return nil
}
//------------------------------------------------------------------------------
type unexpectedCodeError struct {
code byte
hint string
}
func (err unexpectedCodeError) Error() string {
return fmt.Sprintf("msgpack: unexpected code=%x decoding %s", err.code, err.hint)
}

88
vendor/github.com/vmihailenco/msgpack/v5/msgpcode/msgpcode.go сгенерированный поставляемый Обычный файл
Просмотреть файл

@@ -0,0 +1,88 @@
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
}

128
vendor/github.com/vmihailenco/msgpack/v5/time.go сгенерированный поставляемый
Просмотреть файл

@@ -6,16 +6,30 @@ import (
"reflect"
"time"
"github.com/vmihailenco/msgpack/v5/codes"
"github.com/vmihailenco/msgpack/v5/msgpcode"
)
var timeExtID int8 = -1
var timePtrType = reflect.TypeOf((*time.Time)(nil))
//nolint:gochecknoinits
func init() {
registerExt(timeExtID, timePtrType.Elem(), encodeTimeValue, decodeTimeValue)
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
}
ptr := v.Addr().Interface().(*time.Time)
*ptr = tm
return nil
}
func (e *Encoder) EncodeTime(tm time.Time) error {
@@ -56,62 +70,56 @@ func (e *Encoder) encodeTime(tm time.Time) []byte {
}
func (d *Decoder) DecodeTime() (time.Time, error) {
tm, err := d.decodeTime()
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
}
if extID != timeExtID {
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() {
// Assume that zero time does not have timezone information.
// Zero time does not have timezone information.
return tm.UTC(), nil
}
return tm, nil
}
func (d *Decoder) decodeTime() (time.Time, error) {
extLen := d.extLen
d.extLen = 0
if extLen == 0 {
c, err := d.readCode()
if err != nil {
return time.Time{}, err
}
// Legacy format.
if c == codes.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 codes.IsString(c) {
s, err := d.string(c)
if err != nil {
return time.Time{}, err
}
return time.Parse(time.RFC3339Nano, s)
}
extLen, err = d.parseExtLen(c)
if err != nil {
return time.Time{}, err
}
// Skip ext id.
_, err = d.s.ReadByte()
if err != nil {
return time.Time{}, nil
}
}
func (d *Decoder) decodeTime(extLen int) (time.Time, error) {
b, err := d.readN(extLen)
if err != nil {
return time.Time{}, err
@@ -135,21 +143,3 @@ func (d *Decoder) decodeTime() (time.Time, error) {
return time.Time{}, err
}
}
func encodeTimeValue(e *Encoder, v reflect.Value) error {
tm := v.Interface().(time.Time)
b := e.encodeTime(tm)
return e.write(b)
}
func decodeTimeValue(d *Decoder, v reflect.Value) error {
tm, err := d.DecodeTime()
if err != nil {
return err
}
ptr := v.Addr().Interface().(*time.Time)
*ptr = tm
return nil
}

21
vendor/github.com/vmihailenco/msgpack/v5/types.go сгенерированный поставляемый
Просмотреть файл

@@ -27,6 +27,11 @@ var (
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
@@ -39,7 +44,7 @@ var (
// Register registers encoder and decoder functions for a value.
// This is low level API and in most cases you should prefer implementing
// Marshaler/CustomEncoder and Unmarshaler/CustomDecoder interfaces.
// CustomEncoder/CustomDecoder or Marshaler/Unmarshaler interfaces.
func Register(value interface{}, enc encoderFunc, dec decoderFunc) {
typ := reflect.TypeOf(value)
if enc != nil {
@@ -66,7 +71,7 @@ type structCacheKey struct {
}
func newStructCache() *structCache {
return &structCache{}
return new(structCache)
}
func (m *structCache) Fields(typ reflect.Type, tag string) *fields {
@@ -181,9 +186,7 @@ func getFields(typ reflect.Type, fallbackTag string) *fields {
}
if f.Name == "_msgpack" {
if tag.HasOption("asArray") {
fs.AsArray = true
}
fs.AsArray = tag.HasOption("as_array") || tag.HasOption("asArray")
if tag.HasOption("omitempty") {
omitEmpty = true
}
@@ -202,11 +205,11 @@ func getFields(typ reflect.Type, fallbackTag string) *fields {
if tag.HasOption("intern") {
switch f.Type.Kind() {
case reflect.Interface:
field.encoder = encodeInternInterfaceValue
field.decoder = decodeInternInterfaceValue
field.encoder = encodeInternedInterfaceValue
field.decoder = decodeInternedInterfaceValue
case reflect.String:
field.encoder = encodeInternStringValue
field.decoder = decodeInternStringValue
field.encoder = encodeInternedStringValue
field.decoder = decodeInternedStringValue
default:
err := fmt.Errorf("msgpack: intern strings are not supported on %s", f.Type)
panic(err)