mirror of
https://github.com/superseriousbusiness/gotosocial.git
synced 2024-12-23 18:52:11 +00:00
98263a7de6
* start fixing up tests * fix up tests + automate with drone * fiddle with linting * messing about with drone.yml * some more fiddling * hmmm * add cache * add vendor directory * verbose * ci updates * update some little things * update sig
239 lines
4.9 KiB
Go
239 lines
4.9 KiB
Go
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 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 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
|
|
}
|