Make Nix builds work

1 files changed, 483 insertions, 0 deletions

diff --git a/vendor/github.com/json-iterator/go/reflect_extension.go b/vendor/github.com/json-iterator/go/reflect_extension.go
new file mode 100644
index 0000000..74a97bf
--- /dev/null
+++ b/vendor/github.com/json-iterator/go/reflect_extension.go
@@ -0,0 +1,483 @@
+package jsoniter
+
+import (
+        "fmt"
+        "github.com/modern-go/reflect2"
+        "reflect"
+        "sort"
+        "strings"
+        "unicode"
+        "unsafe"
+)
+
+var typeDecoders = map[string]ValDecoder{}
+var fieldDecoders = map[string]ValDecoder{}
+var typeEncoders = map[string]ValEncoder{}
+var fieldEncoders = map[string]ValEncoder{}
+var extensions = []Extension{}
+
+// StructDescriptor describe how should we encode/decode the struct
+type StructDescriptor struct {
+        Type   reflect2.Type
+        Fields []*Binding
+}
+
+// GetField get one field from the descriptor by its name.
+// Can not use map here to keep field orders.
+func (structDescriptor *StructDescriptor) GetField(fieldName string) *Binding {
+        for _, binding := range structDescriptor.Fields {
+                if binding.Field.Name() == fieldName {
+                        return binding
+                }
+        }
+        return nil
+}
+
+// Binding describe how should we encode/decode the struct field
+type Binding struct {
+        levels    []int
+        Field     reflect2.StructField
+        FromNames []string
+        ToNames   []string
+        Encoder   ValEncoder
+        Decoder   ValDecoder
+}
+
+// Extension the one for all SPI. Customize encoding/decoding by specifying alternate encoder/decoder.
+// Can also rename fields by UpdateStructDescriptor.
+type Extension interface {
+        UpdateStructDescriptor(structDescriptor *StructDescriptor)
+        CreateMapKeyDecoder(typ reflect2.Type) ValDecoder
+        CreateMapKeyEncoder(typ reflect2.Type) ValEncoder
+        CreateDecoder(typ reflect2.Type) ValDecoder
+        CreateEncoder(typ reflect2.Type) ValEncoder
+        DecorateDecoder(typ reflect2.Type, decoder ValDecoder) ValDecoder
+        DecorateEncoder(typ reflect2.Type, encoder ValEncoder) ValEncoder
+}
+
+// DummyExtension embed this type get dummy implementation for all methods of Extension
+type DummyExtension struct {
+}
+
+// UpdateStructDescriptor No-op
+func (extension *DummyExtension) UpdateStructDescriptor(structDescriptor *StructDescriptor) {
+}
+
+// CreateMapKeyDecoder No-op
+func (extension *DummyExtension) CreateMapKeyDecoder(typ reflect2.Type) ValDecoder {
+        return nil
+}
+
+// CreateMapKeyEncoder No-op
+func (extension *DummyExtension) CreateMapKeyEncoder(typ reflect2.Type) ValEncoder {
+        return nil
+}
+
+// CreateDecoder No-op
+func (extension *DummyExtension) CreateDecoder(typ reflect2.Type) ValDecoder {
+        return nil
+}
+
+// CreateEncoder No-op
+func (extension *DummyExtension) CreateEncoder(typ reflect2.Type) ValEncoder {
+        return nil
+}
+
+// DecorateDecoder No-op
+func (extension *DummyExtension) DecorateDecoder(typ reflect2.Type, decoder ValDecoder) ValDecoder {
+        return decoder
+}
+
+// DecorateEncoder No-op
+func (extension *DummyExtension) DecorateEncoder(typ reflect2.Type, encoder ValEncoder) ValEncoder {
+        return encoder
+}
+
+type EncoderExtension map[reflect2.Type]ValEncoder
+
+// UpdateStructDescriptor No-op
+func (extension EncoderExtension) UpdateStructDescriptor(structDescriptor *StructDescriptor) {
+}
+
+// CreateDecoder No-op
+func (extension EncoderExtension) CreateDecoder(typ reflect2.Type) ValDecoder {
+        return nil
+}
+
+// CreateEncoder get encoder from map
+func (extension EncoderExtension) CreateEncoder(typ reflect2.Type) ValEncoder {
+        return extension[typ]
+}
+
+// CreateMapKeyDecoder No-op
+func (extension EncoderExtension) CreateMapKeyDecoder(typ reflect2.Type) ValDecoder {
+        return nil
+}
+
+// CreateMapKeyEncoder No-op
+func (extension EncoderExtension) CreateMapKeyEncoder(typ reflect2.Type) ValEncoder {
+        return nil
+}
+
+// DecorateDecoder No-op
+func (extension EncoderExtension) DecorateDecoder(typ reflect2.Type, decoder ValDecoder) ValDecoder {
+        return decoder
+}
+
+// DecorateEncoder No-op
+func (extension EncoderExtension) DecorateEncoder(typ reflect2.Type, encoder ValEncoder) ValEncoder {
+        return encoder
+}
+
+type DecoderExtension map[reflect2.Type]ValDecoder
+
+// UpdateStructDescriptor No-op
+func (extension DecoderExtension) UpdateStructDescriptor(structDescriptor *StructDescriptor) {
+}
+
+// CreateMapKeyDecoder No-op
+func (extension DecoderExtension) CreateMapKeyDecoder(typ reflect2.Type) ValDecoder {
+        return nil
+}
+
+// CreateMapKeyEncoder No-op
+func (extension DecoderExtension) CreateMapKeyEncoder(typ reflect2.Type) ValEncoder {
+        return nil
+}
+
+// CreateDecoder get decoder from map
+func (extension DecoderExtension) CreateDecoder(typ reflect2.Type) ValDecoder {
+        return extension[typ]
+}
+
+// CreateEncoder No-op
+func (extension DecoderExtension) CreateEncoder(typ reflect2.Type) ValEncoder {
+        return nil
+}
+
+// DecorateDecoder No-op
+func (extension DecoderExtension) DecorateDecoder(typ reflect2.Type, decoder ValDecoder) ValDecoder {
+        return decoder
+}
+
+// DecorateEncoder No-op
+func (extension DecoderExtension) DecorateEncoder(typ reflect2.Type, encoder ValEncoder) ValEncoder {
+        return encoder
+}
+
+type funcDecoder struct {
+        fun DecoderFunc
+}
+
+func (decoder *funcDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) {
+        decoder.fun(ptr, iter)
+}
+
+type funcEncoder struct {
+        fun         EncoderFunc
+        isEmptyFunc func(ptr unsafe.Pointer) bool
+}
+
+func (encoder *funcEncoder) Encode(ptr unsafe.Pointer, stream *Stream) {
+        encoder.fun(ptr, stream)
+}
+
+func (encoder *funcEncoder) IsEmpty(ptr unsafe.Pointer) bool {
+        if encoder.isEmptyFunc == nil {
+                return false
+        }
+        return encoder.isEmptyFunc(ptr)
+}
+
+// DecoderFunc the function form of TypeDecoder
+type DecoderFunc func(ptr unsafe.Pointer, iter *Iterator)
+
+// EncoderFunc the function form of TypeEncoder
+type EncoderFunc func(ptr unsafe.Pointer, stream *Stream)
+
+// RegisterTypeDecoderFunc register TypeDecoder for a type with function
+func RegisterTypeDecoderFunc(typ string, fun DecoderFunc) {
+        typeDecoders[typ] = &funcDecoder{fun}
+}
+
+// RegisterTypeDecoder register TypeDecoder for a typ
+func RegisterTypeDecoder(typ string, decoder ValDecoder) {
+        typeDecoders[typ] = decoder
+}
+
+// RegisterFieldDecoderFunc register TypeDecoder for a struct field with function
+func RegisterFieldDecoderFunc(typ string, field string, fun DecoderFunc) {
+        RegisterFieldDecoder(typ, field, &funcDecoder{fun})
+}
+
+// RegisterFieldDecoder register TypeDecoder for a struct field
+func RegisterFieldDecoder(typ string, field string, decoder ValDecoder) {
+        fieldDecoders[fmt.Sprintf("%s/%s", typ, field)] = decoder
+}
+
+// RegisterTypeEncoderFunc register TypeEncoder for a type with encode/isEmpty function
+func RegisterTypeEncoderFunc(typ string, fun EncoderFunc, isEmptyFunc func(unsafe.Pointer) bool) {
+        typeEncoders[typ] = &funcEncoder{fun, isEmptyFunc}
+}
+
+// RegisterTypeEncoder register TypeEncoder for a type
+func RegisterTypeEncoder(typ string, encoder ValEncoder) {
+        typeEncoders[typ] = encoder
+}
+
+// RegisterFieldEncoderFunc register TypeEncoder for a struct field with encode/isEmpty function
+func RegisterFieldEncoderFunc(typ string, field string, fun EncoderFunc, isEmptyFunc func(unsafe.Pointer) bool) {
+        RegisterFieldEncoder(typ, field, &funcEncoder{fun, isEmptyFunc})
+}
+
+// RegisterFieldEncoder register TypeEncoder for a struct field
+func RegisterFieldEncoder(typ string, field string, encoder ValEncoder) {
+        fieldEncoders[fmt.Sprintf("%s/%s", typ, field)] = encoder
+}
+
+// RegisterExtension register extension
+func RegisterExtension(extension Extension) {
+        extensions = append(extensions, extension)
+}
+
+func getTypeDecoderFromExtension(ctx *ctx, typ reflect2.Type) ValDecoder {
+        decoder := _getTypeDecoderFromExtension(ctx, typ)
+        if decoder != nil {
+                for _, extension := range extensions {
+                        decoder = extension.DecorateDecoder(typ, decoder)
+                }
+                decoder = ctx.decoderExtension.DecorateDecoder(typ, decoder)
+                for _, extension := range ctx.extraExtensions {
+                        decoder = extension.DecorateDecoder(typ, decoder)
+                }
+        }
+        return decoder
+}
+func _getTypeDecoderFromExtension(ctx *ctx, typ reflect2.Type) ValDecoder {
+        for _, extension := range extensions {
+                decoder := extension.CreateDecoder(typ)
+                if decoder != nil {
+                        return decoder
+                }
+        }
+        decoder := ctx.decoderExtension.CreateDecoder(typ)
+        if decoder != nil {
+                return decoder
+        }
+        for _, extension := range ctx.extraExtensions {
+                decoder := extension.CreateDecoder(typ)
+                if decoder != nil {
+                        return decoder
+                }
+        }
+        typeName := typ.String()
+        decoder = typeDecoders[typeName]
+        if decoder != nil {
+                return decoder
+        }
+        if typ.Kind() == reflect.Ptr {
+                ptrType := typ.(*reflect2.UnsafePtrType)
+                decoder := typeDecoders[ptrType.Elem().String()]
+                if decoder != nil {
+                        return &OptionalDecoder{ptrType.Elem(), decoder}
+                }
+        }
+        return nil
+}
+
+func getTypeEncoderFromExtension(ctx *ctx, typ reflect2.Type) ValEncoder {
+        encoder := _getTypeEncoderFromExtension(ctx, typ)
+        if encoder != nil {
+                for _, extension := range extensions {
+                        encoder = extension.DecorateEncoder(typ, encoder)
+                }
+                encoder = ctx.encoderExtension.DecorateEncoder(typ, encoder)
+                for _, extension := range ctx.extraExtensions {
+                        encoder = extension.DecorateEncoder(typ, encoder)
+                }
+        }
+        return encoder
+}
+
+func _getTypeEncoderFromExtension(ctx *ctx, typ reflect2.Type) ValEncoder {
+        for _, extension := range extensions {
+                encoder := extension.CreateEncoder(typ)
+                if encoder != nil {
+                        return encoder
+                }
+        }
+        encoder := ctx.encoderExtension.CreateEncoder(typ)
+        if encoder != nil {
+                return encoder
+        }
+        for _, extension := range ctx.extraExtensions {
+                encoder := extension.CreateEncoder(typ)
+                if encoder != nil {
+                        return encoder
+                }
+        }
+        typeName := typ.String()
+        encoder = typeEncoders[typeName]
+        if encoder != nil {
+                return encoder
+        }
+        if typ.Kind() == reflect.Ptr {
+                typePtr := typ.(*reflect2.UnsafePtrType)
+                encoder := typeEncoders[typePtr.Elem().String()]
+                if encoder != nil {
+                        return &OptionalEncoder{encoder}
+                }
+        }
+        return nil
+}
+
+func describeStruct(ctx *ctx, typ reflect2.Type) *StructDescriptor {
+        structType := typ.(*reflect2.UnsafeStructType)
+        embeddedBindings := []*Binding{}
+        bindings := []*Binding{}
+        for i := 0; i < structType.NumField(); i++ {
+                field := structType.Field(i)
+                tag, hastag := field.Tag().Lookup(ctx.getTagKey())
+                if ctx.onlyTaggedField && !hastag && !field.Anonymous() {
+                        continue
+                }
+                if tag == "-" || field.Name() == "_" {
+                        continue
+                }
+                tagParts := strings.Split(tag, ",")
+                if field.Anonymous() && (tag == "" || tagParts[0] == "") {
+                        if field.Type().Kind() == reflect.Struct {
+                                structDescriptor := describeStruct(ctx, field.Type())
+                                for _, binding := range structDescriptor.Fields {
+                                        binding.levels = append([]int{i}, binding.levels...)
+                                        omitempty := binding.Encoder.(*structFieldEncoder).omitempty
+                                        binding.Encoder = &structFieldEncoder{field, binding.Encoder, omitempty}
+                                        binding.Decoder = &structFieldDecoder{field, binding.Decoder}
+                                        embeddedBindings = append(embeddedBindings, binding)
+                                }
+                                continue
+                        } else if field.Type().Kind() == reflect.Ptr {
+                                ptrType := field.Type().(*reflect2.UnsafePtrType)
+                                if ptrType.Elem().Kind() == reflect.Struct {
+                                        structDescriptor := describeStruct(ctx, ptrType.Elem())
+                                        for _, binding := range structDescriptor.Fields {
+                                                binding.levels = append([]int{i}, binding.levels...)
+                                                omitempty := binding.Encoder.(*structFieldEncoder).omitempty
+                                                binding.Encoder = &dereferenceEncoder{binding.Encoder}
+                                                binding.Encoder = &structFieldEncoder{field, binding.Encoder, omitempty}
+                                                binding.Decoder = &dereferenceDecoder{ptrType.Elem(), binding.Decoder}
+                                                binding.Decoder = &structFieldDecoder{field, binding.Decoder}
+                                                embeddedBindings = append(embeddedBindings, binding)
+                                        }
+                                        continue
+                                }
+                        }
+                }
+                fieldNames := calcFieldNames(field.Name(), tagParts[0], tag)
+                fieldCacheKey := fmt.Sprintf("%s/%s", typ.String(), field.Name())
+                decoder := fieldDecoders[fieldCacheKey]
+                if decoder == nil {
+                        decoder = decoderOfType(ctx.append(field.Name()), field.Type())
+                }
+                encoder := fieldEncoders[fieldCacheKey]
+                if encoder == nil {
+                        encoder = encoderOfType(ctx.append(field.Name()), field.Type())
+                }
+                binding := &Binding{
+                        Field:     field,
+                        FromNames: fieldNames,
+                        ToNames:   fieldNames,
+                        Decoder:   decoder,
+                        Encoder:   encoder,
+                }
+                binding.levels = []int{i}
+                bindings = append(bindings, binding)
+        }
+        return createStructDescriptor(ctx, typ, bindings, embeddedBindings)
+}
+func createStructDescriptor(ctx *ctx, typ reflect2.Type, bindings []*Binding, embeddedBindings []*Binding) *StructDescriptor {
+        structDescriptor := &StructDescriptor{
+                Type:   typ,
+                Fields: bindings,
+        }
+        for _, extension := range extensions {
+                extension.UpdateStructDescriptor(structDescriptor)
+        }
+        ctx.encoderExtension.UpdateStructDescriptor(structDescriptor)
+        ctx.decoderExtension.UpdateStructDescriptor(structDescriptor)
+        for _, extension := range ctx.extraExtensions {
+                extension.UpdateStructDescriptor(structDescriptor)
+        }
+        processTags(structDescriptor, ctx.frozenConfig)
+        // merge normal & embedded bindings & sort with original order
+        allBindings := sortableBindings(append(embeddedBindings, structDescriptor.Fields...))
+        sort.Sort(allBindings)
+        structDescriptor.Fields = allBindings
+        return structDescriptor
+}
+
+type sortableBindings []*Binding
+
+func (bindings sortableBindings) Len() int {
+        return len(bindings)
+}
+
+func (bindings sortableBindings) Less(i, j int) bool {
+        left := bindings[i].levels
+        right := bindings[j].levels
+        k := 0
+        for {
+                if left[k] < right[k] {
+                        return true
+                } else if left[k] > right[k] {
+                        return false
+                }
+                k++
+        }
+}
+
+func (bindings sortableBindings) Swap(i, j int) {
+        bindings[i], bindings[j] = bindings[j], bindings[i]
+}
+
+func processTags(structDescriptor *StructDescriptor, cfg *frozenConfig) {
+        for _, binding := range structDescriptor.Fields {
+                shouldOmitEmpty := false
+                tagParts := strings.Split(binding.Field.Tag().Get(cfg.getTagKey()), ",")
+                for _, tagPart := range tagParts[1:] {
+                        if tagPart == "omitempty" {
+                                shouldOmitEmpty = true
+                        } else if tagPart == "string" {
+                                if binding.Field.Type().Kind() == reflect.String {
+                                        binding.Decoder = &stringModeStringDecoder{binding.Decoder, cfg}
+                                        binding.Encoder = &stringModeStringEncoder{binding.Encoder, cfg}
+                                } else {
+                                        binding.Decoder = &stringModeNumberDecoder{binding.Decoder}
+                                        binding.Encoder = &stringModeNumberEncoder{binding.Encoder}
+                                }
+                        }
+                }
+                binding.Decoder = &structFieldDecoder{binding.Field, binding.Decoder}
+                binding.Encoder = &structFieldEncoder{binding.Field, binding.Encoder, shouldOmitEmpty}
+        }
+}
+
+func calcFieldNames(originalFieldName string, tagProvidedFieldName string, wholeTag string) []string {
+        // ignore?
+        if wholeTag == "-" {
+                return []string{}
+        }
+        // rename?
+        var fieldNames []string
+        if tagProvidedFieldName == "" {
+                fieldNames = []string{originalFieldName}
+        } else {
+                fieldNames = []string{tagProvidedFieldName}
+        }
+        // private?
+        isNotExported := unicode.IsLower(rune(originalFieldName[0])) || originalFieldName[0] == '_'
+        if isNotExported {
+                fieldNames = []string{}
+        }
+        return fieldNames
+}