summaryrefslogtreecommitdiff
path: root/vendor/github.com/pquerna/ffjson/inception
diff options
context:
space:
mode:
Diffstat (limited to 'vendor/github.com/pquerna/ffjson/inception')
-rw-r--r--vendor/github.com/pquerna/ffjson/inception/decoder.go323
-rw-r--r--vendor/github.com/pquerna/ffjson/inception/decoder_tpl.go773
-rw-r--r--vendor/github.com/pquerna/ffjson/inception/encoder.go544
-rw-r--r--vendor/github.com/pquerna/ffjson/inception/encoder_tpl.go73
-rw-r--r--vendor/github.com/pquerna/ffjson/inception/inception.go160
-rw-r--r--vendor/github.com/pquerna/ffjson/inception/reflect.go290
-rw-r--r--vendor/github.com/pquerna/ffjson/inception/tags.go79
-rw-r--r--vendor/github.com/pquerna/ffjson/inception/template.go60
-rw-r--r--vendor/github.com/pquerna/ffjson/inception/writerstack.go65
9 files changed, 0 insertions, 2367 deletions
diff --git a/vendor/github.com/pquerna/ffjson/inception/decoder.go b/vendor/github.com/pquerna/ffjson/inception/decoder.go
deleted file mode 100644
index 908347a32..000000000
--- a/vendor/github.com/pquerna/ffjson/inception/decoder.go
+++ /dev/null
@@ -1,323 +0,0 @@
-/**
- * Copyright 2014 Paul Querna
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-package ffjsoninception
-
-import (
- "fmt"
- "reflect"
- "strings"
-
- "github.com/pquerna/ffjson/shared"
-)
-
-var validValues []string = []string{
- "FFTok_left_brace",
- "FFTok_left_bracket",
- "FFTok_integer",
- "FFTok_double",
- "FFTok_string",
- "FFTok_bool",
- "FFTok_null",
-}
-
-func CreateUnmarshalJSON(ic *Inception, si *StructInfo) error {
- out := ""
- ic.OutputImports[`fflib "github.com/pquerna/ffjson/fflib/v1"`] = true
- if len(si.Fields) > 0 {
- ic.OutputImports[`"bytes"`] = true
- }
- ic.OutputImports[`"fmt"`] = true
-
- out += tplStr(decodeTpl["header"], header{
- IC: ic,
- SI: si,
- })
-
- out += tplStr(decodeTpl["ujFunc"], ujFunc{
- SI: si,
- IC: ic,
- ValidValues: validValues,
- ResetFields: ic.ResetFields,
- })
-
- ic.OutputFuncs = append(ic.OutputFuncs, out)
-
- return nil
-}
-
-func handleField(ic *Inception, name string, typ reflect.Type, ptr bool, quoted bool) string {
- return handleFieldAddr(ic, name, false, typ, ptr, quoted)
-}
-
-func handleFieldAddr(ic *Inception, name string, takeAddr bool, typ reflect.Type, ptr bool, quoted bool) string {
- out := fmt.Sprintf("/* handler: %s type=%v kind=%v quoted=%t*/\n", name, typ, typ.Kind(), quoted)
-
- umlx := typ.Implements(unmarshalFasterType) || typeInInception(ic, typ, shared.MustDecoder)
- umlx = umlx || reflect.PtrTo(typ).Implements(unmarshalFasterType)
-
- umlstd := typ.Implements(unmarshalerType) || reflect.PtrTo(typ).Implements(unmarshalerType)
-
- out += tplStr(decodeTpl["handleUnmarshaler"], handleUnmarshaler{
- IC: ic,
- Name: name,
- Typ: typ,
- Ptr: reflect.Ptr,
- TakeAddr: takeAddr || ptr,
- UnmarshalJSONFFLexer: umlx,
- Unmarshaler: umlstd,
- })
-
- if umlx || umlstd {
- return out
- }
-
- // TODO(pquerna): generic handling of token type mismatching struct type
- switch typ.Kind() {
- case reflect.Int,
- reflect.Int8,
- reflect.Int16,
- reflect.Int32,
- reflect.Int64:
-
- allowed := buildTokens(quoted, "FFTok_string", "FFTok_integer", "FFTok_null")
- out += getAllowTokens(typ.Name(), allowed...)
-
- out += getNumberHandler(ic, name, takeAddr || ptr, typ, "ParseInt")
-
- case reflect.Uint,
- reflect.Uint8,
- reflect.Uint16,
- reflect.Uint32,
- reflect.Uint64:
-
- allowed := buildTokens(quoted, "FFTok_string", "FFTok_integer", "FFTok_null")
- out += getAllowTokens(typ.Name(), allowed...)
-
- out += getNumberHandler(ic, name, takeAddr || ptr, typ, "ParseUint")
-
- case reflect.Float32,
- reflect.Float64:
-
- allowed := buildTokens(quoted, "FFTok_string", "FFTok_double", "FFTok_integer", "FFTok_null")
- out += getAllowTokens(typ.Name(), allowed...)
-
- out += getNumberHandler(ic, name, takeAddr || ptr, typ, "ParseFloat")
-
- case reflect.Bool:
- ic.OutputImports[`"bytes"`] = true
- ic.OutputImports[`"errors"`] = true
-
- allowed := buildTokens(quoted, "FFTok_string", "FFTok_bool", "FFTok_null")
- out += getAllowTokens(typ.Name(), allowed...)
-
- out += tplStr(decodeTpl["handleBool"], handleBool{
- Name: name,
- Typ: typ,
- TakeAddr: takeAddr || ptr,
- })
-
- case reflect.Ptr:
- out += tplStr(decodeTpl["handlePtr"], handlePtr{
- IC: ic,
- Name: name,
- Typ: typ,
- Quoted: quoted,
- })
-
- case reflect.Array,
- reflect.Slice:
- out += getArrayHandler(ic, name, typ, ptr)
-
- case reflect.String:
- // Is it a json.Number?
- if typ.PkgPath() == "encoding/json" && typ.Name() == "Number" {
- // Fall back to json package to rely on the valid number check.
- // See: https://github.com/golang/go/blob/f05c3aa24d815cd3869153750c9875e35fc48a6e/src/encoding/json/decode.go#L897
- ic.OutputImports[`"encoding/json"`] = true
- out += tplStr(decodeTpl["handleFallback"], handleFallback{
- Name: name,
- Typ: typ,
- Kind: typ.Kind(),
- })
- } else {
- out += tplStr(decodeTpl["handleString"], handleString{
- IC: ic,
- Name: name,
- Typ: typ,
- TakeAddr: takeAddr || ptr,
- Quoted: quoted,
- })
- }
- case reflect.Interface:
- ic.OutputImports[`"encoding/json"`] = true
- out += tplStr(decodeTpl["handleFallback"], handleFallback{
- Name: name,
- Typ: typ,
- Kind: typ.Kind(),
- })
- case reflect.Map:
- out += tplStr(decodeTpl["handleObject"], handleObject{
- IC: ic,
- Name: name,
- Typ: typ,
- Ptr: reflect.Ptr,
- TakeAddr: takeAddr || ptr,
- })
- default:
- ic.OutputImports[`"encoding/json"`] = true
- out += tplStr(decodeTpl["handleFallback"], handleFallback{
- Name: name,
- Typ: typ,
- Kind: typ.Kind(),
- })
- }
-
- return out
-}
-
-func getArrayHandler(ic *Inception, name string, typ reflect.Type, ptr bool) string {
- if typ.Kind() == reflect.Slice && typ.Elem().Kind() == reflect.Uint8 {
- ic.OutputImports[`"encoding/base64"`] = true
- useReflectToSet := false
- if typ.Elem().Name() != "byte" {
- ic.OutputImports[`"reflect"`] = true
- useReflectToSet = true
- }
-
- return tplStr(decodeTpl["handleByteSlice"], handleArray{
- IC: ic,
- Name: name,
- Typ: typ,
- Ptr: reflect.Ptr,
- UseReflectToSet: useReflectToSet,
- })
- }
-
- if typ.Elem().Kind() == reflect.Struct && typ.Elem().Name() != "" {
- goto sliceOrArray
- }
-
- if (typ.Elem().Kind() == reflect.Struct || typ.Elem().Kind() == reflect.Map) ||
- typ.Elem().Kind() == reflect.Array || typ.Elem().Kind() == reflect.Slice &&
- typ.Elem().Name() == "" {
- ic.OutputImports[`"encoding/json"`] = true
-
- return tplStr(decodeTpl["handleFallback"], handleFallback{
- Name: name,
- Typ: typ,
- Kind: typ.Kind(),
- })
- }
-
-sliceOrArray:
-
- if typ.Kind() == reflect.Array {
- return tplStr(decodeTpl["handleArray"], handleArray{
- IC: ic,
- Name: name,
- Typ: typ,
- IsPtr: ptr,
- Ptr: reflect.Ptr,
- })
- }
-
- return tplStr(decodeTpl["handleSlice"], handleArray{
- IC: ic,
- Name: name,
- Typ: typ,
- IsPtr: ptr,
- Ptr: reflect.Ptr,
- })
-}
-
-func getAllowTokens(name string, tokens ...string) string {
- return tplStr(decodeTpl["allowTokens"], allowTokens{
- Name: name,
- Tokens: tokens,
- })
-}
-
-func getNumberHandler(ic *Inception, name string, takeAddr bool, typ reflect.Type, parsefunc string) string {
- return tplStr(decodeTpl["handlerNumeric"], handlerNumeric{
- IC: ic,
- Name: name,
- ParseFunc: parsefunc,
- TakeAddr: takeAddr,
- Typ: typ,
- })
-}
-
-func getNumberSize(typ reflect.Type) string {
- return fmt.Sprintf("%d", typ.Bits())
-}
-
-func getType(ic *Inception, name string, typ reflect.Type) string {
- s := typ.Name()
-
- if typ.PkgPath() != "" && typ.PkgPath() != ic.PackagePath {
- path := removeVendor(typ.PkgPath())
- ic.OutputImports[`"`+path+`"`] = true
- s = typ.String()
- }
-
- if s == "" {
- return typ.String()
- }
-
- return s
-}
-
-// removeVendor removes everything before and including a '/vendor/'
-// substring in the package path.
-// This is needed becuase that full path can't be used in the
-// import statement.
-func removeVendor(path string) string {
- i := strings.Index(path, "/vendor/")
- if i == -1 {
- return path
- }
- return path[i+8:]
-}
-
-func buildTokens(containsOptional bool, optional string, required ...string) []string {
- if containsOptional {
- return append(required, optional)
- }
-
- return required
-}
-
-func unquoteField(quoted bool) string {
- // The outer quote of a string is already stripped out by
- // the lexer. We need to check if the inner string is also
- // quoted. If so, we will decode it as json string. If decoding
- // fails, we will use the original string
- if quoted {
- return `
- unquoted, ok := fflib.UnquoteBytes(outBuf)
- if ok {
- outBuf = unquoted
- }
- `
- }
- return ""
-}
-
-func getTmpVarFor(name string) string {
- return "tmp" + strings.Replace(strings.Title(name), ".", "", -1)
-}
diff --git a/vendor/github.com/pquerna/ffjson/inception/decoder_tpl.go b/vendor/github.com/pquerna/ffjson/inception/decoder_tpl.go
deleted file mode 100644
index 098506122..000000000
--- a/vendor/github.com/pquerna/ffjson/inception/decoder_tpl.go
+++ /dev/null
@@ -1,773 +0,0 @@
-/**
- * Copyright 2014 Paul Querna
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-package ffjsoninception
-
-import (
- "reflect"
- "strconv"
- "text/template"
-)
-
-var decodeTpl map[string]*template.Template
-
-func init() {
- decodeTpl = make(map[string]*template.Template)
-
- funcs := map[string]string{
- "handlerNumeric": handlerNumericTxt,
- "allowTokens": allowTokensTxt,
- "handleFallback": handleFallbackTxt,
- "handleString": handleStringTxt,
- "handleObject": handleObjectTxt,
- "handleArray": handleArrayTxt,
- "handleSlice": handleSliceTxt,
- "handleByteSlice": handleByteSliceTxt,
- "handleBool": handleBoolTxt,
- "handlePtr": handlePtrTxt,
- "header": headerTxt,
- "ujFunc": ujFuncTxt,
- "handleUnmarshaler": handleUnmarshalerTxt,
- }
-
- tplFuncs := template.FuncMap{
- "getAllowTokens": getAllowTokens,
- "getNumberSize": getNumberSize,
- "getType": getType,
- "handleField": handleField,
- "handleFieldAddr": handleFieldAddr,
- "unquoteField": unquoteField,
- "getTmpVarFor": getTmpVarFor,
- }
-
- for k, v := range funcs {
- decodeTpl[k] = template.Must(template.New(k).Funcs(tplFuncs).Parse(v))
- }
-}
-
-type handlerNumeric struct {
- IC *Inception
- Name string
- ParseFunc string
- Typ reflect.Type
- TakeAddr bool
-}
-
-var handlerNumericTxt = `
-{
- {{$ic := .IC}}
-
- if tok == fflib.FFTok_null {
- {{if eq .TakeAddr true}}
- {{.Name}} = nil
- {{end}}
- } else {
- {{if eq .ParseFunc "ParseFloat" }}
- tval, err := fflib.{{ .ParseFunc}}(fs.Output.Bytes(), {{getNumberSize .Typ}})
- {{else}}
- tval, err := fflib.{{ .ParseFunc}}(fs.Output.Bytes(), 10, {{getNumberSize .Typ}})
- {{end}}
-
- if err != nil {
- return fs.WrapErr(err)
- }
- {{if eq .TakeAddr true}}
- ttypval := {{getType $ic .Name .Typ}}(tval)
- {{.Name}} = &ttypval
- {{else}}
- {{.Name}} = {{getType $ic .Name .Typ}}(tval)
- {{end}}
- }
-}
-`
-
-type allowTokens struct {
- Name string
- Tokens []string
-}
-
-var allowTokensTxt = `
-{
- if {{range $index, $element := .Tokens}}{{if ne $index 0 }}&&{{end}} tok != fflib.{{$element}}{{end}} {
- return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for {{.Name}}", tok))
- }
-}
-`
-
-type handleFallback struct {
- Name string
- Typ reflect.Type
- Kind reflect.Kind
-}
-
-var handleFallbackTxt = `
-{
- /* Falling back. type={{printf "%v" .Typ}} kind={{printf "%v" .Kind}} */
- tbuf, err := fs.CaptureField(tok)
- if err != nil {
- return fs.WrapErr(err)
- }
-
- err = json.Unmarshal(tbuf, &{{.Name}})
- if err != nil {
- return fs.WrapErr(err)
- }
-}
-`
-
-type handleString struct {
- IC *Inception
- Name string
- Typ reflect.Type
- TakeAddr bool
- Quoted bool
-}
-
-var handleStringTxt = `
-{
- {{$ic := .IC}}
-
- {{getAllowTokens .Typ.Name "FFTok_string" "FFTok_null"}}
- if tok == fflib.FFTok_null {
- {{if eq .TakeAddr true}}
- {{.Name}} = nil
- {{end}}
- } else {
- {{if eq .TakeAddr true}}
- var tval {{getType $ic .Name .Typ}}
- outBuf := fs.Output.Bytes()
- {{unquoteField .Quoted}}
- tval = {{getType $ic .Name .Typ}}(string(outBuf))
- {{.Name}} = &tval
- {{else}}
- outBuf := fs.Output.Bytes()
- {{unquoteField .Quoted}}
- {{.Name}} = {{getType $ic .Name .Typ}}(string(outBuf))
- {{end}}
- }
-}
-`
-
-type handleObject struct {
- IC *Inception
- Name string
- Typ reflect.Type
- Ptr reflect.Kind
- TakeAddr bool
-}
-
-var handleObjectTxt = `
-{
- {{$ic := .IC}}
- {{getAllowTokens .Typ.Name "FFTok_left_bracket" "FFTok_null"}}
- if tok == fflib.FFTok_null {
- {{.Name}} = nil
- } else {
-
- {{if eq .TakeAddr true}}
- {{if eq .Typ.Elem.Kind .Ptr }}
- {{if eq .Typ.Key.Kind .Ptr }}
- var tval = make(map[*{{getType $ic .Name .Typ.Key.Elem}}]*{{getType $ic .Name .Typ.Elem.Elem}}, 0)
- {{else}}
- var tval = make(map[{{getType $ic .Name .Typ.Key}}]*{{getType $ic .Name .Typ.Elem.Elem}}, 0)
- {{end}}
- {{else}}
- {{if eq .Typ.Key.Kind .Ptr }}
- var tval = make(map[*{{getType $ic .Name .Typ.Key.Elem}}]{{getType $ic .Name .Typ.Elem}}, 0)
- {{else}}
- var tval = make(map[{{getType $ic .Name .Typ.Key}}]{{getType $ic .Name .Typ.Elem}}, 0)
- {{end}}
- {{end}}
- {{else}}
- {{if eq .Typ.Elem.Kind .Ptr }}
- {{if eq .Typ.Key.Kind .Ptr }}
- {{.Name}} = make(map[*{{getType $ic .Name .Typ.Key.Elem}}]*{{getType $ic .Name .Typ.Elem.Elem}}, 0)
- {{else}}
- {{.Name}} = make(map[{{getType $ic .Name .Typ.Key}}]*{{getType $ic .Name .Typ.Elem.Elem}}, 0)
- {{end}}
- {{else}}
- {{if eq .Typ.Key.Kind .Ptr }}
- {{.Name}} = make(map[*{{getType $ic .Name .Typ.Key.Elem}}]{{getType $ic .Name .Typ.Elem}}, 0)
- {{else}}
- {{.Name}} = make(map[{{getType $ic .Name .Typ.Key}}]{{getType $ic .Name .Typ.Elem}}, 0)
- {{end}}
- {{end}}
- {{end}}
-
- wantVal := true
-
- for {
- {{$keyPtr := false}}
- {{if eq .Typ.Key.Kind .Ptr }}
- {{$keyPtr := true}}
- var k *{{getType $ic .Name .Typ.Key.Elem}}
- {{else}}
- var k {{getType $ic .Name .Typ.Key}}
- {{end}}
-
- {{$valPtr := false}}
- {{$tmpVar := getTmpVarFor .Name}}
- {{if eq .Typ.Elem.Kind .Ptr }}
- {{$valPtr := true}}
- var {{$tmpVar}} *{{getType $ic .Name .Typ.Elem.Elem}}
- {{else}}
- var {{$tmpVar}} {{getType $ic .Name .Typ.Elem}}
- {{end}}
-
- tok = fs.Scan()
- if tok == fflib.FFTok_error {
- goto tokerror
- }
- if tok == fflib.FFTok_right_bracket {
- break
- }
-
- if tok == fflib.FFTok_comma {
- if wantVal == true {
- // TODO(pquerna): this isn't an ideal error message, this handles
- // things like [,,,] as an array value.
- return fs.WrapErr(fmt.Errorf("wanted value token, but got token: %v", tok))
- }
- continue
- } else {
- wantVal = true
- }
-
- {{handleField .IC "k" .Typ.Key $keyPtr false}}
-
- // Expect ':' after key
- tok = fs.Scan()
- if tok != fflib.FFTok_colon {
- return fs.WrapErr(fmt.Errorf("wanted colon token, but got token: %v", tok))
- }
-
- tok = fs.Scan()
- {{handleField .IC $tmpVar .Typ.Elem $valPtr false}}
-
- {{if eq .TakeAddr true}}
- tval[k] = {{$tmpVar}}
- {{else}}
- {{.Name}}[k] = {{$tmpVar}}
- {{end}}
- wantVal = false
- }
-
- {{if eq .TakeAddr true}}
- {{.Name}} = &tval
- {{end}}
- }
-}
-`
-
-type handleArray struct {
- IC *Inception
- Name string
- Typ reflect.Type
- Ptr reflect.Kind
- UseReflectToSet bool
- IsPtr bool
-}
-
-var handleArrayTxt = `
-{
- {{$ic := .IC}}
- {{getAllowTokens .Typ.Name "FFTok_left_brace" "FFTok_null"}}
- {{if eq .Typ.Elem.Kind .Ptr}}
- {{.Name}} = [{{.Typ.Len}}]*{{getType $ic .Name .Typ.Elem.Elem}}{}
- {{else}}
- {{.Name}} = [{{.Typ.Len}}]{{getType $ic .Name .Typ.Elem}}{}
- {{end}}
- if tok != fflib.FFTok_null {
- wantVal := true
-
- idx := 0
- for {
- {{$ptr := false}}
- {{$tmpVar := getTmpVarFor .Name}}
- {{if eq .Typ.Elem.Kind .Ptr }}
- {{$ptr := true}}
- var {{$tmpVar}} *{{getType $ic .Name .Typ.Elem.Elem}}
- {{else}}
- var {{$tmpVar}} {{getType $ic .Name .Typ.Elem}}
- {{end}}
-
- tok = fs.Scan()
- if tok == fflib.FFTok_error {
- goto tokerror
- }
- if tok == fflib.FFTok_right_brace {
- break
- }
-
- if tok == fflib.FFTok_comma {
- if wantVal == true {
- // TODO(pquerna): this isn't an ideal error message, this handles
- // things like [,,,] as an array value.
- return fs.WrapErr(fmt.Errorf("wanted value token, but got token: %v", tok))
- }
- continue
- } else {
- wantVal = true
- }
-
- {{handleField .IC $tmpVar .Typ.Elem $ptr false}}
-
- // Standard json.Unmarshal ignores elements out of array bounds,
- // that what we do as well.
- if idx < {{.Typ.Len}} {
- {{.Name}}[idx] = {{$tmpVar}}
- idx++
- }
-
- wantVal = false
- }
- }
-}
-`
-
-var handleSliceTxt = `
-{
- {{$ic := .IC}}
- {{getAllowTokens .Typ.Name "FFTok_left_brace" "FFTok_null"}}
- if tok == fflib.FFTok_null {
- {{.Name}} = nil
- } else {
- {{if eq .Typ.Elem.Kind .Ptr }}
- {{if eq .IsPtr true}}
- {{.Name}} = &[]*{{getType $ic .Name .Typ.Elem.Elem}}{}
- {{else}}
- {{.Name}} = []*{{getType $ic .Name .Typ.Elem.Elem}}{}
- {{end}}
- {{else}}
- {{if eq .IsPtr true}}
- {{.Name}} = &[]{{getType $ic .Name .Typ.Elem}}{}
- {{else}}
- {{.Name}} = []{{getType $ic .Name .Typ.Elem}}{}
- {{end}}
- {{end}}
-
- wantVal := true
-
- for {
- {{$ptr := false}}
- {{$tmpVar := getTmpVarFor .Name}}
- {{if eq .Typ.Elem.Kind .Ptr }}
- {{$ptr := true}}
- var {{$tmpVar}} *{{getType $ic .Name .Typ.Elem.Elem}}
- {{else}}
- var {{$tmpVar}} {{getType $ic .Name .Typ.Elem}}
- {{end}}
-
- tok = fs.Scan()
- if tok == fflib.FFTok_error {
- goto tokerror
- }
- if tok == fflib.FFTok_right_brace {
- break
- }
-
- if tok == fflib.FFTok_comma {
- if wantVal == true {
- // TODO(pquerna): this isn't an ideal error message, this handles
- // things like [,,,] as an array value.
- return fs.WrapErr(fmt.Errorf("wanted value token, but got token: %v", tok))
- }
- continue
- } else {
- wantVal = true
- }
-
- {{handleField .IC $tmpVar .Typ.Elem $ptr false}}
- {{if eq .IsPtr true}}
- *{{.Name}} = append(*{{.Name}}, {{$tmpVar}})
- {{else}}
- {{.Name}} = append({{.Name}}, {{$tmpVar}})
- {{end}}
- wantVal = false
- }
- }
-}
-`
-
-var handleByteSliceTxt = `
-{
- {{getAllowTokens .Typ.Name "FFTok_string" "FFTok_null"}}
- if tok == fflib.FFTok_null {
- {{.Name}} = nil
- } else {
- b := make([]byte, base64.StdEncoding.DecodedLen(fs.Output.Len()))
- n, err := base64.StdEncoding.Decode(b, fs.Output.Bytes())
- if err != nil {
- return fs.WrapErr(err)
- }
- {{if eq .UseReflectToSet true}}
- v := reflect.ValueOf(&{{.Name}}).Elem()
- v.SetBytes(b[0:n])
- {{else}}
- {{.Name}} = append([]byte(), b[0:n]...)
- {{end}}
- }
-}
-`
-
-type handleBool struct {
- Name string
- Typ reflect.Type
- TakeAddr bool
-}
-
-var handleBoolTxt = `
-{
- if tok == fflib.FFTok_null {
- {{if eq .TakeAddr true}}
- {{.Name}} = nil
- {{end}}
- } else {
- tmpb := fs.Output.Bytes()
-
- {{if eq .TakeAddr true}}
- var tval bool
- {{end}}
-
- if bytes.Compare([]byte{'t', 'r', 'u', 'e'}, tmpb) == 0 {
- {{if eq .TakeAddr true}}
- tval = true
- {{else}}
- {{.Name}} = true
- {{end}}
- } else if bytes.Compare([]byte{'f', 'a', 'l', 's', 'e'}, tmpb) == 0 {
- {{if eq .TakeAddr true}}
- tval = false
- {{else}}
- {{.Name}} = false
- {{end}}
- } else {
- err = errors.New("unexpected bytes for true/false value")
- return fs.WrapErr(err)
- }
-
- {{if eq .TakeAddr true}}
- {{.Name}} = &tval
- {{end}}
- }
-}
-`
-
-type handlePtr struct {
- IC *Inception
- Name string
- Typ reflect.Type
- Quoted bool
-}
-
-var handlePtrTxt = `
-{
- {{$ic := .IC}}
-
- if tok == fflib.FFTok_null {
- {{.Name}} = nil
- } else {
- if {{.Name}} == nil {
- {{.Name}} = new({{getType $ic .Typ.Elem.Name .Typ.Elem}})
- }
-
- {{handleFieldAddr .IC .Name true .Typ.Elem false .Quoted}}
- }
-}
-`
-
-type header struct {
- IC *Inception
- SI *StructInfo
-}
-
-var headerTxt = `
-const (
- ffjt{{.SI.Name}}base = iota
- ffjt{{.SI.Name}}nosuchkey
- {{with $si := .SI}}
- {{range $index, $field := $si.Fields}}
- {{if ne $field.JsonName "-"}}
- ffjt{{$si.Name}}{{$field.Name}}
- {{end}}
- {{end}}
- {{end}}
-)
-
-{{with $si := .SI}}
- {{range $index, $field := $si.Fields}}
- {{if ne $field.JsonName "-"}}
-var ffjKey{{$si.Name}}{{$field.Name}} = []byte({{$field.JsonName}})
- {{end}}
- {{end}}
-{{end}}
-
-`
-
-type ujFunc struct {
- IC *Inception
- SI *StructInfo
- ValidValues []string
- ResetFields bool
-}
-
-var ujFuncTxt = `
-{{$si := .SI}}
-{{$ic := .IC}}
-
-// UnmarshalJSON umarshall json - template of ffjson
-func (j *{{.SI.Name}}) UnmarshalJSON(input []byte) error {
- fs := fflib.NewFFLexer(input)
- return j.UnmarshalJSONFFLexer(fs, fflib.FFParse_map_start)
-}
-
-// UnmarshalJSONFFLexer fast json unmarshall - template ffjson
-func (j *{{.SI.Name}}) UnmarshalJSONFFLexer(fs *fflib.FFLexer, state fflib.FFParseState) error {
- var err error
- currentKey := ffjt{{.SI.Name}}base
- _ = currentKey
- tok := fflib.FFTok_init
- wantedTok := fflib.FFTok_init
-
- {{if eq .ResetFields true}}
- {{range $index, $field := $si.Fields}}
- var ffjSet{{$si.Name}}{{$field.Name}} = false
- {{end}}
- {{end}}
-
-mainparse:
- for {
- tok = fs.Scan()
- // println(fmt.Sprintf("debug: tok: %v state: %v", tok, state))
- if tok == fflib.FFTok_error {
- goto tokerror
- }
-
- switch state {
-
- case fflib.FFParse_map_start:
- if tok != fflib.FFTok_left_bracket {
- wantedTok = fflib.FFTok_left_bracket
- goto wrongtokenerror
- }
- state = fflib.FFParse_want_key
- continue
-
- case fflib.FFParse_after_value:
- if tok == fflib.FFTok_comma {
- state = fflib.FFParse_want_key
- } else if tok == fflib.FFTok_right_bracket {
- goto done
- } else {
- wantedTok = fflib.FFTok_comma
- goto wrongtokenerror
- }
-
- case fflib.FFParse_want_key:
- // json {} ended. goto exit. woo.
- if tok == fflib.FFTok_right_bracket {
- goto done
- }
- if tok != fflib.FFTok_string {
- wantedTok = fflib.FFTok_string
- goto wrongtokenerror
- }
-
- kn := fs.Output.Bytes()
- if len(kn) <= 0 {
- // "" case. hrm.
- currentKey = ffjt{{.SI.Name}}nosuchkey
- state = fflib.FFParse_want_colon
- goto mainparse
- } else {
- switch kn[0] {
- {{range $byte, $fields := $si.FieldsByFirstByte}}
- case '{{$byte}}':
- {{range $index, $field := $fields}}
- {{if ne $index 0 }}} else if {{else}}if {{end}} bytes.Equal(ffjKey{{$si.Name}}{{$field.Name}}, kn) {
- currentKey = ffjt{{$si.Name}}{{$field.Name}}
- state = fflib.FFParse_want_colon
- goto mainparse
- {{end}} }
- {{end}}
- }
- {{range $index, $field := $si.ReverseFields}}
- if {{$field.FoldFuncName}}(ffjKey{{$si.Name}}{{$field.Name}}, kn) {
- currentKey = ffjt{{$si.Name}}{{$field.Name}}
- state = fflib.FFParse_want_colon
- goto mainparse
- }
- {{end}}
- currentKey = ffjt{{.SI.Name}}nosuchkey
- state = fflib.FFParse_want_colon
- goto mainparse
- }
-
- case fflib.FFParse_want_colon:
- if tok != fflib.FFTok_colon {
- wantedTok = fflib.FFTok_colon
- goto wrongtokenerror
- }
- state = fflib.FFParse_want_value
- continue
- case fflib.FFParse_want_value:
-
- if {{range $index, $v := .ValidValues}}{{if ne $index 0 }}||{{end}}tok == fflib.{{$v}}{{end}} {
- switch currentKey {
- {{range $index, $field := $si.Fields}}
- case ffjt{{$si.Name}}{{$field.Name}}:
- goto handle_{{$field.Name}}
- {{end}}
- case ffjt{{$si.Name}}nosuchkey:
- err = fs.SkipField(tok)
- if err != nil {
- return fs.WrapErr(err)
- }
- state = fflib.FFParse_after_value
- goto mainparse
- }
- } else {
- goto wantedvalue
- }
- }
- }
-{{range $index, $field := $si.Fields}}
-handle_{{$field.Name}}:
- {{with $fieldName := $field.Name | printf "j.%s"}}
- {{handleField $ic $fieldName $field.Typ $field.Pointer $field.ForceString}}
- {{if eq $.ResetFields true}}
- ffjSet{{$si.Name}}{{$field.Name}} = true
- {{end}}
- state = fflib.FFParse_after_value
- goto mainparse
- {{end}}
-{{end}}
-
-wantedvalue:
- return fs.WrapErr(fmt.Errorf("wanted value token, but got token: %v", tok))
-wrongtokenerror:
- return fs.WrapErr(fmt.Errorf("ffjson: wanted token: %v, but got token: %v output=%s", wantedTok, tok, fs.Output.String()))
-tokerror:
- if fs.BigError != nil {
- return fs.WrapErr(fs.BigError)
- }
- err = fs.Error.ToError()
- if err != nil {
- return fs.WrapErr(err)
- }
- panic("ffjson-generated: unreachable, please report bug.")
-done:
-{{if eq .ResetFields true}}
-{{range $index, $field := $si.Fields}}
- if !ffjSet{{$si.Name}}{{$field.Name}} {
- {{with $fieldName := $field.Name | printf "j.%s"}}
- {{if eq $field.Pointer true}}
- {{$fieldName}} = nil
- {{else if eq $field.Typ.Kind ` + strconv.FormatUint(uint64(reflect.Interface), 10) + `}}
- {{$fieldName}} = nil
- {{else if eq $field.Typ.Kind ` + strconv.FormatUint(uint64(reflect.Slice), 10) + `}}
- {{$fieldName}} = nil
- {{else if eq $field.Typ.Kind ` + strconv.FormatUint(uint64(reflect.Array), 10) + `}}
- {{$fieldName}} = [{{$field.Typ.Len}}]{{getType $ic $fieldName $field.Typ.Elem}}{}
- {{else if eq $field.Typ.Kind ` + strconv.FormatUint(uint64(reflect.Map), 10) + `}}
- {{$fieldName}} = nil
- {{else if eq $field.Typ.Kind ` + strconv.FormatUint(uint64(reflect.Bool), 10) + `}}
- {{$fieldName}} = false
- {{else if eq $field.Typ.Kind ` + strconv.FormatUint(uint64(reflect.String), 10) + `}}
- {{$fieldName}} = ""
- {{else if eq $field.Typ.Kind ` + strconv.FormatUint(uint64(reflect.Struct), 10) + `}}
- {{$fieldName}} = {{getType $ic $fieldName $field.Typ}}{}
- {{else}}
- {{$fieldName}} = {{getType $ic $fieldName $field.Typ}}(0)
- {{end}}
- {{end}}
- }
-{{end}}
-{{end}}
- return nil
-}
-`
-
-type handleUnmarshaler struct {
- IC *Inception
- Name string
- Typ reflect.Type
- Ptr reflect.Kind
- TakeAddr bool
- UnmarshalJSONFFLexer bool
- Unmarshaler bool
-}
-
-var handleUnmarshalerTxt = `
- {{$ic := .IC}}
-
- {{if eq .UnmarshalJSONFFLexer true}}
- {
- if tok == fflib.FFTok_null {
- {{if eq .Typ.Kind .Ptr }}
- {{.Name}} = nil
- {{end}}
- {{if eq .TakeAddr true }}
- {{.Name}} = nil
- {{end}}
- } else {
- {{if eq .Typ.Kind .Ptr }}
- if {{.Name}} == nil {
- {{.Name}} = new({{getType $ic .Typ.Elem.Name .Typ.Elem}})
- }
- {{end}}
- {{if eq .TakeAddr true }}
- if {{.Name}} == nil {
- {{.Name}} = new({{getType $ic .Typ.Name .Typ}})
- }
- {{end}}
- err = {{.Name}}.UnmarshalJSONFFLexer(fs, fflib.FFParse_want_key)
- if err != nil {
- return err
- }
- }
- state = fflib.FFParse_after_value
- }
- {{else}}
- {{if eq .Unmarshaler true}}
- {
- if tok == fflib.FFTok_null {
- {{if eq .TakeAddr true }}
- {{.Name}} = nil
- {{end}}
- } else {
-
- tbuf, err := fs.CaptureField(tok)
- if err != nil {
- return fs.WrapErr(err)
- }
-
- {{if eq .TakeAddr true }}
- if {{.Name}} == nil {
- {{.Name}} = new({{getType $ic .Typ.Name .Typ}})
- }
- {{end}}
- err = {{.Name}}.UnmarshalJSON(tbuf)
- if err != nil {
- return fs.WrapErr(err)
- }
- }
- state = fflib.FFParse_after_value
- }
- {{end}}
- {{end}}
-`
diff --git a/vendor/github.com/pquerna/ffjson/inception/encoder.go b/vendor/github.com/pquerna/ffjson/inception/encoder.go
deleted file mode 100644
index 3e37a2814..000000000
--- a/vendor/github.com/pquerna/ffjson/inception/encoder.go
+++ /dev/null
@@ -1,544 +0,0 @@
-/**
- * Copyright 2014 Paul Querna
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-package ffjsoninception
-
-import (
- "fmt"
- "reflect"
-
- "github.com/pquerna/ffjson/shared"
-)
-
-func typeInInception(ic *Inception, typ reflect.Type, f shared.Feature) bool {
- for _, v := range ic.objs {
- if v.Typ == typ {
- return v.Options.HasFeature(f)
- }
- if typ.Kind() == reflect.Ptr {
- if v.Typ == typ.Elem() {
- return v.Options.HasFeature(f)
- }
- }
- }
-
- return false
-}
-
-func getOmitEmpty(ic *Inception, sf *StructField) string {
- ptname := "j." + sf.Name
- if sf.Pointer {
- ptname = "*" + ptname
- return "if true {\n"
- }
- switch sf.Typ.Kind() {
-
- case reflect.Array, reflect.Map, reflect.Slice, reflect.String:
- return "if len(" + ptname + ") != 0 {" + "\n"
-
- case reflect.Int,
- reflect.Int8,
- reflect.Int16,
- reflect.Int32,
- reflect.Int64,
- reflect.Uint,
- reflect.Uint8,
- reflect.Uint16,
- reflect.Uint32,
- reflect.Uint64,
- reflect.Uintptr,
- reflect.Float32,
- reflect.Float64:
- return "if " + ptname + " != 0 {" + "\n"
-
- case reflect.Bool:
- return "if " + ptname + " != false {" + "\n"
-
- case reflect.Interface, reflect.Ptr:
- return "if " + ptname + " != nil {" + "\n"
-
- default:
- // TODO(pquerna): fix types
- return "if true {" + "\n"
- }
-}
-
-func getMapValue(ic *Inception, name string, typ reflect.Type, ptr bool, forceString bool) string {
- var out = ""
-
- if typ.Key().Kind() != reflect.String {
- out += fmt.Sprintf("/* Falling back. type=%v kind=%v */\n", typ, typ.Kind())
- out += ic.q.Flush()
- out += "err = buf.Encode(" + name + ")" + "\n"
- out += "if err != nil {" + "\n"
- out += " return err" + "\n"
- out += "}" + "\n"
- return out
- }
-
- var elemKind reflect.Kind
- elemKind = typ.Elem().Kind()
-
- switch elemKind {
- case reflect.String,
- reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64,
- reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr,
- reflect.Float32,
- reflect.Float64,
- reflect.Bool:
-
- ic.OutputImports[`fflib "github.com/pquerna/ffjson/fflib/v1"`] = true
-
- out += "if " + name + " == nil {" + "\n"
- ic.q.Write("null")
- out += ic.q.GetQueued()
- ic.q.DeleteLast()
- out += "} else {" + "\n"
- out += ic.q.WriteFlush("{ ")
- out += " for key, value := range " + name + " {" + "\n"
- out += " fflib.WriteJsonString(buf, key)" + "\n"
- out += " buf.WriteString(`:`)" + "\n"
- out += getGetInnerValue(ic, "value", typ.Elem(), false, forceString)
- out += " buf.WriteByte(',')" + "\n"
- out += " }" + "\n"
- out += "buf.Rewind(1)" + "\n"
- out += ic.q.WriteFlush("}")
- out += "}" + "\n"
-
- default:
- out += ic.q.Flush()
- out += fmt.Sprintf("/* Falling back. type=%v kind=%v */\n", typ, typ.Kind())
- out += "err = buf.Encode(" + name + ")" + "\n"
- out += "if err != nil {" + "\n"
- out += " return err" + "\n"
- out += "}" + "\n"
- }
- return out
-}
-
-func getGetInnerValue(ic *Inception, name string, typ reflect.Type, ptr bool, forceString bool) string {
- var out = ""
-
- // Flush if not bool or maps
- if typ.Kind() != reflect.Bool && typ.Kind() != reflect.Map && typ.Kind() != reflect.Struct {
- out += ic.q.Flush()
- }
-
- if typ.Implements(marshalerFasterType) ||
- reflect.PtrTo(typ).Implements(marshalerFasterType) ||
- typeInInception(ic, typ, shared.MustEncoder) ||
- typ.Implements(marshalerType) ||
- reflect.PtrTo(typ).Implements(marshalerType) {
-
- out += ic.q.Flush()
- out += tplStr(encodeTpl["handleMarshaler"], handleMarshaler{
- IC: ic,
- Name: name,
- Typ: typ,
- Ptr: reflect.Ptr,
- MarshalJSONBuf: typ.Implements(marshalerFasterType) || reflect.PtrTo(typ).Implements(marshalerFasterType) || typeInInception(ic, typ, shared.MustEncoder),
- Marshaler: typ.Implements(marshalerType) || reflect.PtrTo(typ).Implements(marshalerType),
- })
- return out
- }
-
- ptname := name
- if ptr {
- ptname = "*" + name
- }
-
- switch typ.Kind() {
- case reflect.Int,
- reflect.Int8,
- reflect.Int16,
- reflect.Int32,
- reflect.Int64:
- ic.OutputImports[`fflib "github.com/pquerna/ffjson/fflib/v1"`] = true
- out += "fflib.FormatBits2(buf, uint64(" + ptname + "), 10, " + ptname + " < 0)" + "\n"
- case reflect.Uint,
- reflect.Uint8,
- reflect.Uint16,
- reflect.Uint32,
- reflect.Uint64,
- reflect.Uintptr:
- ic.OutputImports[`fflib "github.com/pquerna/ffjson/fflib/v1"`] = true
- out += "fflib.FormatBits2(buf, uint64(" + ptname + "), 10, false)" + "\n"
- case reflect.Float32:
- ic.OutputImports[`fflib "github.com/pquerna/ffjson/fflib/v1"`] = true
- out += "fflib.AppendFloat(buf, float64(" + ptname + "), 'g', -1, 32)" + "\n"
- case reflect.Float64:
- ic.OutputImports[`fflib "github.com/pquerna/ffjson/fflib/v1"`] = true
- out += "fflib.AppendFloat(buf, float64(" + ptname + "), 'g', -1, 64)" + "\n"
- case reflect.Array,
- reflect.Slice:
-
- // Arrays cannot be nil
- if typ.Kind() != reflect.Array {
- out += "if " + name + "!= nil {" + "\n"
- }
- // Array and slice values encode as JSON arrays, except that
- // []byte encodes as a base64-encoded string, and a nil slice
- // encodes as the null JSON object.
- if typ.Kind() == reflect.Slice && typ.Elem().Kind() == reflect.Uint8 {
- ic.OutputImports[`"encoding/base64"`] = true
-
- out += "buf.WriteString(`\"`)" + "\n"
- out += `{` + "\n"
- out += `enc := base64.NewEncoder(base64.StdEncoding, buf)` + "\n"
- if typ.Elem().Name() != "byte" {
- ic.OutputImports[`"reflect"`] = true
- out += `enc.Write(reflect.Indirect(reflect.ValueOf(` + ptname + `)).Bytes())` + "\n"
-
- } else {
- out += `enc.Write(` + ptname + `)` + "\n"
- }
- out += `enc.Close()` + "\n"
- out += `}` + "\n"
- out += "buf.WriteString(`\"`)" + "\n"
- } else {
- out += "buf.WriteString(`[`)" + "\n"
- out += "for i, v := range " + ptname + "{" + "\n"
- out += "if i != 0 {" + "\n"
- out += "buf.WriteString(`,`)" + "\n"
- out += "}" + "\n"
- out += getGetInnerValue(ic, "v", typ.Elem(), false, false)
- out += "}" + "\n"
- out += "buf.WriteString(`]`)" + "\n"
- }
- if typ.Kind() != reflect.Array {
- out += "} else {" + "\n"
- out += "buf.WriteString(`null`)" + "\n"
- out += "}" + "\n"
- }
- case reflect.String:
- // Is it a json.Number?
- if typ.PkgPath() == "encoding/json" && typ.Name() == "Number" {
- // Fall back to json package to rely on the valid number check.
- // See: https://github.com/golang/go/blob/92cd6e3af9f423ab4d8ac78f24e7fd81c31a8ce6/src/encoding/json/encode.go#L550
- out += fmt.Sprintf("/* json.Number */\n")
- out += "err = buf.Encode(" + name + ")" + "\n"
- out += "if err != nil {" + "\n"
- out += " return err" + "\n"
- out += "}" + "\n"
- } else {
- ic.OutputImports[`fflib "github.com/pquerna/ffjson/fflib/v1"`] = true
- if forceString {
- // Forcestring on strings does double-escaping of the entire value.
- // We create a temporary buffer, encode to that an re-encode it.
- out += "{" + "\n"
- out += "tmpbuf := fflib.Buffer{}" + "\n"
- out += "tmpbuf.Grow(len(" + ptname + ") + 16)" + "\n"
- out += "fflib.WriteJsonString(&tmpbuf, string(" + ptname + "))" + "\n"
- out += "fflib.WriteJsonString(buf, string( tmpbuf.Bytes() " + `))` + "\n"
- out += "}" + "\n"
- } else {
- out += "fflib.WriteJsonString(buf, string(" + ptname + "))" + "\n"
- }
- }
- case reflect.Ptr:
- out += "if " + name + "!= nil {" + "\n"
- switch typ.Elem().Kind() {
- case reflect.Struct:
- out += getGetInnerValue(ic, name, typ.Elem(), false, false)
- default:
- out += getGetInnerValue(ic, "*"+name, typ.Elem(), false, false)
- }
- out += "} else {" + "\n"
- out += "buf.WriteString(`null`)" + "\n"
- out += "}" + "\n"
- case reflect.Bool:
- out += "if " + ptname + " {" + "\n"
- ic.q.Write("true")
- out += ic.q.GetQueued()
- out += "} else {" + "\n"
- // Delete 'true'
- ic.q.DeleteLast()
- out += ic.q.WriteFlush("false")
- out += "}" + "\n"
- case reflect.Interface:
- out += fmt.Sprintf("/* Interface types must use runtime reflection. type=%v kind=%v */\n", typ, typ.Kind())
- out += "err = buf.Encode(" + name + ")" + "\n"
- out += "if err != nil {" + "\n"
- out += " return err" + "\n"
- out += "}" + "\n"
- case reflect.Map:
- out += getMapValue(ic, ptname, typ, ptr, forceString)
- case reflect.Struct:
- if typ.Name() == "" {
- ic.q.Write("{")
- ic.q.Write(" ")
- out += fmt.Sprintf("/* Inline struct. type=%v kind=%v */\n", typ, typ.Kind())
- newV := reflect.Indirect(reflect.New(typ)).Interface()
- fields := extractFields(newV)
-
- // Output all fields
- for _, field := range fields {
- // Adjust field name
- field.Name = name + "." + field.Name
- out += getField(ic, field, "")
- }
-
- if lastConditional(fields) {
- out += ic.q.Flush()
- out += `buf.Rewind(1)` + "\n"
- } else {
- ic.q.DeleteLast()
- }
- out += ic.q.WriteFlush("}")
- } else {
- out += fmt.Sprintf("/* Struct fall back. type=%v kind=%v */\n", typ, typ.Kind())
- out += ic.q.Flush()
- if ptr {
- out += "err = buf.Encode(" + name + ")" + "\n"
- } else {
- // We send pointer to avoid copying entire struct
- out += "err = buf.Encode(&" + name + ")" + "\n"
- }
- out += "if err != nil {" + "\n"
- out += " return err" + "\n"
- out += "}" + "\n"
- }
- default:
- out += fmt.Sprintf("/* Falling back. type=%v kind=%v */\n", typ, typ.Kind())
- out += "err = buf.Encode(" + name + ")" + "\n"
- out += "if err != nil {" + "\n"
- out += " return err" + "\n"
- out += "}" + "\n"
- }
-
- return out
-}
-
-func getValue(ic *Inception, sf *StructField, prefix string) string {
- closequote := false
- if sf.ForceString {
- switch sf.Typ.Kind() {
- case reflect.Int,
- reflect.Int8,
- reflect.Int16,
- reflect.Int32,
- reflect.Int64,
- reflect.Uint,
- reflect.Uint8,
- reflect.Uint16,
- reflect.Uint32,
- reflect.Uint64,
- reflect.Uintptr,
- reflect.Float32,
- reflect.Float64,
- reflect.Bool:
- ic.q.Write(`"`)
- closequote = true
- }
- }
- out := getGetInnerValue(ic, prefix+sf.Name, sf.Typ, sf.Pointer, sf.ForceString)
- if closequote {
- if sf.Pointer {
- out += ic.q.WriteFlush(`"`)
- } else {
- ic.q.Write(`"`)
- }
- }
-
- return out
-}
-
-func p2(v uint32) uint32 {
- v--
- v |= v >> 1
- v |= v >> 2
- v |= v >> 4
- v |= v >> 8
- v |= v >> 16
- v++
- return v
-}
-
-func getTypeSize(t reflect.Type) uint32 {
- switch t.Kind() {
- case reflect.String:
- // TODO: consider runtime analysis.
- return 32
- case reflect.Array, reflect.Map, reflect.Slice:
- // TODO: consider runtime analysis.
- return 4 * getTypeSize(t.Elem())
- case reflect.Int,
- reflect.Int8,
- reflect.Int16,
- reflect.Int32,
- reflect.Uint,
- reflect.Uint8,
- reflect.Uint16,
- reflect.Uint32:
- return 8
- case reflect.Int64,
- reflect.Uint64,
- reflect.Uintptr:
- return 16
- case reflect.Float32,
- reflect.Float64:
- return 16
- case reflect.Bool:
- return 4
- case reflect.Ptr:
- return getTypeSize(t.Elem())
- default:
- return 16
- }
-}
-
-func getTotalSize(si *StructInfo) uint32 {
- rv := uint32(si.Typ.Size())
- for _, f := range si.Fields {
- rv += getTypeSize(f.Typ)
- }
- return rv
-}
-
-func getBufGrowSize(si *StructInfo) uint32 {
-
- // TOOD(pquerna): automatically calc a better grow size based on history
- // of a struct.
- return p2(getTotalSize(si))
-}
-
-func isIntish(t reflect.Type) bool {
- if t.Kind() >= reflect.Int && t.Kind() <= reflect.Uintptr {
- return true
- }
- if t.Kind() == reflect.Array || t.Kind() == reflect.Slice || t.Kind() == reflect.Ptr {
- if t.Kind() == reflect.Slice && t.Elem().Kind() == reflect.Uint8 {
- // base64 special case.
- return false
- } else {
- return isIntish(t.Elem())
- }
- }
- return false
-}
-
-func getField(ic *Inception, f *StructField, prefix string) string {
- out := ""
- if f.OmitEmpty {
- out += ic.q.Flush()
- if f.Pointer {
- out += "if " + prefix + f.Name + " != nil {" + "\n"
- }
- out += getOmitEmpty(ic, f)
- }
-
- if f.Pointer && !f.OmitEmpty {
- // Pointer values encode as the value pointed to. A nil pointer encodes as the null JSON object.
- out += "if " + prefix + f.Name + " != nil {" + "\n"
- }
-
- // JsonName is already escaped and quoted.
- // getInnervalue should flush
- ic.q.Write(f.JsonName + ":")
- // We save a copy in case we need it
- t := ic.q
-
- out += getValue(ic, f, prefix)
- ic.q.Write(",")
-
- if f.Pointer && !f.OmitEmpty {
- out += "} else {" + "\n"
- out += t.WriteFlush("null")
- out += "}" + "\n"
- }
-
- if f.OmitEmpty {
- out += ic.q.Flush()
- if f.Pointer {
- out += "}" + "\n"
- }
- out += "}" + "\n"
- }
- return out
-}
-
-// We check if the last field is conditional.
-func lastConditional(fields []*StructField) bool {
- if len(fields) > 0 {
- f := fields[len(fields)-1]
- return f.OmitEmpty
- }
- return false
-}
-
-func CreateMarshalJSON(ic *Inception, si *StructInfo) error {
- conditionalWrites := lastConditional(si.Fields)
- out := ""
-
- out += "// MarshalJSON marshal bytes to json - template\n"
- out += `func (j *` + si.Name + `) MarshalJSON() ([]byte, error) {` + "\n"
- out += `var buf fflib.Buffer` + "\n"
-
- out += `if j == nil {` + "\n"
- out += ` buf.WriteString("null")` + "\n"
- out += " return buf.Bytes(), nil" + "\n"
- out += `}` + "\n"
-
- out += `err := j.MarshalJSONBuf(&buf)` + "\n"
- out += `if err != nil {` + "\n"
- out += " return nil, err" + "\n"
- out += `}` + "\n"
- out += `return buf.Bytes(), nil` + "\n"
- out += `}` + "\n"
-
- out += "// MarshalJSONBuf marshal buff to json - template\n"
- out += `func (j *` + si.Name + `) MarshalJSONBuf(buf fflib.EncodingBuffer) (error) {` + "\n"
- out += ` if j == nil {` + "\n"
- out += ` buf.WriteString("null")` + "\n"
- out += " return nil" + "\n"
- out += ` }` + "\n"
-
- out += `var err error` + "\n"
- out += `var obj []byte` + "\n"
- out += `_ = obj` + "\n"
- out += `_ = err` + "\n"
-
- ic.q.Write("{")
-
- // The extra space is inserted here.
- // If nothing is written to the field this will be deleted
- // instead of the last comma.
- if conditionalWrites || len(si.Fields) == 0 {
- ic.q.Write(" ")
- }
-
- for _, f := range si.Fields {
- out += getField(ic, f, "j.")
- }
-
- // Handling the last comma is tricky.
- // If the last field has omitempty, conditionalWrites is set.
- // If something has been written, we delete the last comma,
- // by backing up the buffer, otherwise it will delete a space.
- if conditionalWrites {
- out += ic.q.Flush()
- out += `buf.Rewind(1)` + "\n"
- } else {
- ic.q.DeleteLast()
- }
-
- out += ic.q.WriteFlush("}")
- out += `return nil` + "\n"
- out += `}` + "\n"
- ic.OutputFuncs = append(ic.OutputFuncs, out)
- return nil
-}
diff --git a/vendor/github.com/pquerna/ffjson/inception/encoder_tpl.go b/vendor/github.com/pquerna/ffjson/inception/encoder_tpl.go
deleted file mode 100644
index 22ab5292e..000000000
--- a/vendor/github.com/pquerna/ffjson/inception/encoder_tpl.go
+++ /dev/null
@@ -1,73 +0,0 @@
-/**
- * Copyright 2014 Paul Querna
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-package ffjsoninception
-
-import (
- "reflect"
- "text/template"
-)
-
-var encodeTpl map[string]*template.Template
-
-func init() {
- encodeTpl = make(map[string]*template.Template)
-
- funcs := map[string]string{
- "handleMarshaler": handleMarshalerTxt,
- }
- tplFuncs := template.FuncMap{}
-
- for k, v := range funcs {
- encodeTpl[k] = template.Must(template.New(k).Funcs(tplFuncs).Parse(v))
- }
-}
-
-type handleMarshaler struct {
- IC *Inception
- Name string
- Typ reflect.Type
- Ptr reflect.Kind
- MarshalJSONBuf bool
- Marshaler bool
-}
-
-var handleMarshalerTxt = `
- {
- {{if eq .Typ.Kind .Ptr}}
- if {{.Name}} == nil {
- buf.WriteString("null")
- } else {
- {{end}}
-
- {{if eq .MarshalJSONBuf true}}
- err = {{.Name}}.MarshalJSONBuf(buf)
- if err != nil {
- return err
- }
- {{else if eq .Marshaler true}}
- obj, err = {{.Name}}.MarshalJSON()
- if err != nil {
- return err
- }
- buf.Write(obj)
- {{end}}
- {{if eq .Typ.Kind .Ptr}}
- }
- {{end}}
- }
-`
diff --git a/vendor/github.com/pquerna/ffjson/inception/inception.go b/vendor/github.com/pquerna/ffjson/inception/inception.go
deleted file mode 100644
index 10cb2712c..000000000
--- a/vendor/github.com/pquerna/ffjson/inception/inception.go
+++ /dev/null
@@ -1,160 +0,0 @@
-/**
- * Copyright 2014 Paul Querna
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-package ffjsoninception
-
-import (
- "errors"
- "fmt"
- "github.com/pquerna/ffjson/shared"
- "io/ioutil"
- "os"
- "reflect"
- "sort"
-)
-
-type Inception struct {
- objs []*StructInfo
- InputPath string
- OutputPath string
- PackageName string
- PackagePath string
- OutputImports map[string]bool
- OutputFuncs []string
- q ConditionalWrite
- ResetFields bool
-}
-
-func NewInception(inputPath string, packageName string, outputPath string, resetFields bool) *Inception {
- return &Inception{
- objs: make([]*StructInfo, 0),
- InputPath: inputPath,
- OutputPath: outputPath,
- PackageName: packageName,
- OutputFuncs: make([]string, 0),
- OutputImports: make(map[string]bool),
- ResetFields: resetFields,
- }
-}
-
-func (i *Inception) AddMany(objs []shared.InceptionType) {
- for _, obj := range objs {
- i.Add(obj)
- }
-}
-
-func (i *Inception) Add(obj shared.InceptionType) {
- i.objs = append(i.objs, NewStructInfo(obj))
- i.PackagePath = i.objs[0].Typ.PkgPath()
-}
-
-func (i *Inception) wantUnmarshal(si *StructInfo) bool {
- if si.Options.SkipDecoder {
- return false
- }
- typ := si.Typ
- umlx := typ.Implements(unmarshalFasterType) || reflect.PtrTo(typ).Implements(unmarshalFasterType)
- umlstd := typ.Implements(unmarshalerType) || reflect.PtrTo(typ).Implements(unmarshalerType)
- if umlstd && !umlx {
- // structure has UnmarshalJSON, but not our faster version -- skip it.
- return false
- }
- return true
-}
-
-func (i *Inception) wantMarshal(si *StructInfo) bool {
- if si.Options.SkipEncoder {
- return false
- }
- typ := si.Typ
- mlx := typ.Implements(marshalerFasterType) || reflect.PtrTo(typ).Implements(marshalerFasterType)
- mlstd := typ.Implements(marshalerType) || reflect.PtrTo(typ).Implements(marshalerType)
- if mlstd && !mlx {
- // structure has MarshalJSON, but not our faster version -- skip it.
- return false
- }
- return true
-}
-
-type sortedStructs []*StructInfo
-
-func (p sortedStructs) Len() int { return len(p) }
-func (p sortedStructs) Less(i, j int) bool { return p[i].Name < p[j].Name }
-func (p sortedStructs) Swap(i, j int) { p[i], p[j] = p[j], p[i] }
-func (p sortedStructs) Sort() { sort.Sort(p) }
-
-func (i *Inception) generateCode() error {
- // We sort the structs by name, so output if predictable.
- sorted := sortedStructs(i.objs)
- sorted.Sort()
-
- for _, si := range sorted {
- if i.wantMarshal(si) {
- err := CreateMarshalJSON(i, si)
- if err != nil {
- return err
- }
- }
-
- if i.wantUnmarshal(si) {
- err := CreateUnmarshalJSON(i, si)
- if err != nil {
- return err
- }
- }
- }
- return nil
-}
-
-func (i *Inception) handleError(err error) {
- fmt.Fprintf(os.Stderr, "Error: %s:\n\n", err)
- os.Exit(1)
-}
-
-func (i *Inception) Execute() {
- if len(os.Args) != 1 {
- i.handleError(errors.New(fmt.Sprintf("Internal ffjson error: inception executable takes no args: %v", os.Args)))
- return
- }
-
- err := i.generateCode()
- if err != nil {
- i.handleError(err)
- return
- }
-
- data, err := RenderTemplate(i)
- if err != nil {
- i.handleError(err)
- return
- }
-
- stat, err := os.Stat(i.InputPath)
-
- if err != nil {
- i.handleError(err)
- return
- }
-
- err = ioutil.WriteFile(i.OutputPath, data, stat.Mode())
-
- if err != nil {
- i.handleError(err)
- return
- }
-
-}
diff --git a/vendor/github.com/pquerna/ffjson/inception/reflect.go b/vendor/github.com/pquerna/ffjson/inception/reflect.go
deleted file mode 100644
index 8fb0bd5cb..000000000
--- a/vendor/github.com/pquerna/ffjson/inception/reflect.go
+++ /dev/null
@@ -1,290 +0,0 @@
-/**
- * Copyright 2014 Paul Querna
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-package ffjsoninception
-
-import (
- fflib "github.com/pquerna/ffjson/fflib/v1"
- "github.com/pquerna/ffjson/shared"
-
- "bytes"
- "encoding/json"
- "reflect"
- "unicode/utf8"
-)
-
-type StructField struct {
- Name string
- JsonName string
- FoldFuncName string
- Typ reflect.Type
- OmitEmpty bool
- ForceString bool
- HasMarshalJSON bool
- HasUnmarshalJSON bool
- Pointer bool
- Tagged bool
-}
-
-type FieldByJsonName []*StructField
-
-func (a FieldByJsonName) Len() int { return len(a) }
-func (a FieldByJsonName) Swap(i, j int) { a[i], a[j] = a[j], a[i] }
-func (a FieldByJsonName) Less(i, j int) bool { return a[i].JsonName < a[j].JsonName }
-
-type StructInfo struct {
- Name string
- Obj interface{}
- Typ reflect.Type
- Fields []*StructField
- Options shared.StructOptions
-}
-
-func NewStructInfo(obj shared.InceptionType) *StructInfo {
- t := reflect.TypeOf(obj.Obj)
- return &StructInfo{
- Obj: obj.Obj,
- Name: t.Name(),
- Typ: t,
- Fields: extractFields(obj.Obj),
- Options: obj.Options,
- }
-}
-
-func (si *StructInfo) FieldsByFirstByte() map[string][]*StructField {
- rv := make(map[string][]*StructField)
- for _, f := range si.Fields {
- b := string(f.JsonName[1])
- rv[b] = append(rv[b], f)
- }
- return rv
-}
-
-func (si *StructInfo) ReverseFields() []*StructField {
- var i int
- rv := make([]*StructField, 0)
- for i = len(si.Fields) - 1; i >= 0; i-- {
- rv = append(rv, si.Fields[i])
- }
- return rv
-}
-
-const (
- caseMask = ^byte(0x20) // Mask to ignore case in ASCII.
-)
-
-func foldFunc(key []byte) string {
- nonLetter := false
- special := false // special letter
- for _, b := range key {
- if b >= utf8.RuneSelf {
- return "bytes.EqualFold"
- }
- upper := b & caseMask
- if upper < 'A' || upper > 'Z' {
- nonLetter = true
- } else if upper == 'K' || upper == 'S' {
- // See above for why these letters are special.
- special = true
- }
- }
- if special {
- return "fflib.EqualFoldRight"
- }
- if nonLetter {
- return "fflib.AsciiEqualFold"
- }
- return "fflib.SimpleLetterEqualFold"
-}
-
-type MarshalerFaster interface {
- MarshalJSONBuf(buf fflib.EncodingBuffer) error
-}
-
-type UnmarshalFaster interface {
- UnmarshalJSONFFLexer(l *fflib.FFLexer, state fflib.FFParseState) error
-}
-
-var marshalerType = reflect.TypeOf(new(json.Marshaler)).Elem()
-var marshalerFasterType = reflect.TypeOf(new(MarshalerFaster)).Elem()
-var unmarshalerType = reflect.TypeOf(new(json.Unmarshaler)).Elem()
-var unmarshalFasterType = reflect.TypeOf(new(UnmarshalFaster)).Elem()
-
-// extractFields returns a list of fields that JSON should recognize for the given type.
-// The algorithm is breadth-first search over the set of structs to include - the top struct
-// and then any reachable anonymous structs.
-func extractFields(obj interface{}) []*StructField {
- t := reflect.TypeOf(obj)
- // Anonymous fields to explore at the current level and the next.
- current := []StructField{}
- next := []StructField{{Typ: t}}
-
- // Count of queued names for current level and the next.
- count := map[reflect.Type]int{}
- nextCount := map[reflect.Type]int{}
-
- // Types already visited at an earlier level.
- visited := map[reflect.Type]bool{}
-
- // Fields found.
- var fields []*StructField
-
- for len(next) > 0 {
- current, next = next, current[:0]
- count, nextCount = nextCount, map[reflect.Type]int{}
-
- for _, f := range current {
- if visited[f.Typ] {
- continue
- }
- visited[f.Typ] = true
-
- // Scan f.typ for fields to include.
- for i := 0; i < f.Typ.NumField(); i++ {
- sf := f.Typ.Field(i)
- if sf.PkgPath != "" { // unexported
- continue
- }
- tag := sf.Tag.Get("json")
- if tag == "-" {
- continue
- }
- name, opts := parseTag(tag)
- if !isValidTag(name) {
- name = ""
- }
-
- ft := sf.Type
- ptr := false
- if ft.Kind() == reflect.Ptr {
- ptr = true
- }
-
- if ft.Name() == "" && ft.Kind() == reflect.Ptr {
- // Follow pointer.
- ft = ft.Elem()
- }
-
- // Record found field and index sequence.
- if name != "" || !sf.Anonymous || ft.Kind() != reflect.Struct {
- tagged := name != ""
- if name == "" {
- name = sf.Name
- }
-
- var buf bytes.Buffer
- fflib.WriteJsonString(&buf, name)
-
- field := &StructField{
- Name: sf.Name,
- JsonName: string(buf.Bytes()),
- FoldFuncName: foldFunc([]byte(name)),
- Typ: ft,
- HasMarshalJSON: ft.Implements(marshalerType),
- HasUnmarshalJSON: ft.Implements(unmarshalerType),
- OmitEmpty: opts.Contains("omitempty"),
- ForceString: opts.Contains("string"),
- Pointer: ptr,
- Tagged: tagged,
- }
-
- fields = append(fields, field)
-
- if count[f.Typ] > 1 {
- // If there were multiple instances, add a second,
- // so that the annihilation code will see a duplicate.
- // It only cares about the distinction between 1 or 2,
- // so don't bother generating any more copies.
- fields = append(fields, fields[len(fields)-1])
- }
- continue
- }
-
- // Record new anonymous struct to explore in next round.
- nextCount[ft]++
- if nextCount[ft] == 1 {
- next = append(next, StructField{
- Name: ft.Name(),
- Typ: ft,
- })
- }
- }
- }
- }
-
- // Delete all fields that are hidden by the Go rules for embedded fields,
- // except that fields with JSON tags are promoted.
-
- // The fields are sorted in primary order of name, secondary order
- // of field index length. Loop over names; for each name, delete
- // hidden fields by choosing the one dominant field that survives.
- out := fields[:0]
- for advance, i := 0, 0; i < len(fields); i += advance {
- // One iteration per name.
- // Find the sequence of fields with the name of this first field.
- fi := fields[i]
- name := fi.JsonName
- for advance = 1; i+advance < len(fields); advance++ {
- fj := fields[i+advance]
- if fj.JsonName != name {
- break
- }
- }
- if advance == 1 { // Only one field with this name
- out = append(out, fi)
- continue
- }
- dominant, ok := dominantField(fields[i : i+advance])
- if ok {
- out = append(out, dominant)
- }
- }
-
- fields = out
-
- return fields
-}
-
-// dominantField looks through the fields, all of which are known to
-// have the same name, to find the single field that dominates the
-// others using Go's embedding rules, modified by the presence of
-// JSON tags. If there are multiple top-level fields, the boolean
-// will be false: This condition is an error in Go and we skip all
-// the fields.
-func dominantField(fields []*StructField) (*StructField, bool) {
- tagged := -1 // Index of first tagged field.
- for i, f := range fields {
- if f.Tagged {
- if tagged >= 0 {
- // Multiple tagged fields at the same level: conflict.
- // Return no field.
- return nil, false
- }
- tagged = i
- }
- }
- if tagged >= 0 {
- return fields[tagged], true
- }
- // All remaining fields have the same length. If there's more than one,
- // we have a conflict (two fields named "X" at the same level) and we
- // return no field.
- if len(fields) > 1 {
- return nil, false
- }
- return fields[0], true
-}
diff --git a/vendor/github.com/pquerna/ffjson/inception/tags.go b/vendor/github.com/pquerna/ffjson/inception/tags.go
deleted file mode 100644
index ccce101b8..000000000
--- a/vendor/github.com/pquerna/ffjson/inception/tags.go
+++ /dev/null
@@ -1,79 +0,0 @@
-/**
- * Copyright 2014 Paul Querna
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-package ffjsoninception
-
-import (
- "strings"
- "unicode"
-)
-
-// from: http://golang.org/src/pkg/encoding/json/tags.go
-
-// tagOptions is the string following a comma in a struct field's "json"
-// tag, or the empty string. It does not include the leading comma.
-type tagOptions string
-
-// parseTag splits a struct field's json tag into its name and
-// comma-separated options.
-func parseTag(tag string) (string, tagOptions) {
- if idx := strings.Index(tag, ","); idx != -1 {
- return tag[:idx], tagOptions(tag[idx+1:])
- }
- return tag, tagOptions("")
-}
-
-// Contains reports whether a comma-separated list of options
-// contains a particular substr flag. substr must be surrounded by a
-// string boundary or commas.
-func (o tagOptions) Contains(optionName string) bool {
- if len(o) == 0 {
- return false
- }
- s := string(o)
- for s != "" {
- var next string
- i := strings.Index(s, ",")
- if i >= 0 {
- s, next = s[:i], s[i+1:]
- }
- if s == optionName {
- return true
- }
- s = next
- }
- return false
-}
-
-func isValidTag(s string) bool {
- if s == "" {
- return false
- }
- for _, c := range s {
- switch {
- case strings.ContainsRune("!#$%&()*+-./:<=>?@[]^_{|}~ ", c):
- // Backslash and quote chars are reserved, but
- // otherwise any punctuation chars are allowed
- // in a tag name.
- default:
- if !unicode.IsLetter(c) && !unicode.IsDigit(c) {
- return false
- }
- }
- }
- return true
-}
diff --git a/vendor/github.com/pquerna/ffjson/inception/template.go b/vendor/github.com/pquerna/ffjson/inception/template.go
deleted file mode 100644
index 121a23dd8..000000000
--- a/vendor/github.com/pquerna/ffjson/inception/template.go
+++ /dev/null
@@ -1,60 +0,0 @@
-/**
- * Copyright 2014 Paul Querna
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-package ffjsoninception
-
-import (
- "bytes"
- "go/format"
- "text/template"
-)
-
-const ffjsonTemplate = `
-// Code generated by ffjson <https://github.com/pquerna/ffjson>. DO NOT EDIT.
-// source: {{.InputPath}}
-
-package {{.PackageName}}
-
-import (
-{{range $k, $v := .OutputImports}}{{$k}}
-{{end}}
-)
-
-{{range .OutputFuncs}}
-{{.}}
-{{end}}
-
-`
-
-func RenderTemplate(ic *Inception) ([]byte, error) {
- t := template.Must(template.New("ffjson.go").Parse(ffjsonTemplate))
- buf := new(bytes.Buffer)
- err := t.Execute(buf, ic)
- if err != nil {
- return nil, err
- }
- return format.Source(buf.Bytes())
-}
-
-func tplStr(t *template.Template, data interface{}) string {
- buf := bytes.Buffer{}
- err := t.Execute(&buf, data)
- if err != nil {
- panic(err)
- }
- return buf.String()
-}
diff --git a/vendor/github.com/pquerna/ffjson/inception/writerstack.go b/vendor/github.com/pquerna/ffjson/inception/writerstack.go
deleted file mode 100644
index 1521961c9..000000000
--- a/vendor/github.com/pquerna/ffjson/inception/writerstack.go
+++ /dev/null
@@ -1,65 +0,0 @@
-package ffjsoninception
-
-import "strings"
-
-// ConditionalWrite is a stack containing a number of pending writes
-type ConditionalWrite struct {
- Queued []string
-}
-
-// Write will add a string to be written
-func (w *ConditionalWrite) Write(s string) {
- w.Queued = append(w.Queued, s)
-}
-
-// DeleteLast will delete the last added write
-func (w *ConditionalWrite) DeleteLast() {
- if len(w.Queued) == 0 {
- return
- }
- w.Queued = w.Queued[:len(w.Queued)-1]
-}
-
-// Last will return the last added write
-func (w *ConditionalWrite) Last() string {
- if len(w.Queued) == 0 {
- return ""
- }
- return w.Queued[len(w.Queued)-1]
-}
-
-// Flush will return all queued writes, and return
-// "" (empty string) in nothing has been queued
-// "buf.WriteByte('" + byte + "')" + '\n' if one bute has been queued.
-// "buf.WriteString(`" + string + "`)" + "\n" if more than one byte has been queued.
-func (w *ConditionalWrite) Flush() string {
- combined := strings.Join(w.Queued, "")
- if len(combined) == 0 {
- return ""
- }
-
- w.Queued = nil
- if len(combined) == 1 {
- return "buf.WriteByte('" + combined + "')" + "\n"
- }
- return "buf.WriteString(`" + combined + "`)" + "\n"
-}
-
-func (w *ConditionalWrite) FlushTo(out string) string {
- out += w.Flush()
- return out
-}
-
-// WriteFlush will add a string and return the Flush result for the queue
-func (w *ConditionalWrite) WriteFlush(s string) string {
- w.Write(s)
- return w.Flush()
-}
-
-// GetQueued will return the current queued content without flushing.
-func (w *ConditionalWrite) GetQueued() string {
- t := w.Queued
- s := w.Flush()
- w.Queued = t
- return s
-}