mirror of https://github.com/k3d-io/k3d
Before this change, we simply did a search/replace on the stringified kubeconfig blob. Now we're parsing it into a kubeconfig struct and modify the fields directly in a more controlled manner. Here's what we change: - server URL: based on the chosen APIHost and APIPort - cluster name: default -> k3d-CLUSTERNAME - user name: default -> admin@k3d-CLUSTERNAME - context name: default -> admin@k3d-CLUSTERNAMEpull/226/head
iwilltry42
4 years ago
parent
c51ec003bd
commit
2a76bba98b
@ -0,0 +1,15 @@ |
||||
ISC License |
||||
|
||||
Copyright (c) 2012-2016 Dave Collins <dave@davec.name> |
||||
|
||||
Permission to use, copy, modify, and/or distribute this software for any |
||||
purpose with or without fee is hereby granted, provided that the above |
||||
copyright notice and this permission notice appear in all copies. |
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES |
||||
WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF |
||||
MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR |
||||
ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES |
||||
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN |
||||
ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF |
||||
OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. |
||||
@ -0,0 +1,145 @@ |
||||
// Copyright (c) 2015-2016 Dave Collins <dave@davec.name>
|
||||
//
|
||||
// Permission to use, copy, modify, and distribute this software for any
|
||||
// purpose with or without fee is hereby granted, provided that the above
|
||||
// copyright notice and this permission notice appear in all copies.
|
||||
//
|
||||
// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
|
||||
// WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
|
||||
// MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
|
||||
// ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
|
||||
// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
|
||||
// ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
|
||||
// OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
||||
|
||||
// NOTE: Due to the following build constraints, this file will only be compiled
|
||||
// when the code is not running on Google App Engine, compiled by GopherJS, and
|
||||
// "-tags safe" is not added to the go build command line. The "disableunsafe"
|
||||
// tag is deprecated and thus should not be used.
|
||||
// Go versions prior to 1.4 are disabled because they use a different layout
|
||||
// for interfaces which make the implementation of unsafeReflectValue more complex.
|
||||
// +build !js,!appengine,!safe,!disableunsafe,go1.4
|
||||
|
||||
package spew |
||||
|
||||
import ( |
||||
"reflect" |
||||
"unsafe" |
||||
) |
||||
|
||||
const ( |
||||
// UnsafeDisabled is a build-time constant which specifies whether or
|
||||
// not access to the unsafe package is available.
|
||||
UnsafeDisabled = false |
||||
|
||||
// ptrSize is the size of a pointer on the current arch.
|
||||
ptrSize = unsafe.Sizeof((*byte)(nil)) |
||||
) |
||||
|
||||
type flag uintptr |
||||
|
||||
var ( |
||||
// flagRO indicates whether the value field of a reflect.Value
|
||||
// is read-only.
|
||||
flagRO flag |
||||
|
||||
// flagAddr indicates whether the address of the reflect.Value's
|
||||
// value may be taken.
|
||||
flagAddr flag |
||||
) |
||||
|
||||
// flagKindMask holds the bits that make up the kind
|
||||
// part of the flags field. In all the supported versions,
|
||||
// it is in the lower 5 bits.
|
||||
const flagKindMask = flag(0x1f) |
||||
|
||||
// Different versions of Go have used different
|
||||
// bit layouts for the flags type. This table
|
||||
// records the known combinations.
|
||||
var okFlags = []struct { |
||||
ro, addr flag |
||||
}{{ |
||||
// From Go 1.4 to 1.5
|
||||
ro: 1 << 5, |
||||
addr: 1 << 7, |
||||
}, { |
||||
// Up to Go tip.
|
||||
ro: 1<<5 | 1<<6, |
||||
addr: 1 << 8, |
||||
}} |
||||
|
||||
var flagValOffset = func() uintptr { |
||||
field, ok := reflect.TypeOf(reflect.Value{}).FieldByName("flag") |
||||
if !ok { |
||||
panic("reflect.Value has no flag field") |
||||
} |
||||
return field.Offset |
||||
}() |
||||
|
||||
// flagField returns a pointer to the flag field of a reflect.Value.
|
||||
func flagField(v *reflect.Value) *flag { |
||||
return (*flag)(unsafe.Pointer(uintptr(unsafe.Pointer(v)) + flagValOffset)) |
||||
} |
||||
|
||||
// unsafeReflectValue converts the passed reflect.Value into a one that bypasses
|
||||
// the typical safety restrictions preventing access to unaddressable and
|
||||
// unexported data. It works by digging the raw pointer to the underlying
|
||||
// value out of the protected value and generating a new unprotected (unsafe)
|
||||
// reflect.Value to it.
|
||||
//
|
||||
// This allows us to check for implementations of the Stringer and error
|
||||
// interfaces to be used for pretty printing ordinarily unaddressable and
|
||||
// inaccessible values such as unexported struct fields.
|
||||
func unsafeReflectValue(v reflect.Value) reflect.Value { |
||||
if !v.IsValid() || (v.CanInterface() && v.CanAddr()) { |
||||
return v |
||||
} |
||||
flagFieldPtr := flagField(&v) |
||||
*flagFieldPtr &^= flagRO |
||||
*flagFieldPtr |= flagAddr |
||||
return v |
||||
} |
||||
|
||||
// Sanity checks against future reflect package changes
|
||||
// to the type or semantics of the Value.flag field.
|
||||
func init() { |
||||
field, ok := reflect.TypeOf(reflect.Value{}).FieldByName("flag") |
||||
if !ok { |
||||
panic("reflect.Value has no flag field") |
||||
} |
||||
if field.Type.Kind() != reflect.TypeOf(flag(0)).Kind() { |
||||
panic("reflect.Value flag field has changed kind") |
||||
} |
||||
type t0 int |
||||
var t struct { |
||||
A t0 |
||||
// t0 will have flagEmbedRO set.
|
||||
t0 |
||||
// a will have flagStickyRO set
|
||||
a t0 |
||||
} |
||||
vA := reflect.ValueOf(t).FieldByName("A") |
||||
va := reflect.ValueOf(t).FieldByName("a") |
||||
vt0 := reflect.ValueOf(t).FieldByName("t0") |
||||
|
||||
// Infer flagRO from the difference between the flags
|
||||
// for the (otherwise identical) fields in t.
|
||||
flagPublic := *flagField(&vA) |
||||
flagWithRO := *flagField(&va) | *flagField(&vt0) |
||||
flagRO = flagPublic ^ flagWithRO |
||||
|
||||
// Infer flagAddr from the difference between a value
|
||||
// taken from a pointer and not.
|
||||
vPtrA := reflect.ValueOf(&t).Elem().FieldByName("A") |
||||
flagNoPtr := *flagField(&vA) |
||||
flagPtr := *flagField(&vPtrA) |
||||
flagAddr = flagNoPtr ^ flagPtr |
||||
|
||||
// Check that the inferred flags tally with one of the known versions.
|
||||
for _, f := range okFlags { |
||||
if flagRO == f.ro && flagAddr == f.addr { |
||||
return |
||||
} |
||||
} |
||||
panic("reflect.Value read-only flag has changed semantics") |
||||
} |
||||
@ -0,0 +1,38 @@ |
||||
// Copyright (c) 2015-2016 Dave Collins <dave@davec.name>
|
||||
//
|
||||
// Permission to use, copy, modify, and distribute this software for any
|
||||
// purpose with or without fee is hereby granted, provided that the above
|
||||
// copyright notice and this permission notice appear in all copies.
|
||||
//
|
||||
// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
|
||||
// WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
|
||||
// MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
|
||||
// ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
|
||||
// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
|
||||
// ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
|
||||
// OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
||||
|
||||
// NOTE: Due to the following build constraints, this file will only be compiled
|
||||
// when the code is running on Google App Engine, compiled by GopherJS, or
|
||||
// "-tags safe" is added to the go build command line. The "disableunsafe"
|
||||
// tag is deprecated and thus should not be used.
|
||||
// +build js appengine safe disableunsafe !go1.4
|
||||
|
||||
package spew |
||||
|
||||
import "reflect" |
||||
|
||||
const ( |
||||
// UnsafeDisabled is a build-time constant which specifies whether or
|
||||
// not access to the unsafe package is available.
|
||||
UnsafeDisabled = true |
||||
) |
||||
|
||||
// unsafeReflectValue typically converts the passed reflect.Value into a one
|
||||
// that bypasses the typical safety restrictions preventing access to
|
||||
// unaddressable and unexported data. However, doing this relies on access to
|
||||
// the unsafe package. This is a stub version which simply returns the passed
|
||||
// reflect.Value when the unsafe package is not available.
|
||||
func unsafeReflectValue(v reflect.Value) reflect.Value { |
||||
return v |
||||
} |
||||
@ -0,0 +1,341 @@ |
||||
/* |
||||
* Copyright (c) 2013-2016 Dave Collins <dave@davec.name> |
||||
* |
||||
* Permission to use, copy, modify, and distribute this software for any |
||||
* purpose with or without fee is hereby granted, provided that the above |
||||
* copyright notice and this permission notice appear in all copies. |
||||
* |
||||
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES |
||||
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF |
||||
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR |
||||
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES |
||||
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN |
||||
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF |
||||
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. |
||||
*/ |
||||
|
||||
package spew |
||||
|
||||
import ( |
||||
"bytes" |
||||
"fmt" |
||||
"io" |
||||
"reflect" |
||||
"sort" |
||||
"strconv" |
||||
) |
||||
|
||||
// Some constants in the form of bytes to avoid string overhead. This mirrors
|
||||
// the technique used in the fmt package.
|
||||
var ( |
||||
panicBytes = []byte("(PANIC=") |
||||
plusBytes = []byte("+") |
||||
iBytes = []byte("i") |
||||
trueBytes = []byte("true") |
||||
falseBytes = []byte("false") |
||||
interfaceBytes = []byte("(interface {})") |
||||
commaNewlineBytes = []byte(",\n") |
||||
newlineBytes = []byte("\n") |
||||
openBraceBytes = []byte("{") |
||||
openBraceNewlineBytes = []byte("{\n") |
||||
closeBraceBytes = []byte("}") |
||||
asteriskBytes = []byte("*") |
||||
colonBytes = []byte(":") |
||||
colonSpaceBytes = []byte(": ") |
||||
openParenBytes = []byte("(") |
||||
closeParenBytes = []byte(")") |
||||
spaceBytes = []byte(" ") |
||||
pointerChainBytes = []byte("->") |
||||
nilAngleBytes = []byte("<nil>") |
||||
maxNewlineBytes = []byte("<max depth reached>\n") |
||||
maxShortBytes = []byte("<max>") |
||||
circularBytes = []byte("<already shown>") |
||||
circularShortBytes = []byte("<shown>") |
||||
invalidAngleBytes = []byte("<invalid>") |
||||
openBracketBytes = []byte("[") |
||||
closeBracketBytes = []byte("]") |
||||
percentBytes = []byte("%") |
||||
precisionBytes = []byte(".") |
||||
openAngleBytes = []byte("<") |
||||
closeAngleBytes = []byte(">") |
||||
openMapBytes = []byte("map[") |
||||
closeMapBytes = []byte("]") |
||||
lenEqualsBytes = []byte("len=") |
||||
capEqualsBytes = []byte("cap=") |
||||
) |
||||
|
||||
// hexDigits is used to map a decimal value to a hex digit.
|
||||
var hexDigits = "0123456789abcdef" |
||||
|
||||
// catchPanic handles any panics that might occur during the handleMethods
|
||||
// calls.
|
||||
func catchPanic(w io.Writer, v reflect.Value) { |
||||
if err := recover(); err != nil { |
||||
w.Write(panicBytes) |
||||
fmt.Fprintf(w, "%v", err) |
||||
w.Write(closeParenBytes) |
||||
} |
||||
} |
||||
|
||||
// handleMethods attempts to call the Error and String methods on the underlying
|
||||
// type the passed reflect.Value represents and outputes the result to Writer w.
|
||||
//
|
||||
// It handles panics in any called methods by catching and displaying the error
|
||||
// as the formatted value.
|
||||
func handleMethods(cs *ConfigState, w io.Writer, v reflect.Value) (handled bool) { |
||||
// We need an interface to check if the type implements the error or
|
||||
// Stringer interface. However, the reflect package won't give us an
|
||||
// interface on certain things like unexported struct fields in order
|
||||
// to enforce visibility rules. We use unsafe, when it's available,
|
||||
// to bypass these restrictions since this package does not mutate the
|
||||
// values.
|
||||
if !v.CanInterface() { |
||||
if UnsafeDisabled { |
||||
return false |
||||
} |
||||
|
||||
v = unsafeReflectValue(v) |
||||
} |
||||
|
||||
// Choose whether or not to do error and Stringer interface lookups against
|
||||
// the base type or a pointer to the base type depending on settings.
|
||||
// Technically calling one of these methods with a pointer receiver can
|
||||
// mutate the value, however, types which choose to satisify an error or
|
||||
// Stringer interface with a pointer receiver should not be mutating their
|
||||
// state inside these interface methods.
|
||||
if !cs.DisablePointerMethods && !UnsafeDisabled && !v.CanAddr() { |
||||
v = unsafeReflectValue(v) |
||||
} |
||||
if v.CanAddr() { |
||||
v = v.Addr() |
||||
} |
||||
|
||||
// Is it an error or Stringer?
|
||||
switch iface := v.Interface().(type) { |
||||
case error: |
||||
defer catchPanic(w, v) |
||||
if cs.ContinueOnMethod { |
||||
w.Write(openParenBytes) |
||||
w.Write([]byte(iface.Error())) |
||||
w.Write(closeParenBytes) |
||||
w.Write(spaceBytes) |
||||
return false |
||||
} |
||||
|
||||
w.Write([]byte(iface.Error())) |
||||
return true |
||||
|
||||
case fmt.Stringer: |
||||
defer catchPanic(w, v) |
||||
if cs.ContinueOnMethod { |
||||
w.Write(openParenBytes) |
||||
w.Write([]byte(iface.String())) |
||||
w.Write(closeParenBytes) |
||||
w.Write(spaceBytes) |
||||
return false |
||||
} |
||||
w.Write([]byte(iface.String())) |
||||
return true |
||||
} |
||||
return false |
||||
} |
||||
|
||||
// printBool outputs a boolean value as true or false to Writer w.
|
||||
func printBool(w io.Writer, val bool) { |
||||
if val { |
||||
w.Write(trueBytes) |
||||
} else { |
||||
w.Write(falseBytes) |
||||
} |
||||
} |
||||
|
||||
// printInt outputs a signed integer value to Writer w.
|
||||
func printInt(w io.Writer, val int64, base int) { |
||||
w.Write([]byte(strconv.FormatInt(val, base))) |
||||
} |
||||
|
||||
// printUint outputs an unsigned integer value to Writer w.
|
||||
func printUint(w io.Writer, val uint64, base int) { |
||||
w.Write([]byte(strconv.FormatUint(val, base))) |
||||
} |
||||
|
||||
// printFloat outputs a floating point value using the specified precision,
|
||||
// which is expected to be 32 or 64bit, to Writer w.
|
||||
func printFloat(w io.Writer, val float64, precision int) { |
||||
w.Write([]byte(strconv.FormatFloat(val, 'g', -1, precision))) |
||||
} |
||||
|
||||
// printComplex outputs a complex value using the specified float precision
|
||||
// for the real and imaginary parts to Writer w.
|
||||
func printComplex(w io.Writer, c complex128, floatPrecision int) { |
||||
r := real(c) |
||||
w.Write(openParenBytes) |
||||
w.Write([]byte(strconv.FormatFloat(r, 'g', -1, floatPrecision))) |
||||
i := imag(c) |
||||
if i >= 0 { |
||||
w.Write(plusBytes) |
||||
} |
||||
w.Write([]byte(strconv.FormatFloat(i, 'g', -1, floatPrecision))) |
||||
w.Write(iBytes) |
||||
w.Write(closeParenBytes) |
||||
} |
||||
|
||||
// printHexPtr outputs a uintptr formatted as hexadecimal with a leading '0x'
|
||||
// prefix to Writer w.
|
||||
func printHexPtr(w io.Writer, p uintptr) { |
||||
// Null pointer.
|
||||
num := uint64(p) |
||||
if num == 0 { |
||||
w.Write(nilAngleBytes) |
||||
return |
||||
} |
||||
|
||||
// Max uint64 is 16 bytes in hex + 2 bytes for '0x' prefix
|
||||
buf := make([]byte, 18) |
||||
|
||||
// It's simpler to construct the hex string right to left.
|
||||
base := uint64(16) |
||||
i := len(buf) - 1 |
||||
for num >= base { |
||||
buf[i] = hexDigits[num%base] |
||||
num /= base |
||||
i-- |
||||
} |
||||
buf[i] = hexDigits[num] |
||||
|
||||
// Add '0x' prefix.
|
||||
i-- |
||||
buf[i] = 'x' |
||||
i-- |
||||
buf[i] = '0' |
||||
|
||||
// Strip unused leading bytes.
|
||||
buf = buf[i:] |
||||
w.Write(buf) |
||||
} |
||||
|
||||
// valuesSorter implements sort.Interface to allow a slice of reflect.Value
|
||||
// elements to be sorted.
|
||||
type valuesSorter struct { |
||||
values []reflect.Value |
||||
strings []string // either nil or same len and values
|
||||
cs *ConfigState |
||||
} |
||||
|
||||
// newValuesSorter initializes a valuesSorter instance, which holds a set of
|
||||
// surrogate keys on which the data should be sorted. It uses flags in
|
||||
// ConfigState to decide if and how to populate those surrogate keys.
|
||||
func newValuesSorter(values []reflect.Value, cs *ConfigState) sort.Interface { |
||||
vs := &valuesSorter{values: values, cs: cs} |
||||
if canSortSimply(vs.values[0].Kind()) { |
||||
return vs |
||||
} |
||||
if !cs.DisableMethods { |
||||
vs.strings = make([]string, len(values)) |
||||
for i := range vs.values { |
||||
b := bytes.Buffer{} |
||||
if !handleMethods(cs, &b, vs.values[i]) { |
||||
vs.strings = nil |
||||
break |
||||
} |
||||
vs.strings[i] = b.String() |
||||
} |
||||
} |
||||
if vs.strings == nil && cs.SpewKeys { |
||||
vs.strings = make([]string, len(values)) |
||||
for i := range vs.values { |
||||
vs.strings[i] = Sprintf("%#v", vs.values[i].Interface()) |
||||
} |
||||
} |
||||
return vs |
||||
} |
||||
|
||||
// canSortSimply tests whether a reflect.Kind is a primitive that can be sorted
|
||||
// directly, or whether it should be considered for sorting by surrogate keys
|
||||
// (if the ConfigState allows it).
|
||||
func canSortSimply(kind reflect.Kind) bool { |
||||
// This switch parallels valueSortLess, except for the default case.
|
||||
switch kind { |
||||
case reflect.Bool: |
||||
return true |
||||
case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int: |
||||
return true |
||||
case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint: |
||||
return true |
||||
case reflect.Float32, reflect.Float64: |
||||
return true |
||||
case reflect.String: |
||||
return true |
||||
case reflect.Uintptr: |
||||
return true |
||||
case reflect.Array: |
||||
return true |
||||
} |
||||
return false |
||||
} |
||||
|
||||
// Len returns the number of values in the slice. It is part of the
|
||||
// sort.Interface implementation.
|
||||
func (s *valuesSorter) Len() int { |
||||
return len(s.values) |
||||
} |
||||
|
||||
// Swap swaps the values at the passed indices. It is part of the
|
||||
// sort.Interface implementation.
|
||||
func (s *valuesSorter) Swap(i, j int) { |
||||
s.values[i], s.values[j] = s.values[j], s.values[i] |
||||
if s.strings != nil { |
||||
s.strings[i], s.strings[j] = s.strings[j], s.strings[i] |
||||
} |
||||
} |
||||
|
||||
// valueSortLess returns whether the first value should sort before the second
|
||||
// value. It is used by valueSorter.Less as part of the sort.Interface
|
||||
// implementation.
|
||||
func valueSortLess(a, b reflect.Value) bool { |
||||
switch a.Kind() { |
||||
case reflect.Bool: |
||||
return !a.Bool() && b.Bool() |
||||
case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int: |
||||
return a.Int() < b.Int() |
||||
case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint: |
||||
return a.Uint() < b.Uint() |
||||
case reflect.Float32, reflect.Float64: |
||||
return a.Float() < b.Float() |
||||
case reflect.String: |
||||
return a.String() < b.String() |
||||
case reflect.Uintptr: |
||||
return a.Uint() < b.Uint() |
||||
case reflect.Array: |
||||
// Compare the contents of both arrays.
|
||||
l := a.Len() |
||||
for i := 0; i < l; i++ { |
||||
av := a.Index(i) |
||||
bv := b.Index(i) |
||||
if av.Interface() == bv.Interface() { |
||||
continue |
||||
} |
||||
return valueSortLess(av, bv) |
||||
} |
||||
} |
||||
return a.String() < b.String() |
||||
} |
||||
|
||||
// Less returns whether the value at index i should sort before the
|
||||
// value at index j. It is part of the sort.Interface implementation.
|
||||
func (s *valuesSorter) Less(i, j int) bool { |
||||
if s.strings == nil { |
||||
return valueSortLess(s.values[i], s.values[j]) |
||||
} |
||||
return s.strings[i] < s.strings[j] |
||||
} |
||||
|
||||
// sortValues is a sort function that handles both native types and any type that
|
||||
// can be converted to error or Stringer. Other inputs are sorted according to
|
||||
// their Value.String() value to ensure display stability.
|
||||
func sortValues(values []reflect.Value, cs *ConfigState) { |
||||
if len(values) == 0 { |
||||
return |
||||
} |
||||
sort.Sort(newValuesSorter(values, cs)) |
||||
} |
||||
@ -0,0 +1,306 @@ |
||||
/* |
||||
* Copyright (c) 2013-2016 Dave Collins <dave@davec.name> |
||||
* |
||||
* Permission to use, copy, modify, and distribute this software for any |
||||
* purpose with or without fee is hereby granted, provided that the above |
||||
* copyright notice and this permission notice appear in all copies. |
||||
* |
||||
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES |
||||
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF |
||||
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR |
||||
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES |
||||
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN |
||||
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF |
||||
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. |
||||
*/ |
||||
|
||||
package spew |
||||
|
||||
import ( |
||||
"bytes" |
||||
"fmt" |
||||
"io" |
||||
"os" |
||||
) |
||||
|
||||
// ConfigState houses the configuration options used by spew to format and
|
||||
// display values. There is a global instance, Config, that is used to control
|
||||
// all top-level Formatter and Dump functionality. Each ConfigState instance
|
||||
// provides methods equivalent to the top-level functions.
|
||||
//
|
||||
// The zero value for ConfigState provides no indentation. You would typically
|
||||
// want to set it to a space or a tab.
|
||||
//
|
||||
// Alternatively, you can use NewDefaultConfig to get a ConfigState instance
|
||||
// with default settings. See the documentation of NewDefaultConfig for default
|
||||
// values.
|
||||
type ConfigState struct { |
||||
// Indent specifies the string to use for each indentation level. The
|
||||
// global config instance that all top-level functions use set this to a
|
||||
// single space by default. If you would like more indentation, you might
|
||||
// set this to a tab with "\t" or perhaps two spaces with " ".
|
||||
Indent string |
||||
|
||||
// MaxDepth controls the maximum number of levels to descend into nested
|
||||
// data structures. The default, 0, means there is no limit.
|
||||
//
|
||||
// NOTE: Circular data structures are properly detected, so it is not
|
||||
// necessary to set this value unless you specifically want to limit deeply
|
||||
// nested data structures.
|
||||
MaxDepth int |
||||
|
||||
// DisableMethods specifies whether or not error and Stringer interfaces are
|
||||
// invoked for types that implement them.
|
||||
DisableMethods bool |
||||
|
||||
// DisablePointerMethods specifies whether or not to check for and invoke
|
||||
// error and Stringer interfaces on types which only accept a pointer
|
||||
// receiver when the current type is not a pointer.
|
||||
//
|
||||
// NOTE: This might be an unsafe action since calling one of these methods
|
||||
// with a pointer receiver could technically mutate the value, however,
|
||||
// in practice, types which choose to satisify an error or Stringer
|
||||
// interface with a pointer receiver should not be mutating their state
|
||||
// inside these interface methods. As a result, this option relies on
|
||||
// access to the unsafe package, so it will not have any effect when
|
||||
// running in environments without access to the unsafe package such as
|
||||
// Google App Engine or with the "safe" build tag specified.
|
||||
DisablePointerMethods bool |
||||
|
||||
// DisablePointerAddresses specifies whether to disable the printing of
|
||||
// pointer addresses. This is useful when diffing data structures in tests.
|
||||
DisablePointerAddresses bool |
||||
|
||||
// DisableCapacities specifies whether to disable the printing of capacities
|
||||
// for arrays, slices, maps and channels. This is useful when diffing
|
||||
// data structures in tests.
|
||||
DisableCapacities bool |
||||
|
||||
// ContinueOnMethod specifies whether or not recursion should continue once
|
||||
// a custom error or Stringer interface is invoked. The default, false,
|
||||
// means it will print the results of invoking the custom error or Stringer
|
||||
// interface and return immediately instead of continuing to recurse into
|
||||
// the internals of the data type.
|
||||
//
|
||||
// NOTE: This flag does not have any effect if method invocation is disabled
|
||||
// via the DisableMethods or DisablePointerMethods options.
|
||||
ContinueOnMethod bool |
||||
|
||||
// SortKeys specifies map keys should be sorted before being printed. Use
|
||||
// this to have a more deterministic, diffable output. Note that only
|
||||
// native types (bool, int, uint, floats, uintptr and string) and types
|
||||
// that support the error or Stringer interfaces (if methods are
|
||||
// enabled) are supported, with other types sorted according to the
|
||||
// reflect.Value.String() output which guarantees display stability.
|
||||
SortKeys bool |
||||
|
||||
// SpewKeys specifies that, as a last resort attempt, map keys should
|
||||
// be spewed to strings and sorted by those strings. This is only
|
||||
// considered if SortKeys is true.
|
||||
SpewKeys bool |
||||
} |
||||
|
||||
// Config is the active configuration of the top-level functions.
|
||||
// The configuration can be changed by modifying the contents of spew.Config.
|
||||
var Config = ConfigState{Indent: " "} |
||||
|
||||
// Errorf is a wrapper for fmt.Errorf that treats each argument as if it were
|
||||
// passed with a Formatter interface returned by c.NewFormatter. It returns
|
||||
// the formatted string as a value that satisfies error. See NewFormatter
|
||||
// for formatting details.
|
||||
//
|
||||
// This function is shorthand for the following syntax:
|
||||
//
|
||||
// fmt.Errorf(format, c.NewFormatter(a), c.NewFormatter(b))
|
||||
func (c *ConfigState) Errorf(format string, a ...interface{}) (err error) { |
||||
return fmt.Errorf(format, c.convertArgs(a)...) |
||||
} |
||||
|
||||
// Fprint is a wrapper for fmt.Fprint that treats each argument as if it were
|
||||
// passed with a Formatter interface returned by c.NewFormatter. It returns
|
||||
// the number of bytes written and any write error encountered. See
|
||||
// NewFormatter for formatting details.
|
||||
//
|
||||
// This function is shorthand for the following syntax:
|
||||
//
|
||||
// fmt.Fprint(w, c.NewFormatter(a), c.NewFormatter(b))
|
||||
func (c *ConfigState) Fprint(w io.Writer, a ...interface{}) (n int, err error) { |
||||
return fmt.Fprint(w, c.convertArgs(a)...) |
||||
} |
||||
|
||||
// Fprintf is a wrapper for fmt.Fprintf that treats each argument as if it were
|
||||
// passed with a Formatter interface returned by c.NewFormatter. It returns
|
||||
// the number of bytes written and any write error encountered. See
|
||||
// NewFormatter for formatting details.
|
||||
//
|
||||
// This function is shorthand for the following syntax:
|
||||
//
|
||||
// fmt.Fprintf(w, format, c.NewFormatter(a), c.NewFormatter(b))
|
||||
func (c *ConfigState) Fprintf(w io.Writer, format string, a ...interface{}) (n int, err error) { |
||||
return fmt.Fprintf(w, format, c.convertArgs(a)...) |
||||
} |
||||
|
||||
// Fprintln is a wrapper for fmt.Fprintln that treats each argument as if it
|
||||
// passed with a Formatter interface returned by c.NewFormatter. See
|
||||
// NewFormatter for formatting details.
|
||||
//
|
||||
// This function is shorthand for the following syntax:
|
||||
//
|
||||
// fmt.Fprintln(w, c.NewFormatter(a), c.NewFormatter(b))
|
||||
func (c *ConfigState) Fprintln(w io.Writer, a ...interface{}) (n int, err error) { |
||||
return fmt.Fprintln(w, c.convertArgs(a)...) |
||||
} |
||||
|
||||
// Print is a wrapper for fmt.Print that treats each argument as if it were
|
||||
// passed with a Formatter interface returned by c.NewFormatter. It returns
|
||||
// the number of bytes written and any write error encountered. See
|
||||
// NewFormatter for formatting details.
|
||||
//
|
||||
// This function is shorthand for the following syntax:
|
||||
//
|
||||
// fmt.Print(c.NewFormatter(a), c.NewFormatter(b))
|
||||
func (c *ConfigState) Print(a ...interface{}) (n int, err error) { |
||||
return fmt.Print(c.convertArgs(a)...) |
||||
} |
||||
|
||||
// Printf is a wrapper for fmt.Printf that treats each argument as if it were
|
||||
// passed with a Formatter interface returned by c.NewFormatter. It returns
|
||||
// the number of bytes written and any write error encountered. See
|
||||
// NewFormatter for formatting details.
|
||||
//
|
||||
// This function is shorthand for the following syntax:
|
||||
//
|
||||
// fmt.Printf(format, c.NewFormatter(a), c.NewFormatter(b))
|
||||
func (c *ConfigState) Printf(format string, a ...interface{}) (n int, err error) { |
||||
return fmt.Printf(format, c.convertArgs(a)...) |
||||
} |
||||
|
||||
// Println is a wrapper for fmt.Println that treats each argument as if it were
|
||||
// passed with a Formatter interface returned by c.NewFormatter. It returns
|
||||
// the number of bytes written and any write error encountered. See
|
||||
// NewFormatter for formatting details.
|
||||
//
|
||||
// This function is shorthand for the following syntax:
|
||||
//
|
||||
// fmt.Println(c.NewFormatter(a), c.NewFormatter(b))
|
||||
func (c *ConfigState) Println(a ...interface{}) (n int, err error) { |
||||
return fmt.Println(c.convertArgs(a)...) |
||||
} |
||||
|
||||
// Sprint is a wrapper for fmt.Sprint that treats each argument as if it were
|
||||
// passed with a Formatter interface returned by c.NewFormatter. It returns
|
||||
// the resulting string. See NewFormatter for formatting details.
|
||||
//
|
||||
// This function is shorthand for the following syntax:
|
||||
//
|
||||
// fmt.Sprint(c.NewFormatter(a), c.NewFormatter(b))
|
||||
func (c *ConfigState) Sprint(a ...interface{}) string { |
||||
return fmt.Sprint(c.convertArgs(a)...) |
||||
} |
||||
|
||||
// Sprintf is a wrapper for fmt.Sprintf that treats each argument as if it were
|
||||
// passed with a Formatter interface returned by c.NewFormatter. It returns
|
||||
// the resulting string. See NewFormatter for formatting details.
|
||||
//
|
||||
// This function is shorthand for the following syntax:
|
||||
//
|
||||
// fmt.Sprintf(format, c.NewFormatter(a), c.NewFormatter(b))
|
||||
func (c *ConfigState) Sprintf(format string, a ...interface{}) string { |
||||
return fmt.Sprintf(format, c.convertArgs(a)...) |
||||
} |
||||
|
||||
// Sprintln is a wrapper for fmt.Sprintln that treats each argument as if it
|
||||
// were passed with a Formatter interface returned by c.NewFormatter. It
|
||||
// returns the resulting string. See NewFormatter for formatting details.
|
||||
//
|
||||
// This function is shorthand for the following syntax:
|
||||
//
|
||||
// fmt.Sprintln(c.NewFormatter(a), c.NewFormatter(b))
|
||||
func (c *ConfigState) Sprintln(a ...interface{}) string { |
||||
return fmt.Sprintln(c.convertArgs(a)...) |
||||
} |
||||
|
||||
/* |
||||
NewFormatter returns a custom formatter that satisfies the fmt.Formatter |
||||
interface. As a result, it integrates cleanly with standard fmt package |
||||
printing functions. The formatter is useful for inline printing of smaller data |
||||
types similar to the standard %v format specifier. |
||||
|
||||
The custom formatter only responds to the %v (most compact), %+v (adds pointer |
||||
addresses), %#v (adds types), and %#+v (adds types and pointer addresses) verb |
||||
combinations. Any other verbs such as %x and %q will be sent to the the |
||||
standard fmt package for formatting. In addition, the custom formatter ignores |
||||
the width and precision arguments (however they will still work on the format |
||||
specifiers not handled by the custom formatter). |
||||
|
||||
Typically this function shouldn't be called directly. It is much easier to make |
||||
use of the custom formatter by calling one of the convenience functions such as |
||||
c.Printf, c.Println, or c.Printf. |
||||
*/ |
||||
func (c *ConfigState) NewFormatter(v interface{}) fmt.Formatter { |
||||
return newFormatter(c, v) |
||||
} |
||||
|
||||
// Fdump formats and displays the passed arguments to io.Writer w. It formats
|
||||
// exactly the same as Dump.
|
||||
func (c *ConfigState) Fdump(w io.Writer, a ...interface{}) { |
||||
fdump(c, w, a...) |
||||
} |
||||
|
||||
/* |
||||
Dump displays the passed parameters to standard out with newlines, customizable |
||||
indentation, and additional debug information such as complete types and all |
||||
pointer addresses used to indirect to the final value. It provides the |
||||
following features over the built-in printing facilities provided by the fmt |
||||
package: |
||||
|
||||
* Pointers are dereferenced and followed |
||||
* Circular data structures are detected and handled properly |
||||
* Custom Stringer/error interfaces are optionally invoked, including |
||||
on unexported types |
||||
* Custom types which only implement the Stringer/error interfaces via |
||||
a pointer receiver are optionally invoked when passing non-pointer |
||||
variables |
||||
* Byte arrays and slices are dumped like the hexdump -C command which |
||||
includes offsets, byte values in hex, and ASCII output |
||||
|
||||
The configuration options are controlled by modifying the public members |
||||
of c. See ConfigState for options documentation. |
||||
|
||||
See Fdump if you would prefer dumping to an arbitrary io.Writer or Sdump to |
||||
get the formatted result as a string. |
||||
*/ |
||||
func (c *ConfigState) Dump(a ...interface{}) { |
||||
fdump(c, os.Stdout, a...) |
||||
} |
||||
|
||||
// Sdump returns a string with the passed arguments formatted exactly the same
|
||||
// as Dump.
|
||||
func (c *ConfigState) Sdump(a ...interface{}) string { |
||||
var buf bytes.Buffer |
||||
fdump(c, &buf, a...) |
||||
return buf.String() |
||||
} |
||||
|
||||
// convertArgs accepts a slice of arguments and returns a slice of the same
|
||||
// length with each argument converted to a spew Formatter interface using
|
||||
// the ConfigState associated with s.
|
||||
func (c *ConfigState) convertArgs(args []interface{}) (formatters []interface{}) { |
||||
formatters = make([]interface{}, len(args)) |
||||
for index, arg := range args { |
||||
formatters[index] = newFormatter(c, arg) |
||||
} |
||||
return formatters |
||||
} |
||||
|
||||
// NewDefaultConfig returns a ConfigState with the following default settings.
|
||||
//
|
||||
// Indent: " "
|
||||
// MaxDepth: 0
|
||||
// DisableMethods: false
|
||||
// DisablePointerMethods: false
|
||||
// ContinueOnMethod: false
|
||||
// SortKeys: false
|
||||
func NewDefaultConfig() *ConfigState { |
||||
return &ConfigState{Indent: " "} |
||||
} |
||||
@ -0,0 +1,211 @@ |
||||
/* |
||||
* Copyright (c) 2013-2016 Dave Collins <dave@davec.name> |
||||
* |
||||
* Permission to use, copy, modify, and distribute this software for any |
||||
* purpose with or without fee is hereby granted, provided that the above |
||||
* copyright notice and this permission notice appear in all copies. |
||||
* |
||||
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES |
||||
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF |
||||
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR |
||||
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES |
||||
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN |
||||
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF |
||||
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. |
||||
*/ |
||||
|
||||
/* |
||||
Package spew implements a deep pretty printer for Go data structures to aid in |
||||
debugging. |
||||
|
||||
A quick overview of the additional features spew provides over the built-in |
||||
printing facilities for Go data types are as follows: |
||||
|
||||
* Pointers are dereferenced and followed |
||||
* Circular data structures are detected and handled properly |
||||
* Custom Stringer/error interfaces are optionally invoked, including |
||||
on unexported types |
||||
* Custom types which only implement the Stringer/error interfaces via |
||||
a pointer receiver are optionally invoked when passing non-pointer |
||||
variables |
||||
* Byte arrays and slices are dumped like the hexdump -C command which |
||||
includes offsets, byte values in hex, and ASCII output (only when using |
||||
Dump style) |
||||
|
||||
There are two different approaches spew allows for dumping Go data structures: |
||||
|
||||
* Dump style which prints with newlines, customizable indentation, |
||||
and additional debug information such as types and all pointer addresses |
||||
used to indirect to the final value |
||||
* A custom Formatter interface that integrates cleanly with the standard fmt |
||||
package and replaces %v, %+v, %#v, and %#+v to provide inline printing |
||||
similar to the default %v while providing the additional functionality |
||||
outlined above and passing unsupported format verbs such as %x and %q |
||||
along to fmt |
||||
|
||||
Quick Start |
||||
|
||||
This section demonstrates how to quickly get started with spew. See the |
||||
sections below for further details on formatting and configuration options. |
||||
|
||||
To dump a variable with full newlines, indentation, type, and pointer |
||||
information use Dump, Fdump, or Sdump: |
||||
spew.Dump(myVar1, myVar2, ...) |
||||
spew.Fdump(someWriter, myVar1, myVar2, ...) |
||||
str := spew.Sdump(myVar1, myVar2, ...) |
||||
|
||||
Alternatively, if you would prefer to use format strings with a compacted inline |
||||
printing style, use the convenience wrappers Printf, Fprintf, etc with |
||||
%v (most compact), %+v (adds pointer addresses), %#v (adds types), or |
||||
%#+v (adds types and pointer addresses): |
||||
spew.Printf("myVar1: %v -- myVar2: %+v", myVar1, myVar2) |
||||
spew.Printf("myVar3: %#v -- myVar4: %#+v", myVar3, myVar4) |
||||
spew.Fprintf(someWriter, "myVar1: %v -- myVar2: %+v", myVar1, myVar2) |
||||
spew.Fprintf(someWriter, "myVar3: %#v -- myVar4: %#+v", myVar3, myVar4) |
||||
|
||||
Configuration Options |
||||
|
||||
Configuration of spew is handled by fields in the ConfigState type. For |
||||
convenience, all of the top-level functions use a global state available |
||||
via the spew.Config global. |
||||
|
||||
It is also possible to create a ConfigState instance that provides methods |
||||
equivalent to the top-level functions. This allows concurrent configuration |
||||
options. See the ConfigState documentation for more details. |
||||
|
||||
The following configuration options are available: |
||||
* Indent |
||||
String to use for each indentation level for Dump functions. |
||||
It is a single space by default. A popular alternative is "\t". |
||||
|
||||
* MaxDepth |
||||
Maximum number of levels to descend into nested data structures. |
||||
There is no limit by default. |
||||
|
||||
* DisableMethods |
||||
Disables invocation of error and Stringer interface methods. |
||||
Method invocation is enabled by default. |
||||
|
||||
* DisablePointerMethods |
||||
Disables invocation of error and Stringer interface methods on types |
||||
which only accept pointer receivers from non-pointer variables. |
||||
Pointer method invocation is enabled by default. |
||||
|
||||
* DisablePointerAddresses |
||||
DisablePointerAddresses specifies whether to disable the printing of |
||||
pointer addresses. This is useful when diffing data structures in tests. |
||||
|
||||
* DisableCapacities |
||||
DisableCapacities specifies whether to disable the printing of |
||||
capacities for arrays, slices, maps and channels. This is useful when |
||||
diffing data structures in tests. |
||||
|
||||
* ContinueOnMethod |
||||
Enables recursion into types after invoking error and Stringer interface |
||||
methods. Recursion after method invocation is disabled by default. |
||||
|
||||
* SortKeys |
||||
Specifies map keys should be sorted before being printed. Use |
||||
this to have a more deterministic, diffable output. Note that |
||||
only native types (bool, int, uint, floats, uintptr and string) |
||||
and types which implement error or Stringer interfaces are |
||||
supported with other types sorted according to the |
||||
reflect.Value.String() output which guarantees display |
||||
stability. Natural map order is used by default. |
||||
|
||||
* SpewKeys |
||||
Specifies that, as a last resort attempt, map keys should be |
||||
spewed to strings and sorted by those strings. This is only |
||||
considered if SortKeys is true. |
||||
|
||||
Dump Usage |
||||
|
||||
Simply call spew.Dump with a list of variables you want to dump: |
||||
|
||||
spew.Dump(myVar1, myVar2, ...) |
||||
|
||||
You may also call spew.Fdump if you would prefer to output to an arbitrary |
||||
io.Writer. For example, to dump to standard error: |
||||
|
||||
spew.Fdump(os.Stderr, myVar1, myVar2, ...) |
||||
|
||||
A third option is to call spew.Sdump to get the formatted output as a string: |
||||
|
||||
str := spew.Sdump(myVar1, myVar2, ...) |
||||
|
||||
Sample Dump Output |
||||
|
||||
See the Dump example for details on the setup of the types and variables being |
||||
shown here. |
||||
|
||||
(main.Foo) { |
||||
unexportedField: (*main.Bar)(0xf84002e210)({ |
||||
flag: (main.Flag) flagTwo, |
||||
data: (uintptr) <nil> |
||||
}), |
||||
ExportedField: (map[interface {}]interface {}) (len=1) { |
||||
(string) (len=3) "one": (bool) true |
||||
} |
||||
} |
||||
|
||||
Byte (and uint8) arrays and slices are displayed uniquely like the hexdump -C |
||||
command as shown. |
||||
([]uint8) (len=32 cap=32) { |
||||
00000000 11 12 13 14 15 16 17 18 19 1a 1b 1c 1d 1e 1f 20 |............... | |
||||
00000010 21 22 23 24 25 26 27 28 29 2a 2b 2c 2d 2e 2f 30 |!"#$%&'()*+,-./0| |
||||
00000020 31 32 |12| |
||||
} |
||||
|
||||
Custom Formatter |
||||
|
||||
Spew provides a custom formatter that implements the fmt.Formatter interface |
||||
so that it integrates cleanly with standard fmt package printing functions. The |
||||
formatter is useful for inline printing of smaller data types similar to the |
||||
standard %v format specifier. |
||||
|
||||
The custom formatter only responds to the %v (most compact), %+v (adds pointer |
||||
addresses), %#v (adds types), or %#+v (adds types and pointer addresses) verb |
||||
combinations. Any other verbs such as %x and %q will be sent to the the |
||||
standard fmt package for formatting. In addition, the custom formatter ignores |
||||
the width and precision arguments (however they will still work on the format |
||||
specifiers not handled by the custom formatter). |
||||
|
||||
Custom Formatter Usage |
||||
|
||||
The simplest way to make use of the spew custom formatter is to call one of the |
||||
convenience functions such as spew.Printf, spew.Println, or spew.Printf. The |
||||
functions have syntax you are most likely already familiar with: |
||||
|
||||
spew.Printf("myVar1: %v -- myVar2: %+v", myVar1, myVar2) |
||||
spew.Printf("myVar3: %#v -- myVar4: %#+v", myVar3, myVar4) |
||||
spew.Println(myVar, myVar2) |
||||
spew.Fprintf(os.Stderr, "myVar1: %v -- myVar2: %+v", myVar1, myVar2) |
||||
spew.Fprintf(os.Stderr, "myVar3: %#v -- myVar4: %#+v", myVar3, myVar4) |
||||
|
||||
See the Index for the full list convenience functions. |
||||
|
||||
Sample Formatter Output |
||||
|
||||
Double pointer to a uint8: |
||||
%v: <**>5 |
||||
%+v: <**>(0xf8400420d0->0xf8400420c8)5 |
||||
%#v: (**uint8)5 |
||||
%#+v: (**uint8)(0xf8400420d0->0xf8400420c8)5 |
||||
|
||||
Pointer to circular struct with a uint8 field and a pointer to itself: |
||||
%v: <*>{1 <*><shown>} |
||||
%+v: <*>(0xf84003e260){ui8:1 c:<*>(0xf84003e260)<shown>} |
||||
%#v: (*main.circular){ui8:(uint8)1 c:(*main.circular)<shown>} |
||||
%#+v: (*main.circular)(0xf84003e260){ui8:(uint8)1 c:(*main.circular)(0xf84003e260)<shown>} |
||||
|
||||
See the Printf example for details on the setup of variables being shown |
||||
here. |
||||
|
||||
Errors |
||||
|
||||
Since it is possible for custom Stringer/error interfaces to panic, spew |
||||
detects them and handles them internally by printing the panic information |
||||
inline with the output. Since spew is intended to provide deep pretty printing |
||||
capabilities on structures, it intentionally does not return any errors. |
||||
*/ |
||||
package spew |
||||
@ -0,0 +1,509 @@ |
||||
/* |
||||
* Copyright (c) 2013-2016 Dave Collins <dave@davec.name> |
||||
* |
||||
* Permission to use, copy, modify, and distribute this software for any |
||||
* purpose with or without fee is hereby granted, provided that the above |
||||
* copyright notice and this permission notice appear in all copies. |
||||
* |
||||
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES |
||||
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF |
||||
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR |
||||
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES |
||||
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN |
||||
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF |
||||
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. |
||||
*/ |
||||
|
||||
package spew |
||||
|
||||
import ( |
||||
"bytes" |
||||
"encoding/hex" |
||||
"fmt" |
||||
"io" |
||||
"os" |
||||
"reflect" |
||||
"regexp" |
||||
"strconv" |
||||
"strings" |
||||
) |
||||
|
||||
var ( |
||||
// uint8Type is a reflect.Type representing a uint8. It is used to
|
||||
// convert cgo types to uint8 slices for hexdumping.
|
||||
uint8Type = reflect.TypeOf(uint8(0)) |
||||
|
||||
// cCharRE is a regular expression that matches a cgo char.
|
||||
// It is used to detect character arrays to hexdump them.
|
||||
cCharRE = regexp.MustCompile(`^.*\._Ctype_char$`) |
||||
|
||||
// cUnsignedCharRE is a regular expression that matches a cgo unsigned
|
||||
// char. It is used to detect unsigned character arrays to hexdump
|
||||
// them.
|
||||
cUnsignedCharRE = regexp.MustCompile(`^.*\._Ctype_unsignedchar$`) |
||||
|
||||
// cUint8tCharRE is a regular expression that matches a cgo uint8_t.
|
||||
// It is used to detect uint8_t arrays to hexdump them.
|
||||
cUint8tCharRE = regexp.MustCompile(`^.*\._Ctype_uint8_t$`) |
||||
) |
||||
|
||||
// dumpState contains information about the state of a dump operation.
|
||||
type dumpState struct { |
||||
w io.Writer |
||||
depth int |
||||
pointers map[uintptr]int |
||||
ignoreNextType bool |
||||
ignoreNextIndent bool |
||||
cs *ConfigState |
||||
} |
||||
|
||||
// indent performs indentation according to the depth level and cs.Indent
|
||||
// option.
|
||||
func (d *dumpState) indent() { |
||||
if d.ignoreNextIndent { |
||||
d.ignoreNextIndent = false |
||||
return |
||||
} |
||||
d.w.Write(bytes.Repeat([]byte(d.cs.Indent), d.depth)) |
||||
} |
||||
|
||||
// unpackValue returns values inside of non-nil interfaces when possible.
|
||||
// This is useful for data types like structs, arrays, slices, and maps which
|
||||
// can contain varying types packed inside an interface.
|
||||
func (d *dumpState) unpackValue(v reflect.Value) reflect.Value { |
||||
if v.Kind() == reflect.Interface && !v.IsNil() { |
||||
v = v.Elem() |
||||
} |
||||
return v |
||||
} |
||||
|
||||
// dumpPtr handles formatting of pointers by indirecting them as necessary.
|
||||
func (d *dumpState) dumpPtr(v reflect.Value) { |
||||
// Remove pointers at or below the current depth from map used to detect
|
||||
// circular refs.
|
||||
for k, depth := range d.pointers { |
||||
if depth >= d.depth { |
||||
delete(d.pointers, k) |
||||
} |
||||
} |
||||
|
||||
// Keep list of all dereferenced pointers to show later.
|
||||
pointerChain := make([]uintptr, 0) |
||||
|
||||
// Figure out how many levels of indirection there are by dereferencing
|
||||
// pointers and unpacking interfaces down the chain while detecting circular
|
||||
// references.
|
||||
nilFound := false |
||||
cycleFound := false |
||||
indirects := 0 |
||||
ve := v |
||||
for ve.Kind() == reflect.Ptr { |
||||
if ve.IsNil() { |
||||
nilFound = true |
||||
break |
||||
} |
||||
indirects++ |
||||
addr := ve.Pointer() |
||||
pointerChain = append(pointerChain, addr) |
||||
if pd, ok := d.pointers[addr]; ok && pd < d.depth { |
||||
cycleFound = true |
||||
indirects-- |
||||
break |
||||
} |
||||
d.pointers[addr] = d.depth |
||||
|
||||
ve = ve.Elem() |
||||
if ve.Kind() == reflect.Interface { |
||||
if ve.IsNil() { |
||||
nilFound = true |
||||
break |
||||
} |
||||
ve = ve.Elem() |
||||
} |
||||
} |
||||
|
||||
// Display type information.
|
||||
d.w.Write(openParenBytes) |
||||
d.w.Write(bytes.Repeat(asteriskBytes, indirects)) |
||||
d.w.Write([]byte(ve.Type().String())) |
||||
d.w.Write(closeParenBytes) |
||||
|
||||
// Display pointer information.
|
||||
if !d.cs.DisablePointerAddresses && len(pointerChain) > 0 { |
||||
d.w.Write(openParenBytes) |
||||
for i, addr := range pointerChain { |
||||
if i > 0 { |
||||
d.w.Write(pointerChainBytes) |
||||
} |
||||
printHexPtr(d.w, addr) |
||||
} |
||||
d.w.Write(closeParenBytes) |
||||
} |
||||
|
||||
// Display dereferenced value.
|
||||
d.w.Write(openParenBytes) |
||||
switch { |
||||
case nilFound: |
||||
d.w.Write(nilAngleBytes) |
||||
|
||||
case cycleFound: |
||||
d.w.Write(circularBytes) |
||||
|
||||
default: |
||||
d.ignoreNextType = true |
||||
d.dump(ve) |
||||
} |
||||
d.w.Write(closeParenBytes) |
||||
} |
||||
|
||||
// dumpSlice handles formatting of arrays and slices. Byte (uint8 under
|
||||
// reflection) arrays and slices are dumped in hexdump -C fashion.
|
||||
func (d *dumpState) dumpSlice(v reflect.Value) { |
||||
// Determine whether this type should be hex dumped or not. Also,
|
||||
// for types which should be hexdumped, try to use the underlying data
|
||||
// first, then fall back to trying to convert them to a uint8 slice.
|
||||
var buf []uint8 |
||||
doConvert := false |
||||
doHexDump := false |
||||
numEntries := v.Len() |
||||
if numEntries > 0 { |
||||
vt := v.Index(0).Type() |
||||
vts := vt.String() |
||||
switch { |
||||
// C types that need to be converted.
|
||||
case cCharRE.MatchString(vts): |
||||
fallthrough |
||||
case cUnsignedCharRE.MatchString(vts): |
||||
fallthrough |
||||
case cUint8tCharRE.MatchString(vts): |
||||
doConvert = true |
||||
|
||||
// Try to use existing uint8 slices and fall back to converting
|
||||
// and copying if that fails.
|
||||
case vt.Kind() == reflect.Uint8: |
||||
// We need an addressable interface to convert the type
|
||||
// to a byte slice. However, the reflect package won't
|
||||
// give us an interface on certain things like
|
||||
// unexported struct fields in order to enforce
|
||||
// visibility rules. We use unsafe, when available, to
|
||||
// bypass these restrictions since this package does not
|
||||
// mutate the values.
|
||||
vs := v |
||||
if !vs.CanInterface() || !vs.CanAddr() { |
||||
vs = unsafeReflectValue(vs) |
||||
} |
||||
if !UnsafeDisabled { |
||||
vs = vs.Slice(0, numEntries) |
||||
|
||||
// Use the existing uint8 slice if it can be
|
||||
// type asserted.
|
||||
iface := vs.Interface() |
||||
if slice, ok := iface.([]uint8); ok { |
||||
buf = slice |
||||
doHexDump = true |
||||
break |
||||
} |
||||
} |
||||
|
||||
// The underlying data needs to be converted if it can't
|
||||
// be type asserted to a uint8 slice.
|
||||
doConvert = true |
||||
} |
||||
|
||||
// Copy and convert the underlying type if needed.
|
||||
if doConvert && vt.ConvertibleTo(uint8Type) { |
||||
// Convert and copy each element into a uint8 byte
|
||||
// slice.
|
||||
buf = make([]uint8, numEntries) |
||||
for i := 0; i < numEntries; i++ { |
||||
vv := v.Index(i) |
||||
buf[i] = uint8(vv.Convert(uint8Type).Uint()) |
||||
} |
||||
doHexDump = true |
||||
} |
||||
} |
||||
|
||||
// Hexdump the entire slice as needed.
|
||||
if doHexDump { |
||||
indent := strings.Repeat(d.cs.Indent, d.depth) |
||||
str := indent + hex.Dump(buf) |
||||
str = strings.Replace(str, "\n", "\n"+indent, -1) |
||||
str = strings.TrimRight(str, d.cs.Indent) |
||||
d.w.Write([]byte(str)) |
||||
return |
||||
} |
||||
|
||||
// Recursively call dump for each item.
|
||||
for i := 0; i < numEntries; i++ { |
||||
d.dump(d.unpackValue(v.Index(i))) |
||||
if i < (numEntries - 1) { |
||||
d.w.Write(commaNewlineBytes) |
||||
} else { |
||||
d.w.Write(newlineBytes) |
||||
} |
||||
} |
||||
} |
||||
|
||||
// dump is the main workhorse for dumping a value. It uses the passed reflect
|
||||
// value to figure out what kind of object we are dealing with and formats it
|
||||
// appropriately. It is a recursive function, however circular data structures
|
||||
// are detected and handled properly.
|
||||
func (d *dumpState) dump(v reflect.Value) { |
||||
// Handle invalid reflect values immediately.
|
||||
kind := v.Kind() |
||||
if kind == reflect.Invalid { |
||||
d.w.Write(invalidAngleBytes) |
||||
return |
||||
} |
||||
|
||||
// Handle pointers specially.
|
||||
if kind == reflect.Ptr { |
||||
d.indent() |
||||
d.dumpPtr(v) |
||||
return |
||||
} |
||||
|
||||
// Print type information unless already handled elsewhere.
|
||||
if !d.ignoreNextType { |
||||
d.indent() |
||||
d.w.Write(openParenBytes) |
||||
d.w.Write([]byte(v.Type().String())) |
||||
d.w.Write(closeParenBytes) |
||||
d.w.Write(spaceBytes) |
||||
} |
||||
d.ignoreNextType = false |
||||
|
||||
// Display length and capacity if the built-in len and cap functions
|
||||
// work with the value's kind and the len/cap itself is non-zero.
|
||||
valueLen, valueCap := 0, 0 |
||||
switch v.Kind() { |
||||
case reflect.Array, reflect.Slice, reflect.Chan: |
||||
valueLen, valueCap = v.Len(), v.Cap() |
||||
case reflect.Map, reflect.String: |
||||
valueLen = v.Len() |
||||
} |
||||
if valueLen != 0 || !d.cs.DisableCapacities && valueCap != 0 { |
||||
d.w.Write(openParenBytes) |
||||
if valueLen != 0 { |
||||
d.w.Write(lenEqualsBytes) |
||||
printInt(d.w, int64(valueLen), 10) |
||||
} |
||||
if !d.cs.DisableCapacities && valueCap != 0 { |
||||
if valueLen != 0 { |
||||
d.w.Write(spaceBytes) |
||||
} |
||||
d.w.Write(capEqualsBytes) |
||||
printInt(d.w, int64(valueCap), 10) |
||||
} |
||||
d.w.Write(closeParenBytes) |
||||
d.w.Write(spaceBytes) |
||||
} |
||||
|
||||
// Call Stringer/error interfaces if they exist and the handle methods flag
|
||||
// is enabled
|
||||
if !d.cs.DisableMethods { |
||||
if (kind != reflect.Invalid) && (kind != reflect.Interface) { |
||||
if handled := handleMethods(d.cs, d.w, v); handled { |
||||
return |
||||
} |
||||
} |
||||
} |
||||
|
||||
switch kind { |
||||
case reflect.Invalid: |
||||
// Do nothing. We should never get here since invalid has already
|
||||
// been handled above.
|
||||
|
||||
case reflect.Bool: |
||||
printBool(d.w, v.Bool()) |
||||
|
||||
case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int: |
||||
printInt(d.w, v.Int(), 10) |
||||
|
||||
case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint: |
||||
printUint(d.w, v.Uint(), 10) |
||||
|
||||
case reflect.Float32: |
||||
printFloat(d.w, v.Float(), 32) |
||||
|
||||
case reflect.Float64: |
||||
printFloat(d.w, v.Float(), 64) |
||||
|
||||
case reflect.Complex64: |
||||
printComplex(d.w, v.Complex(), 32) |
||||
|
||||
case reflect.Complex128: |
||||
printComplex(d.w, v.Complex(), 64) |
||||
|
||||
case reflect.Slice: |
||||
if v.IsNil() { |
||||
d.w.Write(nilAngleBytes) |
||||
break |
||||
} |
||||
fallthrough |
||||
|
||||
case reflect.Array: |
||||
d.w.Write(openBraceNewlineBytes) |
||||
d.depth++ |
||||
if (d.cs.MaxDepth != 0) && (d.depth > d.cs.MaxDepth) { |
||||
d.indent() |
||||
d.w.Write(maxNewlineBytes) |
||||
} else { |
||||
d.dumpSlice(v) |
||||
} |
||||
d.depth-- |
||||
d.indent() |
||||
d.w.Write(closeBraceBytes) |
||||
|
||||
case reflect.String: |
||||
d.w.Write([]byte(strconv.Quote(v.String()))) |
||||
|
||||
case reflect.Interface: |
||||
// The only time we should get here is for nil interfaces due to
|
||||
// unpackValue calls.
|
||||
if v.IsNil() { |
||||
d.w.Write(nilAngleBytes) |
||||
} |
||||
|
||||
case reflect.Ptr: |
||||
// Do nothing. We should never get here since pointers have already
|
||||
// been handled above.
|
||||
|
||||
case reflect.Map: |
||||
// nil maps should be indicated as different than empty maps
|
||||
if v.IsNil() { |
||||
d.w.Write(nilAngleBytes) |
||||
break |
||||
} |
||||
|
||||
d.w.Write(openBraceNewlineBytes) |
||||
d.depth++ |
||||
if (d.cs.MaxDepth != 0) && (d.depth > d.cs.MaxDepth) { |
||||
d.indent() |
||||
d.w.Write(maxNewlineBytes) |
||||
} else { |
||||
numEntries := v.Len() |
||||
keys := v.MapKeys() |
||||
if d.cs.SortKeys { |
||||
sortValues(keys, d.cs) |
||||
} |
||||
for i, key := range keys { |
||||
d.dump(d.unpackValue(key)) |
||||
d.w.Write(colonSpaceBytes) |
||||
d.ignoreNextIndent = true |
||||
d.dump(d.unpackValue(v.MapIndex(key))) |
||||
if i < (numEntries - 1) { |
||||
d.w.Write(commaNewlineBytes) |
||||
} else { |
||||
d.w.Write(newlineBytes) |
||||
} |
||||
} |
||||
} |
||||
d.depth-- |
||||
d.indent() |
||||
d.w.Write(closeBraceBytes) |
||||
|
||||
case reflect.Struct: |
||||
d.w.Write(openBraceNewlineBytes) |
||||
d.depth++ |
||||
if (d.cs.MaxDepth != 0) && (d.depth > d.cs.MaxDepth) { |
||||
d.indent() |
||||
d.w.Write(maxNewlineBytes) |
||||
} else { |
||||
vt := v.Type() |
||||
numFields := v.NumField() |
||||
for i := 0; i < numFields; i++ { |
||||
d.indent() |
||||
vtf := vt.Field(i) |
||||
d.w.Write([]byte(vtf.Name)) |
||||
d.w.Write(colonSpaceBytes) |
||||
d.ignoreNextIndent = true |
||||
d.dump(d.unpackValue(v.Field(i))) |
||||
if i < (numFields - 1) { |
||||
d.w.Write(commaNewlineBytes) |
||||
} else { |
||||
d.w.Write(newlineBytes) |
||||
} |
||||
} |
||||
} |
||||
d.depth-- |
||||
d.indent() |
||||
d.w.Write(closeBraceBytes) |
||||
|
||||
case reflect.Uintptr: |
||||
printHexPtr(d.w, uintptr(v.Uint())) |
||||
|
||||
case reflect.UnsafePointer, reflect.Chan, reflect.Func: |
||||
printHexPtr(d.w, v.Pointer()) |
||||
|
||||
// There were not any other types at the time this code was written, but
|
||||
// fall back to letting the default fmt package handle it in case any new
|
||||
// types are added.
|
||||
default: |
||||
if v.CanInterface() { |
||||
fmt.Fprintf(d.w, "%v", v.Interface()) |
||||
} else { |
||||
fmt.Fprintf(d.w, "%v", v.String()) |
||||
} |
||||
} |
||||
} |
||||
|
||||
// fdump is a helper function to consolidate the logic from the various public
|
||||
// methods which take varying writers and config states.
|
||||
func fdump(cs *ConfigState, w io.Writer, a ...interface{}) { |
||||
for _, arg := range a { |
||||
if arg == nil { |
||||
w.Write(interfaceBytes) |
||||
w.Write(spaceBytes) |
||||
w.Write(nilAngleBytes) |
||||
w.Write(newlineBytes) |
||||
continue |
||||
} |
||||
|
||||
d := dumpState{w: w, cs: cs} |
||||
d.pointers = make(map[uintptr]int) |
||||
d.dump(reflect.ValueOf(arg)) |
||||
d.w.Write(newlineBytes) |
||||
} |
||||
} |
||||
|
||||
// Fdump formats and displays the passed arguments to io.Writer w. It formats
|
||||
// exactly the same as Dump.
|
||||
func Fdump(w io.Writer, a ...interface{}) { |
||||
fdump(&Config, w, a...) |
||||
} |
||||
|
||||
// Sdump returns a string with the passed arguments formatted exactly the same
|
||||
// as Dump.
|
||||
func Sdump(a ...interface{}) string { |
||||
var buf bytes.Buffer |
||||
fdump(&Config, &buf, a...) |
||||
return buf.String() |
||||
} |
||||
|
||||
/* |
||||
Dump displays the passed parameters to standard out with newlines, customizable |
||||
indentation, and additional debug information such as complete types and all |
||||
pointer addresses used to indirect to the final value. It provides the |
||||
following features over the built-in printing facilities provided by the fmt |
||||
package: |
||||
|
||||
* Pointers are dereferenced and followed |
||||
* Circular data structures are detected and handled properly |
||||
* Custom Stringer/error interfaces are optionally invoked, including |
||||
on unexported types |
||||
* Custom types which only implement the Stringer/error interfaces via |
||||
a pointer receiver are optionally invoked when passing non-pointer |
||||
variables |
||||
* Byte arrays and slices are dumped like the hexdump -C command which |
||||
includes offsets, byte values in hex, and ASCII output |
||||
|
||||
The configuration options are controlled by an exported package global, |
||||
spew.Config. See ConfigState for options documentation. |
||||
|
||||
See Fdump if you would prefer dumping to an arbitrary io.Writer or Sdump to |
||||
get the formatted result as a string. |
||||
*/ |
||||
func Dump(a ...interface{}) { |
||||
fdump(&Config, os.Stdout, a...) |
||||
} |
||||
@ -0,0 +1,419 @@ |
||||
/* |
||||
* Copyright (c) 2013-2016 Dave Collins <dave@davec.name> |
||||
* |
||||
* Permission to use, copy, modify, and distribute this software for any |
||||
* purpose with or without fee is hereby granted, provided that the above |
||||
* copyright notice and this permission notice appear in all copies. |
||||
* |
||||
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES |
||||
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF |
||||
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR |
||||
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES |
||||
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN |
||||
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF |
||||
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. |
||||
*/ |
||||
|
||||
package spew |
||||
|
||||
import ( |
||||
"bytes" |
||||
"fmt" |
||||
"reflect" |
||||
"strconv" |
||||
"strings" |
||||
) |
||||
|
||||
// supportedFlags is a list of all the character flags supported by fmt package.
|
||||
const supportedFlags = "0-+# " |
||||
|
||||
// formatState implements the fmt.Formatter interface and contains information
|
||||
// about the state of a formatting operation. The NewFormatter function can
|
||||
// be used to get a new Formatter which can be used directly as arguments
|
||||
// in standard fmt package printing calls.
|
||||
type formatState struct { |
||||
value interface{} |
||||
fs fmt.State |
||||
depth int |
||||
pointers map[uintptr]int |
||||
ignoreNextType bool |
||||
cs *ConfigState |
||||
} |
||||
|
||||
// buildDefaultFormat recreates the original format string without precision
|
||||
// and width information to pass in to fmt.Sprintf in the case of an
|
||||
// unrecognized type. Unless new types are added to the language, this
|
||||
// function won't ever be called.
|
||||
func (f *formatState) buildDefaultFormat() (format string) { |
||||
buf := bytes.NewBuffer(percentBytes) |
||||
|
||||
for _, flag := range supportedFlags { |
||||
if f.fs.Flag(int(flag)) { |
||||
buf.WriteRune(flag) |
||||
} |
||||
} |
||||
|
||||
buf.WriteRune('v') |
||||
|
||||
format = buf.String() |
||||
return format |
||||
} |
||||
|
||||
// constructOrigFormat recreates the original format string including precision
|
||||
// and width information to pass along to the standard fmt package. This allows
|
||||
// automatic deferral of all format strings this package doesn't support.
|
||||
func (f *formatState) constructOrigFormat(verb rune) (format string) { |
||||
buf := bytes.NewBuffer(percentBytes) |
||||
|
||||
for _, flag := range supportedFlags { |
||||
if f.fs.Flag(int(flag)) { |
||||
buf.WriteRune(flag) |
||||
} |
||||
} |
||||
|
||||
if width, ok := f.fs.Width(); ok { |
||||
buf.WriteString(strconv.Itoa(width)) |
||||
} |
||||
|
||||
if precision, ok := f.fs.Precision(); ok { |
||||
buf.Write(precisionBytes) |
||||
buf.WriteString(strconv.Itoa(precision)) |
||||
} |
||||
|
||||
buf.WriteRune(verb) |
||||
|
||||
format = buf.String() |
||||
return format |
||||
} |
||||
|
||||
// unpackValue returns values inside of non-nil interfaces when possible and
|
||||
// ensures that types for values which have been unpacked from an interface
|
||||
// are displayed when the show types flag is also set.
|
||||
// This is useful for data types like structs, arrays, slices, and maps which
|
||||
// can contain varying types packed inside an interface.
|
||||
func (f *formatState) unpackValue(v reflect.Value) reflect.Value { |
||||
if v.Kind() == reflect.Interface { |
||||
f.ignoreNextType = false |
||||
if !v.IsNil() { |
||||
v = v.Elem() |
||||
} |
||||
} |
||||
return v |
||||
} |
||||
|
||||
// formatPtr handles formatting of pointers by indirecting them as necessary.
|
||||
func (f *formatState) formatPtr(v reflect.Value) { |
||||
// Display nil if top level pointer is nil.
|
||||
showTypes := f.fs.Flag('#') |
||||
if v.IsNil() && (!showTypes || f.ignoreNextType) { |
||||
f.fs.Write(nilAngleBytes) |
||||
return |
||||
} |
||||
|
||||
// Remove pointers at or below the current depth from map used to detect
|
||||
// circular refs.
|
||||
for k, depth := range f.pointers { |
||||
if depth >= f.depth { |
||||
delete(f.pointers, k) |
||||
} |
||||
} |
||||
|
||||
// Keep list of all dereferenced pointers to possibly show later.
|
||||
pointerChain := make([]uintptr, 0) |
||||
|
||||
// Figure out how many levels of indirection there are by derferencing
|
||||
// pointers and unpacking interfaces down the chain while detecting circular
|
||||
// references.
|
||||
nilFound := false |
||||
cycleFound := false |
||||
indirects := 0 |
||||
ve := v |
||||
for ve.Kind() == reflect.Ptr { |
||||
if ve.IsNil() { |
||||
nilFound = true |
||||
break |
||||
} |
||||
indirects++ |
||||
addr := ve.Pointer() |
||||
pointerChain = append(pointerChain, addr) |
||||
if pd, ok := f.pointers[addr]; ok && pd < f.depth { |
||||
cycleFound = true |
||||
indirects-- |
||||
break |
||||
} |
||||
f.pointers[addr] = f.depth |
||||
|
||||
ve = ve.Elem() |
||||
if ve.Kind() == reflect.Interface { |
||||
if ve.IsNil() { |
||||
nilFound = true |
||||
break |
||||
} |
||||
ve = ve.Elem() |
||||
} |
||||
} |
||||
|
||||
// Display type or indirection level depending on flags.
|
||||
if showTypes && !f.ignoreNextType { |
||||
f.fs.Write(openParenBytes) |
||||
f.fs.Write(bytes.Repeat(asteriskBytes, indirects)) |
||||
f.fs.Write([]byte(ve.Type().String())) |
||||
f.fs.Write(closeParenBytes) |
||||
} else { |
||||
if nilFound || cycleFound { |
||||
indirects += strings.Count(ve.Type().String(), "*") |
||||
} |
||||
f.fs.Write(openAngleBytes) |
||||
f.fs.Write([]byte(strings.Repeat("*", indirects))) |
||||
f.fs.Write(closeAngleBytes) |
||||
} |
||||
|
||||
// Display pointer information depending on flags.
|
||||
if f.fs.Flag('+') && (len(pointerChain) > 0) { |
||||
f.fs.Write(openParenBytes) |
||||
for i, addr := range pointerChain { |
||||
if i > 0 { |
||||
f.fs.Write(pointerChainBytes) |
||||
} |
||||
printHexPtr(f.fs, addr) |
||||
} |
||||
f.fs.Write(closeParenBytes) |
||||
} |
||||
|
||||
// Display dereferenced value.
|
||||
switch { |
||||
case nilFound: |
||||
f.fs.Write(nilAngleBytes) |
||||
|
||||
case cycleFound: |
||||
f.fs.Write(circularShortBytes) |
||||
|
||||
default: |
||||
f.ignoreNextType = true |
||||
f.format(ve) |
||||
} |
||||
} |
||||
|
||||
// format is the main workhorse for providing the Formatter interface. It
|
||||
// uses the passed reflect value to figure out what kind of object we are
|
||||
// dealing with and formats it appropriately. It is a recursive function,
|
||||
// however circular data structures are detected and handled properly.
|
||||
func (f *formatState) format(v reflect.Value) { |
||||
// Handle invalid reflect values immediately.
|
||||
kind := v.Kind() |
||||
if kind == reflect.Invalid { |
||||
f.fs.Write(invalidAngleBytes) |
||||
return |
||||
} |
||||
|
||||
// Handle pointers specially.
|
||||
if kind == reflect.Ptr { |
||||
f.formatPtr(v) |
||||
return |
||||
} |
||||
|
||||
// Print type information unless already handled elsewhere.
|
||||
if !f.ignoreNextType && f.fs.Flag('#') { |
||||
f.fs.Write(openParenBytes) |
||||
f.fs.Write([]byte(v.Type().String())) |
||||
f.fs.Write(closeParenBytes) |
||||
} |
||||
f.ignoreNextType = false |
||||
|
||||
// Call Stringer/error interfaces if they exist and the handle methods
|
||||
// flag is enabled.
|
||||
if !f.cs.DisableMethods { |
||||
if (kind != reflect.Invalid) && (kind != reflect.Interface) { |
||||
if handled := handleMethods(f.cs, f.fs, v); handled { |
||||
return |
||||
} |
||||
} |
||||
} |
||||
|
||||
switch kind { |
||||
case reflect.Invalid: |
||||
// Do nothing. We should never get here since invalid has already
|
||||
// been handled above.
|
||||
|
||||
case reflect.Bool: |
||||
printBool(f.fs, v.Bool()) |
||||
|
||||
case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int: |
||||
printInt(f.fs, v.Int(), 10) |
||||
|
||||
case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint: |
||||
printUint(f.fs, v.Uint(), 10) |
||||
|
||||
case reflect.Float32: |
||||
printFloat(f.fs, v.Float(), 32) |
||||
|
||||
case reflect.Float64: |
||||
printFloat(f.fs, v.Float(), 64) |
||||
|
||||
case reflect.Complex64: |
||||
printComplex(f.fs, v.Complex(), 32) |
||||
|
||||
case reflect.Complex128: |
||||
printComplex(f.fs, v.Complex(), 64) |
||||
|
||||
case reflect.Slice: |
||||
if v.IsNil() { |
||||
f.fs.Write(nilAngleBytes) |
||||
break |
||||
} |
||||
fallthrough |
||||
|
||||
case reflect.Array: |
||||
f.fs.Write(openBracketBytes) |
||||
f.depth++ |
||||
if (f.cs.MaxDepth != 0) && (f.depth > f.cs.MaxDepth) { |
||||
f.fs.Write(maxShortBytes) |
||||
} else { |
||||
numEntries := v.Len() |
||||
for i := 0; i < numEntries; i++ { |
||||
if i > 0 { |
||||
f.fs.Write(spaceBytes) |
||||
} |
||||
f.ignoreNextType = true |
||||
f.format(f.unpackValue(v.Index(i))) |
||||
} |
||||
} |
||||
f.depth-- |
||||
f.fs.Write(closeBracketBytes) |
||||
|
||||
case reflect.String: |
||||
f.fs.Write([]byte(v.String())) |
||||
|
||||
case reflect.Interface: |
||||
// The only time we should get here is for nil interfaces due to
|
||||
// unpackValue calls.
|
||||
if v.IsNil() { |
||||
f.fs.Write(nilAngleBytes) |
||||
} |
||||
|
||||
case reflect.Ptr: |
||||
// Do nothing. We should never get here since pointers have already
|
||||
// been handled above.
|
||||
|
||||
case reflect.Map: |
||||
// nil maps should be indicated as different than empty maps
|
||||
if v.IsNil() { |
||||
f.fs.Write(nilAngleBytes) |
||||
break |
||||
} |
||||
|
||||
f.fs.Write(openMapBytes) |
||||
f.depth++ |
||||
if (f.cs.MaxDepth != 0) && (f.depth > f.cs.MaxDepth) { |
||||
f.fs.Write(maxShortBytes) |
||||
} else { |
||||
keys := v.MapKeys() |
||||
if f.cs.SortKeys { |
||||
sortValues(keys, f.cs) |
||||
} |
||||
for i, key := range keys { |
||||
if i > 0 { |
||||
f.fs.Write(spaceBytes) |
||||
} |
||||
f.ignoreNextType = true |
||||
f.format(f.unpackValue(key)) |
||||
f.fs.Write(colonBytes) |
||||
f.ignoreNextType = true |
||||
f.format(f.unpackValue(v.MapIndex(key))) |
||||
} |
||||
} |
||||
f.depth-- |
||||
f.fs.Write(closeMapBytes) |
||||
|
||||
case reflect.Struct: |
||||
numFields := v.NumField() |
||||
f.fs.Write(openBraceBytes) |
||||
f.depth++ |
||||
if (f.cs.MaxDepth != 0) && (f.depth > f.cs.MaxDepth) { |
||||
f.fs.Write(maxShortBytes) |
||||
} else { |
||||
vt := v.Type() |
||||
for i := 0; i < numFields; i++ { |
||||
if i > 0 { |
||||
f.fs.Write(spaceBytes) |
||||
} |
||||
vtf := vt.Field(i) |
||||
if f.fs.Flag('+') || f.fs.Flag('#') { |
||||
f.fs.Write([]byte(vtf.Name)) |
||||
f.fs.Write(colonBytes) |
||||
} |
||||
f.format(f.unpackValue(v.Field(i))) |
||||
} |
||||
} |
||||
f.depth-- |
||||
f.fs.Write(closeBraceBytes) |
||||
|
||||
case reflect.Uintptr: |
||||
printHexPtr(f.fs, uintptr(v.Uint())) |
||||
|
||||
case reflect.UnsafePointer, reflect.Chan, reflect.Func: |
||||
printHexPtr(f.fs, v.Pointer()) |
||||
|
||||
// There were not any other types at the time this code was written, but
|
||||
// fall back to letting the default fmt package handle it if any get added.
|
||||
default: |
||||
format := f.buildDefaultFormat() |
||||
if v.CanInterface() { |
||||
fmt.Fprintf(f.fs, format, v.Interface()) |
||||
} else { |
||||
fmt.Fprintf(f.fs, format, v.String()) |
||||
} |
||||
} |
||||
} |
||||
|
||||
// Format satisfies the fmt.Formatter interface. See NewFormatter for usage
|
||||
// details.
|
||||
func (f *formatState) Format(fs fmt.State, verb rune) { |
||||
f.fs = fs |
||||
|
||||
// Use standard formatting for verbs that are not v.
|
||||
if verb != 'v' { |
||||
format := f.constructOrigFormat(verb) |
||||
fmt.Fprintf(fs, format, f.value) |
||||
return |
||||
} |
||||
|
||||
if f.value == nil { |
||||
if fs.Flag('#') { |
||||
fs.Write(interfaceBytes) |
||||
} |
||||
fs.Write(nilAngleBytes) |
||||
return |
||||
} |
||||
|
||||
f.format(reflect.ValueOf(f.value)) |
||||
} |
||||
|
||||
// newFormatter is a helper function to consolidate the logic from the various
|
||||
// public methods which take varying config states.
|
||||
func newFormatter(cs *ConfigState, v interface{}) fmt.Formatter { |
||||
fs := &formatState{value: v, cs: cs} |
||||
fs.pointers = make(map[uintptr]int) |
||||
return fs |
||||
} |
||||
|
||||
/* |
||||
NewFormatter returns a custom formatter that satisfies the fmt.Formatter |
||||
interface. As a result, it integrates cleanly with standard fmt package |
||||
printing functions. The formatter is useful for inline printing of smaller data |
||||
types similar to the standard %v format specifier. |
||||
|
||||
The custom formatter only responds to the %v (most compact), %+v (adds pointer |
||||
addresses), %#v (adds types), or %#+v (adds types and pointer addresses) verb |
||||
combinations. Any other verbs such as %x and %q will be sent to the the |
||||
standard fmt package for formatting. In addition, the custom formatter ignores |
||||
the width and precision arguments (however they will still work on the format |
||||
specifiers not handled by the custom formatter). |
||||
|
||||
Typically this function shouldn't be called directly. It is much easier to make |
||||
use of the custom formatter by calling one of the convenience functions such as |
||||
Printf, Println, or Fprintf. |
||||
*/ |
||||
func NewFormatter(v interface{}) fmt.Formatter { |
||||
return newFormatter(&Config, v) |
||||
} |
||||
@ -0,0 +1,148 @@ |
||||
/* |
||||
* Copyright (c) 2013-2016 Dave Collins <dave@davec.name> |
||||
* |
||||
* Permission to use, copy, modify, and distribute this software for any |
||||
* purpose with or without fee is hereby granted, provided that the above |
||||
* copyright notice and this permission notice appear in all copies. |
||||
* |
||||
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES |
||||
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF |
||||
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR |
||||
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES |
||||
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN |
||||
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF |
||||
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. |
||||
*/ |
||||
|
||||
package spew |
||||
|
||||
import ( |
||||
"fmt" |
||||
"io" |
||||
) |
||||
|
||||
// Errorf is a wrapper for fmt.Errorf that treats each argument as if it were
|
||||
// passed with a default Formatter interface returned by NewFormatter. It
|
||||
// returns the formatted string as a value that satisfies error. See
|
||||
// NewFormatter for formatting details.
|
||||
//
|
||||
// This function is shorthand for the following syntax:
|
||||
//
|
||||
// fmt.Errorf(format, spew.NewFormatter(a), spew.NewFormatter(b))
|
||||
func Errorf(format string, a ...interface{}) (err error) { |
||||
return fmt.Errorf(format, convertArgs(a)...) |
||||
} |
||||
|
||||
// Fprint is a wrapper for fmt.Fprint that treats each argument as if it were
|
||||
// passed with a default Formatter interface returned by NewFormatter. It
|
||||
// returns the number of bytes written and any write error encountered. See
|
||||
// NewFormatter for formatting details.
|
||||
//
|
||||
// This function is shorthand for the following syntax:
|
||||
//
|
||||
// fmt.Fprint(w, spew.NewFormatter(a), spew.NewFormatter(b))
|
||||
func Fprint(w io.Writer, a ...interface{}) (n int, err error) { |
||||
return fmt.Fprint(w, convertArgs(a)...) |
||||
} |
||||
|
||||
// Fprintf is a wrapper for fmt.Fprintf that treats each argument as if it were
|
||||
// passed with a default Formatter interface returned by NewFormatter. It
|
||||
// returns the number of bytes written and any write error encountered. See
|
||||
// NewFormatter for formatting details.
|
||||
//
|
||||
// This function is shorthand for the following syntax:
|
||||
//
|
||||
// fmt.Fprintf(w, format, spew.NewFormatter(a), spew.NewFormatter(b))
|
||||
func Fprintf(w io.Writer, format string, a ...interface{}) (n int, err error) { |
||||
return fmt.Fprintf(w, format, convertArgs(a)...) |
||||
} |
||||
|
||||
// Fprintln is a wrapper for fmt.Fprintln that treats each argument as if it
|
||||
// passed with a default Formatter interface returned by NewFormatter. See
|
||||
// NewFormatter for formatting details.
|
||||
//
|
||||
// This function is shorthand for the following syntax:
|
||||
//
|
||||
// fmt.Fprintln(w, spew.NewFormatter(a), spew.NewFormatter(b))
|
||||
func Fprintln(w io.Writer, a ...interface{}) (n int, err error) { |
||||
return fmt.Fprintln(w, convertArgs(a)...) |
||||
} |
||||
|
||||
// Print is a wrapper for fmt.Print that treats each argument as if it were
|
||||
// passed with a default Formatter interface returned by NewFormatter. It
|
||||
// returns the number of bytes written and any write error encountered. See
|
||||
// NewFormatter for formatting details.
|
||||
//
|
||||
// This function is shorthand for the following syntax:
|
||||
//
|
||||
// fmt.Print(spew.NewFormatter(a), spew.NewFormatter(b))
|
||||
func Print(a ...interface{}) (n int, err error) { |
||||
return fmt.Print(convertArgs(a)...) |
||||
} |
||||
|
||||
// Printf is a wrapper for fmt.Printf that treats each argument as if it were
|
||||
// passed with a default Formatter interface returned by NewFormatter. It
|
||||
// returns the number of bytes written and any write error encountered. See
|
||||
// NewFormatter for formatting details.
|
||||
//
|
||||
// This function is shorthand for the following syntax:
|
||||
//
|
||||
// fmt.Printf(format, spew.NewFormatter(a), spew.NewFormatter(b))
|
||||
func Printf(format string, a ...interface{}) (n int, err error) { |
||||
return fmt.Printf(format, convertArgs(a)...) |
||||
} |
||||
|
||||
// Println is a wrapper for fmt.Println that treats each argument as if it were
|
||||
// passed with a default Formatter interface returned by NewFormatter. It
|
||||
// returns the number of bytes written and any write error encountered. See
|
||||
// NewFormatter for formatting details.
|
||||
//
|
||||
// This function is shorthand for the following syntax:
|
||||
//
|
||||
// fmt.Println(spew.NewFormatter(a), spew.NewFormatter(b))
|
||||
func Println(a ...interface{}) (n int, err error) { |
||||
return fmt.Println(convertArgs(a)...) |
||||
} |
||||
|
||||
// Sprint is a wrapper for fmt.Sprint that treats each argument as if it were
|
||||
// passed with a default Formatter interface returned by NewFormatter. It
|
||||
// returns the resulting string. See NewFormatter for formatting details.
|
||||
//
|
||||
// This function is shorthand for the following syntax:
|
||||
//
|
||||
// fmt.Sprint(spew.NewFormatter(a), spew.NewFormatter(b))
|
||||
func Sprint(a ...interface{}) string { |
||||
return fmt.Sprint(convertArgs(a)...) |
||||
} |
||||
|
||||
// Sprintf is a wrapper for fmt.Sprintf that treats each argument as if it were
|
||||
// passed with a default Formatter interface returned by NewFormatter. It
|
||||
// returns the resulting string. See NewFormatter for formatting details.
|
||||
//
|
||||
// This function is shorthand for the following syntax:
|
||||
//
|
||||
// fmt.Sprintf(format, spew.NewFormatter(a), spew.NewFormatter(b))
|
||||
func Sprintf(format string, a ...interface{}) string { |
||||
return fmt.Sprintf(format, convertArgs(a)...) |
||||
} |
||||
|
||||
// Sprintln is a wrapper for fmt.Sprintln that treats each argument as if it
|
||||
// were passed with a default Formatter interface returned by NewFormatter. It
|
||||
// returns the resulting string. See NewFormatter for formatting details.
|
||||
//
|
||||
// This function is shorthand for the following syntax:
|
||||
//
|
||||
// fmt.Sprintln(spew.NewFormatter(a), spew.NewFormatter(b))
|
||||
func Sprintln(a ...interface{}) string { |
||||
return fmt.Sprintln(convertArgs(a)...) |
||||
} |
||||
|
||||
// convertArgs accepts a slice of arguments and returns a slice of the same
|
||||
// length with each argument converted to a default spew Formatter interface.
|
||||
func convertArgs(args []interface{}) (formatters []interface{}) { |
||||
formatters = make([]interface{}, len(args)) |
||||
for index, arg := range args { |
||||
formatters[index] = NewFormatter(arg) |
||||
} |
||||
return formatters |
||||
} |
||||
@ -0,0 +1,324 @@ |
||||
// Copyright 2019 The Go Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
package proto |
||||
|
||||
import ( |
||||
"errors" |
||||
"fmt" |
||||
|
||||
"google.golang.org/protobuf/encoding/prototext" |
||||
"google.golang.org/protobuf/encoding/protowire" |
||||
"google.golang.org/protobuf/runtime/protoimpl" |
||||
) |
||||
|
||||
const ( |
||||
WireVarint = 0 |
||||
WireFixed32 = 5 |
||||
WireFixed64 = 1 |
||||
WireBytes = 2 |
||||
WireStartGroup = 3 |
||||
WireEndGroup = 4 |
||||
) |
||||
|
||||
// EncodeVarint returns the varint encoded bytes of v.
|
||||
func EncodeVarint(v uint64) []byte { |
||||
return protowire.AppendVarint(nil, v) |
||||
} |
||||
|
||||
// SizeVarint returns the length of the varint encoded bytes of v.
|
||||
// This is equal to len(EncodeVarint(v)).
|
||||
func SizeVarint(v uint64) int { |
||||
return protowire.SizeVarint(v) |
||||
} |
||||
|
||||
// DecodeVarint parses a varint encoded integer from b, returning the
|
||||
// integer value and the length of the varint.
|
||||
// It returns (0, 0) if there is a parse error.
|
||||
func DecodeVarint(b []byte) (uint64, int) { |
||||
v, n := protowire.ConsumeVarint(b) |
||||
if n < 0 { |
||||
return 0, 0 |
||||
} |
||||
return v, n |
||||
} |
||||
|
||||
// Buffer is a buffer for encoding and decoding the protobuf wire format.
|
||||
// It may be reused between invocations to reduce memory usage.
|
||||
type Buffer struct { |
||||
buf []byte |
||||
idx int |
||||
deterministic bool |
||||
} |
||||
|
||||
// NewBuffer allocates a new Buffer initialized with buf,
|
||||
// where the contents of buf are considered the unread portion of the buffer.
|
||||
func NewBuffer(buf []byte) *Buffer { |
||||
return &Buffer{buf: buf} |
||||
} |
||||
|
||||
// SetDeterministic specifies whether to use deterministic serialization.
|
||||
//
|
||||
// Deterministic serialization guarantees that for a given binary, equal
|
||||
// messages will always be serialized to the same bytes. This implies:
|
||||
//
|
||||
// - Repeated serialization of a message will return the same bytes.
|
||||
// - Different processes of the same binary (which may be executing on
|
||||
// different machines) will serialize equal messages to the same bytes.
|
||||
//
|
||||
// Note that the deterministic serialization is NOT canonical across
|
||||
// languages. It is not guaranteed to remain stable over time. It is unstable
|
||||
// across different builds with schema changes due to unknown fields.
|
||||
// Users who need canonical serialization (e.g., persistent storage in a
|
||||
// canonical form, fingerprinting, etc.) should define their own
|
||||
// canonicalization specification and implement their own serializer rather
|
||||
// than relying on this API.
|
||||
//
|
||||
// If deterministic serialization is requested, map entries will be sorted
|
||||
// by keys in lexographical order. This is an implementation detail and
|
||||
// subject to change.
|
||||
func (b *Buffer) SetDeterministic(deterministic bool) { |
||||
b.deterministic = deterministic |
||||
} |
||||
|
||||
// SetBuf sets buf as the internal buffer,
|
||||
// where the contents of buf are considered the unread portion of the buffer.
|
||||
func (b *Buffer) SetBuf(buf []byte) { |
||||
b.buf = buf |
||||
b.idx = 0 |
||||
} |
||||
|
||||
// Reset clears the internal buffer of all written and unread data.
|
||||
func (b *Buffer) Reset() { |
||||
b.buf = b.buf[:0] |
||||
b.idx = 0 |
||||
} |
||||
|
||||
// Bytes returns the internal buffer.
|
||||
func (b *Buffer) Bytes() []byte { |
||||
return b.buf |
||||
} |
||||
|
||||
// Unread returns the unread portion of the buffer.
|
||||
func (b *Buffer) Unread() []byte { |
||||
return b.buf[b.idx:] |
||||
} |
||||
|
||||
// Marshal appends the wire-format encoding of m to the buffer.
|
||||
func (b *Buffer) Marshal(m Message) error { |
||||
var err error |
||||
b.buf, err = marshalAppend(b.buf, m, b.deterministic) |
||||
return err |
||||
} |
||||
|
||||
// Unmarshal parses the wire-format message in the buffer and places the decoded results in m.
|
||||
//
|
||||
// Unlike proto.Unmarshal, this does not reset the message before starting to unmarshal.
|
||||
func (b *Buffer) Unmarshal(m Message) error { |
||||
err := UnmarshalMerge(b.Unread(), m) |
||||
b.idx = len(b.buf) |
||||
return err |
||||
} |
||||
|
||||
type unknownFields struct{ XXX_unrecognized protoimpl.UnknownFields } |
||||
|
||||
func (m *unknownFields) String() string { panic("not implemented") } |
||||
func (m *unknownFields) Reset() { panic("not implemented") } |
||||
func (m *unknownFields) ProtoMessage() { panic("not implemented") } |
||||
|
||||
// DebugPrint dumps the encoded bytes of b with a header and footer including s
|
||||
// to stdout. This is only intended for debugging.
|
||||
func (*Buffer) DebugPrint(s string, b []byte) { |
||||
m := MessageReflect(new(unknownFields)) |
||||
m.SetUnknown(b) |
||||
b, _ = prototext.MarshalOptions{AllowPartial: true, Indent: "\t"}.Marshal(m.Interface()) |
||||
fmt.Printf("==== %s ====\n%s==== %s ====\n", s, b, s) |
||||
} |
||||
|
||||
// EncodeVarint appends an unsigned varint encoding to the buffer.
|
||||
func (b *Buffer) EncodeVarint(v uint64) error { |
||||
b.buf = protowire.AppendVarint(b.buf, v) |
||||
return nil |
||||
} |
||||
|
||||
// EncodeZigzag32 appends a 32-bit zig-zag varint encoding to the buffer.
|
||||
func (b *Buffer) EncodeZigzag32(v uint64) error { |
||||
return b.EncodeVarint(uint64((uint32(v) << 1) ^ uint32((int32(v) >> 31)))) |
||||
} |
||||
|
||||
// EncodeZigzag64 appends a 64-bit zig-zag varint encoding to the buffer.
|
||||
func (b *Buffer) EncodeZigzag64(v uint64) error { |
||||
return b.EncodeVarint(uint64((uint64(v) << 1) ^ uint64((int64(v) >> 63)))) |
||||
} |
||||
|
||||
// EncodeFixed32 appends a 32-bit little-endian integer to the buffer.
|
||||
func (b *Buffer) EncodeFixed32(v uint64) error { |
||||
b.buf = protowire.AppendFixed32(b.buf, uint32(v)) |
||||
return nil |
||||
} |
||||
|
||||
// EncodeFixed64 appends a 64-bit little-endian integer to the buffer.
|
||||
func (b *Buffer) EncodeFixed64(v uint64) error { |
||||
b.buf = protowire.AppendFixed64(b.buf, uint64(v)) |
||||
return nil |
||||
} |
||||
|
||||
// EncodeRawBytes appends a length-prefixed raw bytes to the buffer.
|
||||
func (b *Buffer) EncodeRawBytes(v []byte) error { |
||||
b.buf = protowire.AppendBytes(b.buf, v) |
||||
return nil |
||||
} |
||||
|
||||
// EncodeStringBytes appends a length-prefixed raw bytes to the buffer.
|
||||
// It does not validate whether v contains valid UTF-8.
|
||||
func (b *Buffer) EncodeStringBytes(v string) error { |
||||
b.buf = protowire.AppendString(b.buf, v) |
||||
return nil |
||||
} |
||||
|
||||
// EncodeMessage appends a length-prefixed encoded message to the buffer.
|
||||
func (b *Buffer) EncodeMessage(m Message) error { |
||||
var err error |
||||
b.buf = protowire.AppendVarint(b.buf, uint64(Size(m))) |
||||
b.buf, err = marshalAppend(b.buf, m, b.deterministic) |
||||
return err |
||||
} |
||||
|
||||
// DecodeVarint consumes an encoded unsigned varint from the buffer.
|
||||
func (b *Buffer) DecodeVarint() (uint64, error) { |
||||
v, n := protowire.ConsumeVarint(b.buf[b.idx:]) |
||||
if n < 0 { |
||||
return 0, protowire.ParseError(n) |
||||
} |
||||
b.idx += n |
||||
return uint64(v), nil |
||||
} |
||||
|
||||
// DecodeZigzag32 consumes an encoded 32-bit zig-zag varint from the buffer.
|
||||
func (b *Buffer) DecodeZigzag32() (uint64, error) { |
||||
v, err := b.DecodeVarint() |
||||
if err != nil { |
||||
return 0, err |
||||
} |
||||
return uint64((uint32(v) >> 1) ^ uint32((int32(v&1)<<31)>>31)), nil |
||||
} |
||||
|
||||
// DecodeZigzag64 consumes an encoded 64-bit zig-zag varint from the buffer.
|
||||
func (b *Buffer) DecodeZigzag64() (uint64, error) { |
||||
v, err := b.DecodeVarint() |
||||
if err != nil { |
||||
return 0, err |
||||
} |
||||
return uint64((uint64(v) >> 1) ^ uint64((int64(v&1)<<63)>>63)), nil |
||||
} |
||||
|
||||
// DecodeFixed32 consumes a 32-bit little-endian integer from the buffer.
|
||||
func (b *Buffer) DecodeFixed32() (uint64, error) { |
||||
v, n := protowire.ConsumeFixed32(b.buf[b.idx:]) |
||||
if n < 0 { |
||||
return 0, protowire.ParseError(n) |
||||
} |
||||
b.idx += n |
||||
return uint64(v), nil |
||||
} |
||||
|
||||
// DecodeFixed64 consumes a 64-bit little-endian integer from the buffer.
|
||||
func (b *Buffer) DecodeFixed64() (uint64, error) { |
||||
v, n := protowire.ConsumeFixed64(b.buf[b.idx:]) |
||||
if n < 0 { |
||||
return 0, protowire.ParseError(n) |
||||
} |
||||
b.idx += n |
||||
return uint64(v), nil |
||||
} |
||||
|
||||
// DecodeRawBytes consumes a length-prefixed raw bytes from the buffer.
|
||||
// If alloc is specified, it returns a copy the raw bytes
|
||||
// rather than a sub-slice of the buffer.
|
||||
func (b *Buffer) DecodeRawBytes(alloc bool) ([]byte, error) { |
||||
v, n := protowire.ConsumeBytes(b.buf[b.idx:]) |
||||
if n < 0 { |
||||
return nil, protowire.ParseError(n) |
||||
} |
||||
b.idx += n |
||||
if alloc { |
||||
v = append([]byte(nil), v...) |
||||
} |
||||
return v, nil |
||||
} |
||||
|
||||
// DecodeStringBytes consumes a length-prefixed raw bytes from the buffer.
|
||||
// It does not validate whether the raw bytes contain valid UTF-8.
|
||||
func (b *Buffer) DecodeStringBytes() (string, error) { |
||||
v, n := protowire.ConsumeString(b.buf[b.idx:]) |
||||
if n < 0 { |
||||
return "", protowire.ParseError(n) |
||||
} |
||||
b.idx += n |
||||
return v, nil |
||||
} |
||||
|
||||
// DecodeMessage consumes a length-prefixed message from the buffer.
|
||||
// It does not reset m.
|
||||
func (b *Buffer) DecodeMessage(m Message) error { |
||||
v, err := b.DecodeRawBytes(false) |
||||
if err != nil { |
||||
return err |
||||
} |
||||
return UnmarshalMerge(v, m) |
||||
} |
||||
|
||||
// DecodeGroup consumes a message group from the buffer.
|
||||
// It assumes that the start group marker has already been consumed and
|
||||
// consumes all bytes until (and including the end group marker).
|
||||
// It does not reset m.
|
||||
func (b *Buffer) DecodeGroup(m Message) error { |
||||
v, n, err := consumeGroup(b.buf[b.idx:]) |
||||
if err != nil { |
||||
return err |
||||
} |
||||
b.idx += n |
||||
return UnmarshalMerge(v, m) |
||||
} |
||||
|
||||
// consumeGroup parses b until it finds an end group marker, returning
|
||||
// the raw bytes of the message (excluding the end group marker) and the
|
||||
// the total length of the message (including the end group marker).
|
||||
func consumeGroup(b []byte) ([]byte, int, error) { |
||||
b0 := b |
||||
depth := 1 // assume this follows a start group marker
|
||||
for { |
||||
_, wtyp, tagLen := protowire.ConsumeTag(b) |
||||
if tagLen < 0 { |
||||
return nil, 0, protowire.ParseError(tagLen) |
||||
} |
||||
b = b[tagLen:] |
||||
|
||||
var valLen int |
||||
switch wtyp { |
||||
case protowire.VarintType: |
||||
_, valLen = protowire.ConsumeVarint(b) |
||||
case protowire.Fixed32Type: |
||||
_, valLen = protowire.ConsumeFixed32(b) |
||||
case protowire.Fixed64Type: |
||||
_, valLen = protowire.ConsumeFixed64(b) |
||||
case protowire.BytesType: |
||||
_, valLen = protowire.ConsumeBytes(b) |
||||
case protowire.StartGroupType: |
||||
depth++ |
||||
case protowire.EndGroupType: |
||||
depth-- |
||||
default: |
||||
return nil, 0, errors.New("proto: cannot parse reserved wire type") |
||||
} |
||||
if valLen < 0 { |
||||
return nil, 0, protowire.ParseError(valLen) |
||||
} |
||||
b = b[valLen:] |
||||
|
||||
if depth == 0 { |
||||
return b0[:len(b0)-len(b)-tagLen], len(b0) - len(b), nil |
||||
} |
||||
} |
||||
} |
||||
@ -1,253 +0,0 @@ |
||||
// Go support for Protocol Buffers - Google's data interchange format
|
||||
//
|
||||
// Copyright 2011 The Go Authors. All rights reserved.
|
||||
// https://github.com/golang/protobuf
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are
|
||||
// met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following disclaimer
|
||||
// in the documentation and/or other materials provided with the
|
||||
// distribution.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
// Protocol buffer deep copy and merge.
|
||||
// TODO: RawMessage.
|
||||
|
||||
package proto |
||||
|
||||
import ( |
||||
"fmt" |
||||
"log" |
||||
"reflect" |
||||
"strings" |
||||
) |
||||
|
||||
// Clone returns a deep copy of a protocol buffer.
|
||||
func Clone(src Message) Message { |
||||
in := reflect.ValueOf(src) |
||||
if in.IsNil() { |
||||
return src |
||||
} |
||||
out := reflect.New(in.Type().Elem()) |
||||
dst := out.Interface().(Message) |
||||
Merge(dst, src) |
||||
return dst |
||||
} |
||||
|
||||
// Merger is the interface representing objects that can merge messages of the same type.
|
||||
type Merger interface { |
||||
// Merge merges src into this message.
|
||||
// Required and optional fields that are set in src will be set to that value in dst.
|
||||
// Elements of repeated fields will be appended.
|
||||
//
|
||||
// Merge may panic if called with a different argument type than the receiver.
|
||||
Merge(src Message) |
||||
} |
||||
|
||||
// generatedMerger is the custom merge method that generated protos will have.
|
||||
// We must add this method since a generate Merge method will conflict with
|
||||
// many existing protos that have a Merge data field already defined.
|
||||
type generatedMerger interface { |
||||
XXX_Merge(src Message) |
||||
} |
||||
|
||||
// Merge merges src into dst.
|
||||
// Required and optional fields that are set in src will be set to that value in dst.
|
||||
// Elements of repeated fields will be appended.
|
||||
// Merge panics if src and dst are not the same type, or if dst is nil.
|
||||
func Merge(dst, src Message) { |
||||
if m, ok := dst.(Merger); ok { |
||||
m.Merge(src) |
||||
return |
||||
} |
||||
|
||||
in := reflect.ValueOf(src) |
||||
out := reflect.ValueOf(dst) |
||||
if out.IsNil() { |
||||
panic("proto: nil destination") |
||||
} |
||||
if in.Type() != out.Type() { |
||||
panic(fmt.Sprintf("proto.Merge(%T, %T) type mismatch", dst, src)) |
||||
} |
||||
if in.IsNil() { |
||||
return // Merge from nil src is a noop
|
||||
} |
||||
if m, ok := dst.(generatedMerger); ok { |
||||
m.XXX_Merge(src) |
||||
return |
||||
} |
||||
mergeStruct(out.Elem(), in.Elem()) |
||||
} |
||||
|
||||
func mergeStruct(out, in reflect.Value) { |
||||
sprop := GetProperties(in.Type()) |
||||
for i := 0; i < in.NumField(); i++ { |
||||
f := in.Type().Field(i) |
||||
if strings.HasPrefix(f.Name, "XXX_") { |
||||
continue |
||||
} |
||||
mergeAny(out.Field(i), in.Field(i), false, sprop.Prop[i]) |
||||
} |
||||
|
||||
if emIn, err := extendable(in.Addr().Interface()); err == nil { |
||||
emOut, _ := extendable(out.Addr().Interface()) |
||||
mIn, muIn := emIn.extensionsRead() |
||||
if mIn != nil { |
||||
mOut := emOut.extensionsWrite() |
||||
muIn.Lock() |
||||
mergeExtension(mOut, mIn) |
||||
muIn.Unlock() |
||||
} |
||||
} |
||||
|
||||
uf := in.FieldByName("XXX_unrecognized") |
||||
if !uf.IsValid() { |
||||
return |
||||
} |
||||
uin := uf.Bytes() |
||||
if len(uin) > 0 { |
||||
out.FieldByName("XXX_unrecognized").SetBytes(append([]byte(nil), uin...)) |
||||
} |
||||
} |
||||
|
||||
// mergeAny performs a merge between two values of the same type.
|
||||
// viaPtr indicates whether the values were indirected through a pointer (implying proto2).
|
||||
// prop is set if this is a struct field (it may be nil).
|
||||
func mergeAny(out, in reflect.Value, viaPtr bool, prop *Properties) { |
||||
if in.Type() == protoMessageType { |
||||
if !in.IsNil() { |
||||
if out.IsNil() { |
||||
out.Set(reflect.ValueOf(Clone(in.Interface().(Message)))) |
||||
} else { |
||||
Merge(out.Interface().(Message), in.Interface().(Message)) |
||||
} |
||||
} |
||||
return |
||||
} |
||||
switch in.Kind() { |
||||
case reflect.Bool, reflect.Float32, reflect.Float64, reflect.Int32, reflect.Int64, |
||||
reflect.String, reflect.Uint32, reflect.Uint64: |
||||
if !viaPtr && isProto3Zero(in) { |
||||
return |
||||
} |
||||
out.Set(in) |
||||
case reflect.Interface: |
||||
// Probably a oneof field; copy non-nil values.
|
||||
if in.IsNil() { |
||||
return |
||||
} |
||||
// Allocate destination if it is not set, or set to a different type.
|
||||
// Otherwise we will merge as normal.
|
||||
if out.IsNil() || out.Elem().Type() != in.Elem().Type() { |
||||
out.Set(reflect.New(in.Elem().Elem().Type())) // interface -> *T -> T -> new(T)
|
||||
} |
||||
mergeAny(out.Elem(), in.Elem(), false, nil) |
||||
case reflect.Map: |
||||
if in.Len() == 0 { |
||||
return |
||||
} |
||||
if out.IsNil() { |
||||
out.Set(reflect.MakeMap(in.Type())) |
||||
} |
||||
// For maps with value types of *T or []byte we need to deep copy each value.
|
||||
elemKind := in.Type().Elem().Kind() |
||||
for _, key := range in.MapKeys() { |
||||
var val reflect.Value |
||||
switch elemKind { |
||||
case reflect.Ptr: |
||||
val = reflect.New(in.Type().Elem().Elem()) |
||||
mergeAny(val, in.MapIndex(key), false, nil) |
||||
case reflect.Slice: |
||||
val = in.MapIndex(key) |
||||
val = reflect.ValueOf(append([]byte{}, val.Bytes()...)) |
||||
default: |
||||
val = in.MapIndex(key) |
||||
} |
||||
out.SetMapIndex(key, val) |
||||
} |
||||
case reflect.Ptr: |
||||
if in.IsNil() { |
||||
return |
||||
} |
||||
if out.IsNil() { |
||||
out.Set(reflect.New(in.Elem().Type())) |
||||
} |
||||
mergeAny(out.Elem(), in.Elem(), true, nil) |
||||
case reflect.Slice: |
||||
if in.IsNil() { |
||||
return |
||||
} |
||||
if in.Type().Elem().Kind() == reflect.Uint8 { |
||||
// []byte is a scalar bytes field, not a repeated field.
|
||||
|
||||
// Edge case: if this is in a proto3 message, a zero length
|
||||
// bytes field is considered the zero value, and should not
|
||||
// be merged.
|
||||
if prop != nil && prop.proto3 && in.Len() == 0 { |
||||
return |
||||
} |
||||
|
||||
// Make a deep copy.
|
||||
// Append to []byte{} instead of []byte(nil) so that we never end up
|
||||
// with a nil result.
|
||||
out.SetBytes(append([]byte{}, in.Bytes()...)) |
||||
return |
||||
} |
||||
n := in.Len() |
||||
if out.IsNil() { |
||||
out.Set(reflect.MakeSlice(in.Type(), 0, n)) |
||||
} |
||||
switch in.Type().Elem().Kind() { |
||||
case reflect.Bool, reflect.Float32, reflect.Float64, reflect.Int32, reflect.Int64, |
||||
reflect.String, reflect.Uint32, reflect.Uint64: |
||||
out.Set(reflect.AppendSlice(out, in)) |
||||
default: |
||||
for i := 0; i < n; i++ { |
||||
x := reflect.Indirect(reflect.New(in.Type().Elem())) |
||||
mergeAny(x, in.Index(i), false, nil) |
||||
out.Set(reflect.Append(out, x)) |
||||
} |
||||
} |
||||
case reflect.Struct: |
||||
mergeStruct(out, in) |
||||
default: |
||||
// unknown type, so not a protocol buffer
|
||||
log.Printf("proto: don't know how to copy %v", in) |
||||
} |
||||
} |
||||
|
||||
func mergeExtension(out, in map[int32]Extension) { |
||||
for extNum, eIn := range in { |
||||
eOut := Extension{desc: eIn.desc} |
||||
if eIn.value != nil { |
||||
v := reflect.New(reflect.TypeOf(eIn.value)).Elem() |
||||
mergeAny(v, reflect.ValueOf(eIn.value), false, nil) |
||||
eOut.value = v.Interface() |
||||
} |
||||
if eIn.enc != nil { |
||||
eOut.enc = make([]byte, len(eIn.enc)) |
||||
copy(eOut.enc, eIn.enc) |
||||
} |
||||
|
||||
out[extNum] = eOut |
||||
} |
||||
} |
||||
@ -1,427 +0,0 @@ |
||||
// Go support for Protocol Buffers - Google's data interchange format
|
||||
//
|
||||
// Copyright 2010 The Go Authors. All rights reserved.
|
||||
// https://github.com/golang/protobuf
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are
|
||||
// met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following disclaimer
|
||||
// in the documentation and/or other materials provided with the
|
||||
// distribution.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
package proto |
||||
|
||||
/* |
||||
* Routines for decoding protocol buffer data to construct in-memory representations. |
||||
*/ |
||||
|
||||
import ( |
||||
"errors" |
||||
"fmt" |
||||
"io" |
||||
) |
||||
|
||||
// errOverflow is returned when an integer is too large to be represented.
|
||||
var errOverflow = errors.New("proto: integer overflow") |
||||
|
||||
// ErrInternalBadWireType is returned by generated code when an incorrect
|
||||
// wire type is encountered. It does not get returned to user code.
|
||||
var ErrInternalBadWireType = errors.New("proto: internal error: bad wiretype for oneof") |
||||
|
||||
// DecodeVarint reads a varint-encoded integer from the slice.
|
||||
// It returns the integer and the number of bytes consumed, or
|
||||
// zero if there is not enough.
|
||||
// This is the format for the
|
||||
// int32, int64, uint32, uint64, bool, and enum
|
||||
// protocol buffer types.
|
||||
func DecodeVarint(buf []byte) (x uint64, n int) { |
||||
for shift := uint(0); shift < 64; shift += 7 { |
||||
if n >= len(buf) { |
||||
return 0, 0 |
||||
} |
||||
b := uint64(buf[n]) |
||||
n++ |
||||
x |= (b & 0x7F) << shift |
||||
if (b & 0x80) == 0 { |
||||
return x, n |
||||
} |
||||
} |
||||
|
||||
// The number is too large to represent in a 64-bit value.
|
||||
return 0, 0 |
||||
} |
||||
|
||||
func (p *Buffer) decodeVarintSlow() (x uint64, err error) { |
||||
i := p.index |
||||
l := len(p.buf) |
||||
|
||||
for shift := uint(0); shift < 64; shift += 7 { |
||||
if i >= l { |
||||
err = io.ErrUnexpectedEOF |
||||
return |
||||
} |
||||
b := p.buf[i] |
||||
i++ |
||||
x |= (uint64(b) & 0x7F) << shift |
||||
if b < 0x80 { |
||||
p.index = i |
||||
return |
||||
} |
||||
} |
||||
|
||||
// The number is too large to represent in a 64-bit value.
|
||||
err = errOverflow |
||||
return |
||||
} |
||||
|
||||
// DecodeVarint reads a varint-encoded integer from the Buffer.
|
||||
// This is the format for the
|
||||
// int32, int64, uint32, uint64, bool, and enum
|
||||
// protocol buffer types.
|
||||
func (p *Buffer) DecodeVarint() (x uint64, err error) { |
||||
i := p.index |
||||
buf := p.buf |
||||
|
||||
if i >= len(buf) { |
||||
return 0, io.ErrUnexpectedEOF |
||||
} else if buf[i] < 0x80 { |
||||
p.index++ |
||||
return uint64(buf[i]), nil |
||||
} else if len(buf)-i < 10 { |
||||
return p.decodeVarintSlow() |
||||
} |
||||
|
||||
var b uint64 |
||||
// we already checked the first byte
|
||||
x = uint64(buf[i]) - 0x80 |
||||
i++ |
||||
|
||||
b = uint64(buf[i]) |
||||
i++ |
||||
x += b << 7 |
||||
if b&0x80 == 0 { |
||||
goto done |
||||
} |
||||
x -= 0x80 << 7 |
||||
|
||||
b = uint64(buf[i]) |
||||
i++ |
||||
x += b << 14 |
||||
if b&0x80 == 0 { |
||||
goto done |
||||
} |
||||
x -= 0x80 << 14 |
||||
|
||||
b = uint64(buf[i]) |
||||
i++ |
||||
x += b << 21 |
||||
if b&0x80 == 0 { |
||||
goto done |
||||
} |
||||
x -= 0x80 << 21 |
||||
|
||||
b = uint64(buf[i]) |
||||
i++ |
||||
x += b << 28 |
||||
if b&0x80 == 0 { |
||||
goto done |
||||
} |
||||
x -= 0x80 << 28 |
||||
|
||||
b = uint64(buf[i]) |
||||
i++ |
||||
x += b << 35 |
||||
if b&0x80 == 0 { |
||||
goto done |
||||
} |
||||
x -= 0x80 << 35 |
||||
|
||||
b = uint64(buf[i]) |
||||
i++ |
||||
x += b << 42 |
||||
if b&0x80 == 0 { |
||||
goto done |
||||
} |
||||
x -= 0x80 << 42 |
||||
|
||||
b = uint64(buf[i]) |
||||
i++ |
||||
x += b << 49 |
||||
if b&0x80 == 0 { |
||||
goto done |
||||
} |
||||
x -= 0x80 << 49 |
||||
|
||||
b = uint64(buf[i]) |
||||
i++ |
||||
x += b << 56 |
||||
if b&0x80 == 0 { |
||||
goto done |
||||
} |
||||
x -= 0x80 << 56 |
||||
|
||||
b = uint64(buf[i]) |
||||
i++ |
||||
x += b << 63 |
||||
if b&0x80 == 0 { |
||||
goto done |
||||
} |
||||
|
||||
return 0, errOverflow |
||||
|
||||
done: |
||||
p.index = i |
||||
return x, nil |
||||
} |
||||
|
||||
// DecodeFixed64 reads a 64-bit integer from the Buffer.
|
||||
// This is the format for the
|
||||
// fixed64, sfixed64, and double protocol buffer types.
|
||||
func (p *Buffer) DecodeFixed64() (x uint64, err error) { |
||||
// x, err already 0
|
||||
i := p.index + 8 |
||||
if i < 0 || i > len(p.buf) { |
||||
err = io.ErrUnexpectedEOF |
||||
return |
||||
} |
||||
p.index = i |
||||
|
||||
x = uint64(p.buf[i-8]) |
||||
x |= uint64(p.buf[i-7]) << 8 |
||||
x |= uint64(p.buf[i-6]) << 16 |
||||
x |= uint64(p.buf[i-5]) << 24 |
||||
x |= uint64(p.buf[i-4]) << 32 |
||||
x |= uint64(p.buf[i-3]) << 40 |
||||
x |= uint64(p.buf[i-2]) << 48 |
||||
x |= uint64(p.buf[i-1]) << 56 |
||||
return |
||||
} |
||||
|
||||
// DecodeFixed32 reads a 32-bit integer from the Buffer.
|
||||
// This is the format for the
|
||||
// fixed32, sfixed32, and float protocol buffer types.
|
||||
func (p *Buffer) DecodeFixed32() (x uint64, err error) { |
||||
// x, err already 0
|
||||
i := p.index + 4 |
||||
if i < 0 || i > len(p.buf) { |
||||
err = io.ErrUnexpectedEOF |
||||
return |
||||
} |
||||
p.index = i |
||||
|
||||
x = uint64(p.buf[i-4]) |
||||
x |= uint64(p.buf[i-3]) << 8 |
||||
x |= uint64(p.buf[i-2]) << 16 |
||||
x |= uint64(p.buf[i-1]) << 24 |
||||
return |
||||
} |
||||
|
||||
// DecodeZigzag64 reads a zigzag-encoded 64-bit integer
|
||||
// from the Buffer.
|
||||
// This is the format used for the sint64 protocol buffer type.
|
||||
func (p *Buffer) DecodeZigzag64() (x uint64, err error) { |
||||
x, err = p.DecodeVarint() |
||||
if err != nil { |
||||
return |
||||
} |
||||
x = (x >> 1) ^ uint64((int64(x&1)<<63)>>63) |
||||
return |
||||
} |
||||
|
||||
// DecodeZigzag32 reads a zigzag-encoded 32-bit integer
|
||||
// from the Buffer.
|
||||
// This is the format used for the sint32 protocol buffer type.
|
||||
func (p *Buffer) DecodeZigzag32() (x uint64, err error) { |
||||
x, err = p.DecodeVarint() |
||||
if err != nil { |
||||
return |
||||
} |
||||
x = uint64((uint32(x) >> 1) ^ uint32((int32(x&1)<<31)>>31)) |
||||
return |
||||
} |
||||
|
||||
// DecodeRawBytes reads a count-delimited byte buffer from the Buffer.
|
||||
// This is the format used for the bytes protocol buffer
|
||||
// type and for embedded messages.
|
||||
func (p *Buffer) DecodeRawBytes(alloc bool) (buf []byte, err error) { |
||||
n, err := p.DecodeVarint() |
||||
if err != nil { |
||||
return nil, err |
||||
} |
||||
|
||||
nb := int(n) |
||||
if nb < 0 { |
||||
return nil, fmt.Errorf("proto: bad byte length %d", nb) |
||||
} |
||||
end := p.index + nb |
||||
if end < p.index || end > len(p.buf) { |
||||
return nil, io.ErrUnexpectedEOF |
||||
} |
||||
|
||||
if !alloc { |
||||
// todo: check if can get more uses of alloc=false
|
||||
buf = p.buf[p.index:end] |
||||
p.index += nb |
||||
return |
||||
} |
||||
|
||||
buf = make([]byte, nb) |
||||
copy(buf, p.buf[p.index:]) |
||||
p.index += nb |
||||
return |
||||
} |
||||
|
||||
// DecodeStringBytes reads an encoded string from the Buffer.
|
||||
// This is the format used for the proto2 string type.
|
||||
func (p *Buffer) DecodeStringBytes() (s string, err error) { |
||||
buf, err := p.DecodeRawBytes(false) |
||||
if err != nil { |
||||
return |
||||
} |
||||
return string(buf), nil |
||||
} |
||||
|
||||
// Unmarshaler is the interface representing objects that can
|
||||
// unmarshal themselves. The argument points to data that may be
|
||||
// overwritten, so implementations should not keep references to the
|
||||
// buffer.
|
||||
// Unmarshal implementations should not clear the receiver.
|
||||
// Any unmarshaled data should be merged into the receiver.
|
||||
// Callers of Unmarshal that do not want to retain existing data
|
||||
// should Reset the receiver before calling Unmarshal.
|
||||
type Unmarshaler interface { |
||||
Unmarshal([]byte) error |
||||
} |
||||
|
||||
// newUnmarshaler is the interface representing objects that can
|
||||
// unmarshal themselves. The semantics are identical to Unmarshaler.
|
||||
//
|
||||
// This exists to support protoc-gen-go generated messages.
|
||||
// The proto package will stop type-asserting to this interface in the future.
|
||||
//
|
||||
// DO NOT DEPEND ON THIS.
|
||||
type newUnmarshaler interface { |
||||
XXX_Unmarshal([]byte) error |
||||
} |
||||
|
||||
// Unmarshal parses the protocol buffer representation in buf and places the
|
||||
// decoded result in pb. If the struct underlying pb does not match
|
||||
// the data in buf, the results can be unpredictable.
|
||||
//
|
||||
// Unmarshal resets pb before starting to unmarshal, so any
|
||||
// existing data in pb is always removed. Use UnmarshalMerge
|
||||
// to preserve and append to existing data.
|
||||
func Unmarshal(buf []byte, pb Message) error { |
||||
pb.Reset() |
||||
if u, ok := pb.(newUnmarshaler); ok { |
||||
return u.XXX_Unmarshal(buf) |
||||
} |
||||
if u, ok := pb.(Unmarshaler); ok { |
||||
return u.Unmarshal(buf) |
||||
} |
||||
return NewBuffer(buf).Unmarshal(pb) |
||||
} |
||||
|
||||
// UnmarshalMerge parses the protocol buffer representation in buf and
|
||||
// writes the decoded result to pb. If the struct underlying pb does not match
|
||||
// the data in buf, the results can be unpredictable.
|
||||
//
|
||||
// UnmarshalMerge merges into existing data in pb.
|
||||
// Most code should use Unmarshal instead.
|
||||
func UnmarshalMerge(buf []byte, pb Message) error { |
||||
if u, ok := pb.(newUnmarshaler); ok { |
||||
return u.XXX_Unmarshal(buf) |
||||
} |
||||
if u, ok := pb.(Unmarshaler); ok { |
||||
// NOTE: The history of proto have unfortunately been inconsistent
|
||||
// whether Unmarshaler should or should not implicitly clear itself.
|
||||
// Some implementations do, most do not.
|
||||
// Thus, calling this here may or may not do what people want.
|
||||
//
|
||||
// See https://github.com/golang/protobuf/issues/424
|
||||
return u.Unmarshal(buf) |
||||
} |
||||
return NewBuffer(buf).Unmarshal(pb) |
||||
} |
||||
|
||||
// DecodeMessage reads a count-delimited message from the Buffer.
|
||||
func (p *Buffer) DecodeMessage(pb Message) error { |
||||
enc, err := p.DecodeRawBytes(false) |
||||
if err != nil { |
||||
return err |
||||
} |
||||
return NewBuffer(enc).Unmarshal(pb) |
||||
} |
||||
|
||||
// DecodeGroup reads a tag-delimited group from the Buffer.
|
||||
// StartGroup tag is already consumed. This function consumes
|
||||
// EndGroup tag.
|
||||
func (p *Buffer) DecodeGroup(pb Message) error { |
||||
b := p.buf[p.index:] |
||||
x, y := findEndGroup(b) |
||||
if x < 0 { |
||||
return io.ErrUnexpectedEOF |
||||
} |
||||
err := Unmarshal(b[:x], pb) |
||||
p.index += y |
||||
return err |
||||
} |
||||
|
||||
// Unmarshal parses the protocol buffer representation in the
|
||||
// Buffer and places the decoded result in pb. If the struct
|
||||
// underlying pb does not match the data in the buffer, the results can be
|
||||
// unpredictable.
|
||||
//
|
||||
// Unlike proto.Unmarshal, this does not reset pb before starting to unmarshal.
|
||||
func (p *Buffer) Unmarshal(pb Message) error { |
||||
// If the object can unmarshal itself, let it.
|
||||
if u, ok := pb.(newUnmarshaler); ok { |
||||
err := u.XXX_Unmarshal(p.buf[p.index:]) |
||||
p.index = len(p.buf) |
||||
return err |
||||
} |
||||
if u, ok := pb.(Unmarshaler); ok { |
||||
// NOTE: The history of proto have unfortunately been inconsistent
|
||||
// whether Unmarshaler should or should not implicitly clear itself.
|
||||
// Some implementations do, most do not.
|
||||
// Thus, calling this here may or may not do what people want.
|
||||
//
|
||||
// See https://github.com/golang/protobuf/issues/424
|
||||
err := u.Unmarshal(p.buf[p.index:]) |
||||
p.index = len(p.buf) |
||||
return err |
||||
} |
||||
|
||||
// Slow workaround for messages that aren't Unmarshalers.
|
||||
// This includes some hand-coded .pb.go files and
|
||||
// bootstrap protos.
|
||||
// TODO: fix all of those and then add Unmarshal to
|
||||
// the Message interface. Then:
|
||||
// The cast above and code below can be deleted.
|
||||
// The old unmarshaler can be deleted.
|
||||
// Clients can call Unmarshal directly (can already do that, actually).
|
||||
var info InternalMessageInfo |
||||
err := info.Unmarshal(pb, p.buf[p.index:]) |
||||
p.index = len(p.buf) |
||||
return err |
||||
} |
||||
@ -0,0 +1,63 @@ |
||||
// Copyright 2019 The Go Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
package proto |
||||
|
||||
import ( |
||||
"google.golang.org/protobuf/reflect/protoreflect" |
||||
) |
||||
|
||||
// SetDefaults sets unpopulated scalar fields to their default values.
|
||||
// Fields within a oneof are not set even if they have a default value.
|
||||
// SetDefaults is recursively called upon any populated message fields.
|
||||
func SetDefaults(m Message) { |
||||
if m != nil { |
||||
setDefaults(MessageReflect(m)) |
||||
} |
||||
} |
||||
|
||||
func setDefaults(m protoreflect.Message) { |
||||
fds := m.Descriptor().Fields() |
||||
for i := 0; i < fds.Len(); i++ { |
||||
fd := fds.Get(i) |
||||
if !m.Has(fd) { |
||||
if fd.HasDefault() && fd.ContainingOneof() == nil { |
||||
v := fd.Default() |
||||
if fd.Kind() == protoreflect.BytesKind { |
||||
v = protoreflect.ValueOf(append([]byte(nil), v.Bytes()...)) // copy the default bytes
|
||||
} |
||||
m.Set(fd, v) |
||||
} |
||||
continue |
||||
} |
||||
} |
||||
|
||||
m.Range(func(fd protoreflect.FieldDescriptor, v protoreflect.Value) bool { |
||||
switch { |
||||
// Handle singular message.
|
||||
case fd.Cardinality() != protoreflect.Repeated: |
||||
if fd.Message() != nil { |
||||
setDefaults(m.Get(fd).Message()) |
||||
} |
||||
// Handle list of messages.
|
||||
case fd.IsList(): |
||||
if fd.Message() != nil { |
||||
ls := m.Get(fd).List() |
||||
for i := 0; i < ls.Len(); i++ { |
||||
setDefaults(ls.Get(i).Message()) |
||||
} |
||||
} |
||||
// Handle map of messages.
|
||||
case fd.IsMap(): |
||||
if fd.MapValue().Message() != nil { |
||||
ms := m.Get(fd).Map() |
||||
ms.Range(func(_ protoreflect.MapKey, v protoreflect.Value) bool { |
||||
setDefaults(v.Message()) |
||||
return true |
||||
}) |
||||
} |
||||
} |
||||
return true |
||||
}) |
||||
} |
||||
@ -1,63 +1,92 @@ |
||||
// Go support for Protocol Buffers - Google's data interchange format
|
||||
//
|
||||
// Copyright 2018 The Go Authors. All rights reserved.
|
||||
// https://github.com/golang/protobuf
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are
|
||||
// met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following disclaimer
|
||||
// in the documentation and/or other materials provided with the
|
||||
// distribution.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
// Copyright 2018 The Go Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
package proto |
||||
|
||||
import "errors" |
||||
import ( |
||||
"encoding/json" |
||||
"errors" |
||||
"fmt" |
||||
"strconv" |
||||
) |
||||
|
||||
// Deprecated: do not use.
|
||||
var ( |
||||
// Deprecated: No longer returned.
|
||||
ErrNil = errors.New("proto: Marshal called with nil") |
||||
|
||||
// Deprecated: No longer returned.
|
||||
ErrTooLarge = errors.New("proto: message encodes to over 2 GB") |
||||
|
||||
// Deprecated: No longer returned.
|
||||
ErrInternalBadWireType = errors.New("proto: internal error: bad wiretype for oneof") |
||||
) |
||||
|
||||
// Deprecated: Do not use.
|
||||
type Stats struct{ Emalloc, Dmalloc, Encode, Decode, Chit, Cmiss, Size uint64 } |
||||
|
||||
// Deprecated: do not use.
|
||||
// Deprecated: Do not use.
|
||||
func GetStats() Stats { return Stats{} } |
||||
|
||||
// Deprecated: do not use.
|
||||
// Deprecated: Do not use.
|
||||
func MarshalMessageSet(interface{}) ([]byte, error) { |
||||
return nil, errors.New("proto: not implemented") |
||||
} |
||||
|
||||
// Deprecated: do not use.
|
||||
// Deprecated: Do not use.
|
||||
func UnmarshalMessageSet([]byte, interface{}) error { |
||||
return errors.New("proto: not implemented") |
||||
} |
||||
|
||||
// Deprecated: do not use.
|
||||
// Deprecated: Do not use.
|
||||
func MarshalMessageSetJSON(interface{}) ([]byte, error) { |
||||
return nil, errors.New("proto: not implemented") |
||||
} |
||||
|
||||
// Deprecated: do not use.
|
||||
// Deprecated: Do not use.
|
||||
func UnmarshalMessageSetJSON([]byte, interface{}) error { |
||||
return errors.New("proto: not implemented") |
||||
} |
||||
|
||||
// Deprecated: do not use.
|
||||
// Deprecated: Do not use.
|
||||
func RegisterMessageSetType(Message, int32, string) {} |
||||
|
||||
// Deprecated: Do not use.
|
||||
func EnumName(m map[int32]string, v int32) string { |
||||
s, ok := m[v] |
||||
if ok { |
||||
return s |
||||
} |
||||
return strconv.Itoa(int(v)) |
||||
} |
||||
|
||||
// Deprecated: Do not use.
|
||||
func UnmarshalJSONEnum(m map[string]int32, data []byte, enumName string) (int32, error) { |
||||
if data[0] == '"' { |
||||
// New style: enums are strings.
|
||||
var repr string |
||||
if err := json.Unmarshal(data, &repr); err != nil { |
||||
return -1, err |
||||
} |
||||
val, ok := m[repr] |
||||
if !ok { |
||||
return 0, fmt.Errorf("unrecognized enum %s value %q", enumName, repr) |
||||
} |
||||
return val, nil |
||||
} |
||||
// Old style: enums are ints.
|
||||
var val int32 |
||||
if err := json.Unmarshal(data, &val); err != nil { |
||||
return 0, fmt.Errorf("cannot unmarshal %#q into enum %s", data, enumName) |
||||
} |
||||
return val, nil |
||||
} |
||||
|
||||
// Deprecated: Do not use.
|
||||
type InternalMessageInfo struct{} |
||||
|
||||
func (*InternalMessageInfo) DiscardUnknown(Message) { panic("not implemented") } |
||||
func (*InternalMessageInfo) Marshal([]byte, Message, bool) ([]byte, error) { panic("not implemented") } |
||||
func (*InternalMessageInfo) Merge(Message, Message) { panic("not implemented") } |
||||
func (*InternalMessageInfo) Size(Message) int { panic("not implemented") } |
||||
func (*InternalMessageInfo) Unmarshal(Message, []byte) error { panic("not implemented") } |
||||
|
||||
@ -1,203 +0,0 @@ |
||||
// Go support for Protocol Buffers - Google's data interchange format
|
||||
//
|
||||
// Copyright 2010 The Go Authors. All rights reserved.
|
||||
// https://github.com/golang/protobuf
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are
|
||||
// met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following disclaimer
|
||||
// in the documentation and/or other materials provided with the
|
||||
// distribution.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
package proto |
||||
|
||||
/* |
||||
* Routines for encoding data into the wire format for protocol buffers. |
||||
*/ |
||||
|
||||
import ( |
||||
"errors" |
||||
"reflect" |
||||
) |
||||
|
||||
var ( |
||||
// errRepeatedHasNil is the error returned if Marshal is called with
|
||||
// a struct with a repeated field containing a nil element.
|
||||
errRepeatedHasNil = errors.New("proto: repeated field has nil element") |
||||
|
||||
// errOneofHasNil is the error returned if Marshal is called with
|
||||
// a struct with a oneof field containing a nil element.
|
||||
errOneofHasNil = errors.New("proto: oneof field has nil value") |
||||
|
||||
// ErrNil is the error returned if Marshal is called with nil.
|
||||
ErrNil = errors.New("proto: Marshal called with nil") |
||||
|
||||
// ErrTooLarge is the error returned if Marshal is called with a
|
||||
// message that encodes to >2GB.
|
||||
ErrTooLarge = errors.New("proto: message encodes to over 2 GB") |
||||
) |
||||
|
||||
// The fundamental encoders that put bytes on the wire.
|
||||
// Those that take integer types all accept uint64 and are
|
||||
// therefore of type valueEncoder.
|
||||
|
||||
const maxVarintBytes = 10 // maximum length of a varint
|
||||
|
||||
// EncodeVarint returns the varint encoding of x.
|
||||
// This is the format for the
|
||||
// int32, int64, uint32, uint64, bool, and enum
|
||||
// protocol buffer types.
|
||||
// Not used by the package itself, but helpful to clients
|
||||
// wishing to use the same encoding.
|
||||
func EncodeVarint(x uint64) []byte { |
||||
var buf [maxVarintBytes]byte |
||||
var n int |
||||
for n = 0; x > 127; n++ { |
||||
buf[n] = 0x80 | uint8(x&0x7F) |
||||
x >>= 7 |
||||
} |
||||
buf[n] = uint8(x) |
||||
n++ |
||||
return buf[0:n] |
||||
} |
||||
|
||||
// EncodeVarint writes a varint-encoded integer to the Buffer.
|
||||
// This is the format for the
|
||||
// int32, int64, uint32, uint64, bool, and enum
|
||||
// protocol buffer types.
|
||||
func (p *Buffer) EncodeVarint(x uint64) error { |
||||
for x >= 1<<7 { |
||||
p.buf = append(p.buf, uint8(x&0x7f|0x80)) |
||||
x >>= 7 |
||||
} |
||||
p.buf = append(p.buf, uint8(x)) |
||||
return nil |
||||
} |
||||
|
||||
// SizeVarint returns the varint encoding size of an integer.
|
||||
func SizeVarint(x uint64) int { |
||||
switch { |
||||
case x < 1<<7: |
||||
return 1 |
||||
case x < 1<<14: |
||||
return 2 |
||||
case x < 1<<21: |
||||
return 3 |
||||
case x < 1<<28: |
||||
return 4 |
||||
case x < 1<<35: |
||||
return 5 |
||||
case x < 1<<42: |
||||
return 6 |
||||
case x < 1<<49: |
||||
return 7 |
||||
case x < 1<<56: |
||||
return 8 |
||||
case x < 1<<63: |
||||
return 9 |
||||
} |
||||
return 10 |
||||
} |
||||
|
||||
// EncodeFixed64 writes a 64-bit integer to the Buffer.
|
||||
// This is the format for the
|
||||
// fixed64, sfixed64, and double protocol buffer types.
|
||||
func (p *Buffer) EncodeFixed64(x uint64) error { |
||||
p.buf = append(p.buf, |
||||
uint8(x), |
||||
uint8(x>>8), |
||||
uint8(x>>16), |
||||
uint8(x>>24), |
||||
uint8(x>>32), |
||||
uint8(x>>40), |
||||
uint8(x>>48), |
||||
uint8(x>>56)) |
||||
return nil |
||||
} |
||||
|
||||
// EncodeFixed32 writes a 32-bit integer to the Buffer.
|
||||
// This is the format for the
|
||||
// fixed32, sfixed32, and float protocol buffer types.
|
||||
func (p *Buffer) EncodeFixed32(x uint64) error { |
||||
p.buf = append(p.buf, |
||||
uint8(x), |
||||
uint8(x>>8), |
||||
uint8(x>>16), |
||||
uint8(x>>24)) |
||||
return nil |
||||
} |
||||
|
||||
// EncodeZigzag64 writes a zigzag-encoded 64-bit integer
|
||||
// to the Buffer.
|
||||
// This is the format used for the sint64 protocol buffer type.
|
||||
func (p *Buffer) EncodeZigzag64(x uint64) error { |
||||
// use signed number to get arithmetic right shift.
|
||||
return p.EncodeVarint(uint64((x << 1) ^ uint64((int64(x) >> 63)))) |
||||
} |
||||
|
||||
// EncodeZigzag32 writes a zigzag-encoded 32-bit integer
|
||||
// to the Buffer.
|
||||
// This is the format used for the sint32 protocol buffer type.
|
||||
func (p *Buffer) EncodeZigzag32(x uint64) error { |
||||
// use signed number to get arithmetic right shift.
|
||||
return p.EncodeVarint(uint64((uint32(x) << 1) ^ uint32((int32(x) >> 31)))) |
||||
} |
||||
|
||||
// EncodeRawBytes writes a count-delimited byte buffer to the Buffer.
|
||||
// This is the format used for the bytes protocol buffer
|
||||
// type and for embedded messages.
|
||||
func (p *Buffer) EncodeRawBytes(b []byte) error { |
||||
p.EncodeVarint(uint64(len(b))) |
||||
p.buf = append(p.buf, b...) |
||||
return nil |
||||
} |
||||
|
||||
// EncodeStringBytes writes an encoded string to the Buffer.
|
||||
// This is the format used for the proto2 string type.
|
||||
func (p *Buffer) EncodeStringBytes(s string) error { |
||||
p.EncodeVarint(uint64(len(s))) |
||||
p.buf = append(p.buf, s...) |
||||
return nil |
||||
} |
||||
|
||||
// Marshaler is the interface representing objects that can marshal themselves.
|
||||
type Marshaler interface { |
||||
Marshal() ([]byte, error) |
||||
} |
||||
|
||||
// EncodeMessage writes the protocol buffer to the Buffer,
|
||||
// prefixed by a varint-encoded length.
|
||||
func (p *Buffer) EncodeMessage(pb Message) error { |
||||
siz := Size(pb) |
||||
p.EncodeVarint(uint64(siz)) |
||||
return p.Marshal(pb) |
||||
} |
||||
|
||||
// All protocol buffer fields are nillable, but be careful.
|
||||
func isNil(v reflect.Value) bool { |
||||
switch v.Kind() { |
||||
case reflect.Interface, reflect.Map, reflect.Ptr, reflect.Slice: |
||||
return v.IsNil() |
||||
} |
||||
return false |
||||
} |
||||
@ -1,301 +0,0 @@ |
||||
// Go support for Protocol Buffers - Google's data interchange format
|
||||
//
|
||||
// Copyright 2011 The Go Authors. All rights reserved.
|
||||
// https://github.com/golang/protobuf
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are
|
||||
// met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following disclaimer
|
||||
// in the documentation and/or other materials provided with the
|
||||
// distribution.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
// Protocol buffer comparison.
|
||||
|
||||
package proto |
||||
|
||||
import ( |
||||
"bytes" |
||||
"log" |
||||
"reflect" |
||||
"strings" |
||||
) |
||||
|
||||
/* |
||||
Equal returns true iff protocol buffers a and b are equal. |
||||
The arguments must both be pointers to protocol buffer structs. |
||||
|
||||
Equality is defined in this way: |
||||
- Two messages are equal iff they are the same type, |
||||
corresponding fields are equal, unknown field sets |
||||
are equal, and extensions sets are equal. |
||||
- Two set scalar fields are equal iff their values are equal. |
||||
If the fields are of a floating-point type, remember that |
||||
NaN != x for all x, including NaN. If the message is defined |
||||
in a proto3 .proto file, fields are not "set"; specifically, |
||||
zero length proto3 "bytes" fields are equal (nil == {}). |
||||
- Two repeated fields are equal iff their lengths are the same, |
||||
and their corresponding elements are equal. Note a "bytes" field, |
||||
although represented by []byte, is not a repeated field and the |
||||
rule for the scalar fields described above applies. |
||||
- Two unset fields are equal. |
||||
- Two unknown field sets are equal if their current |
||||
encoded state is equal. |
||||
- Two extension sets are equal iff they have corresponding |
||||
elements that are pairwise equal. |
||||
- Two map fields are equal iff their lengths are the same, |
||||
and they contain the same set of elements. Zero-length map |
||||
fields are equal. |
||||
- Every other combination of things are not equal. |
||||
|
||||
The return value is undefined if a and b are not protocol buffers. |
||||
*/ |
||||
func Equal(a, b Message) bool { |
||||
if a == nil || b == nil { |
||||
return a == b |
||||
} |
||||
v1, v2 := reflect.ValueOf(a), reflect.ValueOf(b) |
||||
if v1.Type() != v2.Type() { |
||||
return false |
||||
} |
||||
if v1.Kind() == reflect.Ptr { |
||||
if v1.IsNil() { |
||||
return v2.IsNil() |
||||
} |
||||
if v2.IsNil() { |
||||
return false |
||||
} |
||||
v1, v2 = v1.Elem(), v2.Elem() |
||||
} |
||||
if v1.Kind() != reflect.Struct { |
||||
return false |
||||
} |
||||
return equalStruct(v1, v2) |
||||
} |
||||
|
||||
// v1 and v2 are known to have the same type.
|
||||
func equalStruct(v1, v2 reflect.Value) bool { |
||||
sprop := GetProperties(v1.Type()) |
||||
for i := 0; i < v1.NumField(); i++ { |
||||
f := v1.Type().Field(i) |
||||
if strings.HasPrefix(f.Name, "XXX_") { |
||||
continue |
||||
} |
||||
f1, f2 := v1.Field(i), v2.Field(i) |
||||
if f.Type.Kind() == reflect.Ptr { |
||||
if n1, n2 := f1.IsNil(), f2.IsNil(); n1 && n2 { |
||||
// both unset
|
||||
continue |
||||
} else if n1 != n2 { |
||||
// set/unset mismatch
|
||||
return false |
||||
} |
||||
f1, f2 = f1.Elem(), f2.Elem() |
||||
} |
||||
if !equalAny(f1, f2, sprop.Prop[i]) { |
||||
return false |
||||
} |
||||
} |
||||
|
||||
if em1 := v1.FieldByName("XXX_InternalExtensions"); em1.IsValid() { |
||||
em2 := v2.FieldByName("XXX_InternalExtensions") |
||||
if !equalExtensions(v1.Type(), em1.Interface().(XXX_InternalExtensions), em2.Interface().(XXX_InternalExtensions)) { |
||||
return false |
||||
} |
||||
} |
||||
|
||||
if em1 := v1.FieldByName("XXX_extensions"); em1.IsValid() { |
||||
em2 := v2.FieldByName("XXX_extensions") |
||||
if !equalExtMap(v1.Type(), em1.Interface().(map[int32]Extension), em2.Interface().(map[int32]Extension)) { |
||||
return false |
||||
} |
||||
} |
||||
|
||||
uf := v1.FieldByName("XXX_unrecognized") |
||||
if !uf.IsValid() { |
||||
return true |
||||
} |
||||
|
||||
u1 := uf.Bytes() |
||||
u2 := v2.FieldByName("XXX_unrecognized").Bytes() |
||||
return bytes.Equal(u1, u2) |
||||
} |
||||
|
||||
// v1 and v2 are known to have the same type.
|
||||
// prop may be nil.
|
||||
func equalAny(v1, v2 reflect.Value, prop *Properties) bool { |
||||
if v1.Type() == protoMessageType { |
||||
m1, _ := v1.Interface().(Message) |
||||
m2, _ := v2.Interface().(Message) |
||||
return Equal(m1, m2) |
||||
} |
||||
switch v1.Kind() { |
||||
case reflect.Bool: |
||||
return v1.Bool() == v2.Bool() |
||||
case reflect.Float32, reflect.Float64: |
||||
return v1.Float() == v2.Float() |
||||
case reflect.Int32, reflect.Int64: |
||||
return v1.Int() == v2.Int() |
||||
case reflect.Interface: |
||||
// Probably a oneof field; compare the inner values.
|
||||
n1, n2 := v1.IsNil(), v2.IsNil() |
||||
if n1 || n2 { |
||||
return n1 == n2 |
||||
} |
||||
e1, e2 := v1.Elem(), v2.Elem() |
||||
if e1.Type() != e2.Type() { |
||||
return false |
||||
} |
||||
return equalAny(e1, e2, nil) |
||||
case reflect.Map: |
||||
if v1.Len() != v2.Len() { |
||||
return false |
||||
} |
||||
for _, key := range v1.MapKeys() { |
||||
val2 := v2.MapIndex(key) |
||||
if !val2.IsValid() { |
||||
// This key was not found in the second map.
|
||||
return false |
||||
} |
||||
if !equalAny(v1.MapIndex(key), val2, nil) { |
||||
return false |
||||
} |
||||
} |
||||
return true |
||||
case reflect.Ptr: |
||||
// Maps may have nil values in them, so check for nil.
|
||||
if v1.IsNil() && v2.IsNil() { |
||||
return true |
||||
} |
||||
if v1.IsNil() != v2.IsNil() { |
||||
return false |
||||
} |
||||
return equalAny(v1.Elem(), v2.Elem(), prop) |
||||
case reflect.Slice: |
||||
if v1.Type().Elem().Kind() == reflect.Uint8 { |
||||
// short circuit: []byte
|
||||
|
||||
// Edge case: if this is in a proto3 message, a zero length
|
||||
// bytes field is considered the zero value.
|
||||
if prop != nil && prop.proto3 && v1.Len() == 0 && v2.Len() == 0 { |
||||
return true |
||||
} |
||||
if v1.IsNil() != v2.IsNil() { |
||||
return false |
||||
} |
||||
return bytes.Equal(v1.Interface().([]byte), v2.Interface().([]byte)) |
||||
} |
||||
|
||||
if v1.Len() != v2.Len() { |
||||
return false |
||||
} |
||||
for i := 0; i < v1.Len(); i++ { |
||||
if !equalAny(v1.Index(i), v2.Index(i), prop) { |
||||
return false |
||||
} |
||||
} |
||||
return true |
||||
case reflect.String: |
||||
return v1.Interface().(string) == v2.Interface().(string) |
||||
case reflect.Struct: |
||||
return equalStruct(v1, v2) |
||||
case reflect.Uint32, reflect.Uint64: |
||||
return v1.Uint() == v2.Uint() |
||||
} |
||||
|
||||
// unknown type, so not a protocol buffer
|
||||
log.Printf("proto: don't know how to compare %v", v1) |
||||
return false |
||||
} |
||||
|
||||
// base is the struct type that the extensions are based on.
|
||||
// x1 and x2 are InternalExtensions.
|
||||
func equalExtensions(base reflect.Type, x1, x2 XXX_InternalExtensions) bool { |
||||
em1, _ := x1.extensionsRead() |
||||
em2, _ := x2.extensionsRead() |
||||
return equalExtMap(base, em1, em2) |
||||
} |
||||
|
||||
func equalExtMap(base reflect.Type, em1, em2 map[int32]Extension) bool { |
||||
if len(em1) != len(em2) { |
||||
return false |
||||
} |
||||
|
||||
for extNum, e1 := range em1 { |
||||
e2, ok := em2[extNum] |
||||
if !ok { |
||||
return false |
||||
} |
||||
|
||||
m1 := extensionAsLegacyType(e1.value) |
||||
m2 := extensionAsLegacyType(e2.value) |
||||
|
||||
if m1 == nil && m2 == nil { |
||||
// Both have only encoded form.
|
||||
if bytes.Equal(e1.enc, e2.enc) { |
||||
continue |
||||
} |
||||
// The bytes are different, but the extensions might still be
|
||||
// equal. We need to decode them to compare.
|
||||
} |
||||
|
||||
if m1 != nil && m2 != nil { |
||||
// Both are unencoded.
|
||||
if !equalAny(reflect.ValueOf(m1), reflect.ValueOf(m2), nil) { |
||||
return false |
||||
} |
||||
continue |
||||
} |
||||
|
||||
// At least one is encoded. To do a semantically correct comparison
|
||||
// we need to unmarshal them first.
|
||||
var desc *ExtensionDesc |
||||
if m := extensionMaps[base]; m != nil { |
||||
desc = m[extNum] |
||||
} |
||||
if desc == nil { |
||||
// If both have only encoded form and the bytes are the same,
|
||||
// it is handled above. We get here when the bytes are different.
|
||||
// We don't know how to decode it, so just compare them as byte
|
||||
// slices.
|
||||
log.Printf("proto: don't know how to compare extension %d of %v", extNum, base) |
||||
return false |
||||
} |
||||
var err error |
||||
if m1 == nil { |
||||
m1, err = decodeExtension(e1.enc, desc) |
||||
} |
||||
if m2 == nil && err == nil { |
||||
m2, err = decodeExtension(e2.enc, desc) |
||||
} |
||||
if err != nil { |
||||
// The encoded form is invalid.
|
||||
log.Printf("proto: badly encoded extension %d of %v: %v", extNum, base, err) |
||||
return false |
||||
} |
||||
if !equalAny(reflect.ValueOf(m1), reflect.ValueOf(m2), nil) { |
||||
return false |
||||
} |
||||
} |
||||
|
||||
return true |
||||
} |
||||
@ -1,965 +0,0 @@ |
||||
// Go support for Protocol Buffers - Google's data interchange format
|
||||
//
|
||||
// Copyright 2010 The Go Authors. All rights reserved.
|
||||
// https://github.com/golang/protobuf
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are
|
||||
// met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following disclaimer
|
||||
// in the documentation and/or other materials provided with the
|
||||
// distribution.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
/* |
||||
Package proto converts data structures to and from the wire format of |
||||
protocol buffers. It works in concert with the Go source code generated |
||||
for .proto files by the protocol compiler. |
||||
|
||||
A summary of the properties of the protocol buffer interface |
||||
for a protocol buffer variable v: |
||||
|
||||
- Names are turned from camel_case to CamelCase for export. |
||||
- There are no methods on v to set fields; just treat |
||||
them as structure fields. |
||||
- There are getters that return a field's value if set, |
||||
and return the field's default value if unset. |
||||
The getters work even if the receiver is a nil message. |
||||
- The zero value for a struct is its correct initialization state. |
||||
All desired fields must be set before marshaling. |
||||
- A Reset() method will restore a protobuf struct to its zero state. |
||||
- Non-repeated fields are pointers to the values; nil means unset. |
||||
That is, optional or required field int32 f becomes F *int32. |
||||
- Repeated fields are slices. |
||||
- Helper functions are available to aid the setting of fields. |
||||
msg.Foo = proto.String("hello") // set field
|
||||
- Constants are defined to hold the default values of all fields that |
||||
have them. They have the form Default_StructName_FieldName. |
||||
Because the getter methods handle defaulted values, |
||||
direct use of these constants should be rare. |
||||
- Enums are given type names and maps from names to values. |
||||
Enum values are prefixed by the enclosing message's name, or by the |
||||
enum's type name if it is a top-level enum. Enum types have a String |
||||
method, and a Enum method to assist in message construction. |
||||
- Nested messages, groups and enums have type names prefixed with the name of |
||||
the surrounding message type. |
||||
- Extensions are given descriptor names that start with E_, |
||||
followed by an underscore-delimited list of the nested messages |
||||
that contain it (if any) followed by the CamelCased name of the |
||||
extension field itself. HasExtension, ClearExtension, GetExtension |
||||
and SetExtension are functions for manipulating extensions. |
||||
- Oneof field sets are given a single field in their message, |
||||
with distinguished wrapper types for each possible field value. |
||||
- Marshal and Unmarshal are functions to encode and decode the wire format. |
||||
|
||||
When the .proto file specifies `syntax="proto3"`, there are some differences: |
||||
|
||||
- Non-repeated fields of non-message type are values instead of pointers. |
||||
- Enum types do not get an Enum method. |
||||
|
||||
The simplest way to describe this is to see an example. |
||||
Given file test.proto, containing |
||||
|
||||
package example; |
||||
|
||||
enum FOO { X = 17; } |
||||
|
||||
message Test { |
||||
required string label = 1; |
||||
optional int32 type = 2 [default=77]; |
||||
repeated int64 reps = 3; |
||||
optional group OptionalGroup = 4 { |
||||
required string RequiredField = 5; |
||||
} |
||||
oneof union { |
||||
int32 number = 6; |
||||
string name = 7; |
||||
} |
||||
} |
||||
|
||||
The resulting file, test.pb.go, is: |
||||
|
||||
package example |
||||
|
||||
import proto "github.com/golang/protobuf/proto" |
||||
import math "math" |
||||
|
||||
type FOO int32 |
||||
const ( |
||||
FOO_X FOO = 17 |
||||
) |
||||
var FOO_name = map[int32]string{ |
||||
17: "X", |
||||
} |
||||
var FOO_value = map[string]int32{ |
||||
"X": 17, |
||||
} |
||||
|
||||
func (x FOO) Enum() *FOO { |
||||
p := new(FOO) |
||||
*p = x |
||||
return p |
||||
} |
||||
func (x FOO) String() string { |
||||
return proto.EnumName(FOO_name, int32(x)) |
||||
} |
||||
func (x *FOO) UnmarshalJSON(data []byte) error { |
||||
value, err := proto.UnmarshalJSONEnum(FOO_value, data) |
||||
if err != nil { |
||||
return err |
||||
} |
||||
*x = FOO(value) |
||||
return nil |
||||
} |
||||
|
||||
type Test struct { |
||||
Label *string `protobuf:"bytes,1,req,name=label" json:"label,omitempty"` |
||||
Type *int32 `protobuf:"varint,2,opt,name=type,def=77" json:"type,omitempty"` |
||||
Reps []int64 `protobuf:"varint,3,rep,name=reps" json:"reps,omitempty"` |
||||
Optionalgroup *Test_OptionalGroup `protobuf:"group,4,opt,name=OptionalGroup" json:"optionalgroup,omitempty"` |
||||
// Types that are valid to be assigned to Union:
|
||||
// *Test_Number
|
||||
// *Test_Name
|
||||
Union isTest_Union `protobuf_oneof:"union"` |
||||
XXX_unrecognized []byte `json:"-"` |
||||
} |
||||
func (m *Test) Reset() { *m = Test{} } |
||||
func (m *Test) String() string { return proto.CompactTextString(m) } |
||||
func (*Test) ProtoMessage() {} |
||||
|
||||
type isTest_Union interface { |
||||
isTest_Union() |
||||
} |
||||
|
||||
type Test_Number struct { |
||||
Number int32 `protobuf:"varint,6,opt,name=number"` |
||||
} |
||||
type Test_Name struct { |
||||
Name string `protobuf:"bytes,7,opt,name=name"` |
||||
} |
||||
|
||||
func (*Test_Number) isTest_Union() {} |
||||
func (*Test_Name) isTest_Union() {} |
||||
|
||||
func (m *Test) GetUnion() isTest_Union { |
||||
if m != nil { |
||||
return m.Union |
||||
} |
||||
return nil |
||||
} |
||||
const Default_Test_Type int32 = 77 |
||||
|
||||
func (m *Test) GetLabel() string { |
||||
if m != nil && m.Label != nil { |
||||
return *m.Label |
||||
} |
||||
return "" |
||||
} |
||||
|
||||
func (m *Test) GetType() int32 { |
||||
if m != nil && m.Type != nil { |
||||
return *m.Type |
||||
} |
||||
return Default_Test_Type |
||||
} |
||||
|
||||
func (m *Test) GetOptionalgroup() *Test_OptionalGroup { |
||||
if m != nil { |
||||
return m.Optionalgroup |
||||
} |
||||
return nil |
||||
} |
||||
|
||||
type Test_OptionalGroup struct { |
||||
RequiredField *string `protobuf:"bytes,5,req" json:"RequiredField,omitempty"` |
||||
} |
||||
func (m *Test_OptionalGroup) Reset() { *m = Test_OptionalGroup{} } |
||||
func (m *Test_OptionalGroup) String() string { return proto.CompactTextString(m) } |
||||
|
||||
func (m *Test_OptionalGroup) GetRequiredField() string { |
||||
if m != nil && m.RequiredField != nil { |
||||
return *m.RequiredField |
||||
} |
||||
return "" |
||||
} |
||||
|
||||
func (m *Test) GetNumber() int32 { |
||||
if x, ok := m.GetUnion().(*Test_Number); ok { |
||||
return x.Number |
||||
} |
||||
return 0 |
||||
} |
||||
|
||||
func (m *Test) GetName() string { |
||||
if x, ok := m.GetUnion().(*Test_Name); ok { |
||||
return x.Name |
||||
} |
||||
return "" |
||||
} |
||||
|
||||
func init() { |
||||
proto.RegisterEnum("example.FOO", FOO_name, FOO_value) |
||||
} |
||||
|
||||
To create and play with a Test object: |
||||
|
||||
package main |
||||
|
||||
import ( |
||||
"log" |
||||
|
||||
"github.com/golang/protobuf/proto" |
||||
pb "./example.pb" |
||||
) |
||||
|
||||
func main() { |
||||
test := &pb.Test{ |
||||
Label: proto.String("hello"), |
||||
Type: proto.Int32(17), |
||||
Reps: []int64{1, 2, 3}, |
||||
Optionalgroup: &pb.Test_OptionalGroup{ |
||||
RequiredField: proto.String("good bye"), |
||||
}, |
||||
Union: &pb.Test_Name{"fred"}, |
||||
} |
||||
data, err := proto.Marshal(test) |
||||
if err != nil { |
||||
log.Fatal("marshaling error: ", err) |
||||
} |
||||
newTest := &pb.Test{} |
||||
err = proto.Unmarshal(data, newTest) |
||||
if err != nil { |
||||
log.Fatal("unmarshaling error: ", err) |
||||
} |
||||
// Now test and newTest contain the same data.
|
||||
if test.GetLabel() != newTest.GetLabel() { |
||||
log.Fatalf("data mismatch %q != %q", test.GetLabel(), newTest.GetLabel()) |
||||
} |
||||
// Use a type switch to determine which oneof was set.
|
||||
switch u := test.Union.(type) { |
||||
case *pb.Test_Number: // u.Number contains the number.
|
||||
case *pb.Test_Name: // u.Name contains the string.
|
||||
} |
||||
// etc.
|
||||
} |
||||
*/ |
||||
package proto |
||||
|
||||
import ( |
||||
"encoding/json" |
||||
"fmt" |
||||
"log" |
||||
"reflect" |
||||
"sort" |
||||
"strconv" |
||||
"sync" |
||||
) |
||||
|
||||
// RequiredNotSetError is an error type returned by either Marshal or Unmarshal.
|
||||
// Marshal reports this when a required field is not initialized.
|
||||
// Unmarshal reports this when a required field is missing from the wire data.
|
||||
type RequiredNotSetError struct{ field string } |
||||
|
||||
func (e *RequiredNotSetError) Error() string { |
||||
if e.field == "" { |
||||
return fmt.Sprintf("proto: required field not set") |
||||
} |
||||
return fmt.Sprintf("proto: required field %q not set", e.field) |
||||
} |
||||
func (e *RequiredNotSetError) RequiredNotSet() bool { |
||||
return true |
||||
} |
||||
|
||||
type invalidUTF8Error struct{ field string } |
||||
|
||||
func (e *invalidUTF8Error) Error() string { |
||||
if e.field == "" { |
||||
return "proto: invalid UTF-8 detected" |
||||
} |
||||
return fmt.Sprintf("proto: field %q contains invalid UTF-8", e.field) |
||||
} |
||||
func (e *invalidUTF8Error) InvalidUTF8() bool { |
||||
return true |
||||
} |
||||
|
||||
// errInvalidUTF8 is a sentinel error to identify fields with invalid UTF-8.
|
||||
// This error should not be exposed to the external API as such errors should
|
||||
// be recreated with the field information.
|
||||
var errInvalidUTF8 = &invalidUTF8Error{} |
||||
|
||||
// isNonFatal reports whether the error is either a RequiredNotSet error
|
||||
// or a InvalidUTF8 error.
|
||||
func isNonFatal(err error) bool { |
||||
if re, ok := err.(interface{ RequiredNotSet() bool }); ok && re.RequiredNotSet() { |
||||
return true |
||||
} |
||||
if re, ok := err.(interface{ InvalidUTF8() bool }); ok && re.InvalidUTF8() { |
||||
return true |
||||
} |
||||
return false |
||||
} |
||||
|
||||
type nonFatal struct{ E error } |
||||
|
||||
// Merge merges err into nf and reports whether it was successful.
|
||||
// Otherwise it returns false for any fatal non-nil errors.
|
||||
func (nf *nonFatal) Merge(err error) (ok bool) { |
||||
if err == nil { |
||||
return true // not an error
|
||||
} |
||||
if !isNonFatal(err) { |
||||
return false // fatal error
|
||||
} |
||||
if nf.E == nil { |
||||
nf.E = err // store first instance of non-fatal error
|
||||
} |
||||
return true |
||||
} |
||||
|
||||
// Message is implemented by generated protocol buffer messages.
|
||||
type Message interface { |
||||
Reset() |
||||
String() string |
||||
ProtoMessage() |
||||
} |
||||
|
||||
// A Buffer is a buffer manager for marshaling and unmarshaling
|
||||
// protocol buffers. It may be reused between invocations to
|
||||
// reduce memory usage. It is not necessary to use a Buffer;
|
||||
// the global functions Marshal and Unmarshal create a
|
||||
// temporary Buffer and are fine for most applications.
|
||||
type Buffer struct { |
||||
buf []byte // encode/decode byte stream
|
||||
index int // read point
|
||||
|
||||
deterministic bool |
||||
} |
||||
|
||||
// NewBuffer allocates a new Buffer and initializes its internal data to
|
||||
// the contents of the argument slice.
|
||||
func NewBuffer(e []byte) *Buffer { |
||||
return &Buffer{buf: e} |
||||
} |
||||
|
||||
// Reset resets the Buffer, ready for marshaling a new protocol buffer.
|
||||
func (p *Buffer) Reset() { |
||||
p.buf = p.buf[0:0] // for reading/writing
|
||||
p.index = 0 // for reading
|
||||
} |
||||
|
||||
// SetBuf replaces the internal buffer with the slice,
|
||||
// ready for unmarshaling the contents of the slice.
|
||||
func (p *Buffer) SetBuf(s []byte) { |
||||
p.buf = s |
||||
p.index = 0 |
||||
} |
||||
|
||||
// Bytes returns the contents of the Buffer.
|
||||
func (p *Buffer) Bytes() []byte { return p.buf } |
||||
|
||||
// SetDeterministic sets whether to use deterministic serialization.
|
||||
//
|
||||
// Deterministic serialization guarantees that for a given binary, equal
|
||||
// messages will always be serialized to the same bytes. This implies:
|
||||
//
|
||||
// - Repeated serialization of a message will return the same bytes.
|
||||
// - Different processes of the same binary (which may be executing on
|
||||
// different machines) will serialize equal messages to the same bytes.
|
||||
//
|
||||
// Note that the deterministic serialization is NOT canonical across
|
||||
// languages. It is not guaranteed to remain stable over time. It is unstable
|
||||
// across different builds with schema changes due to unknown fields.
|
||||
// Users who need canonical serialization (e.g., persistent storage in a
|
||||
// canonical form, fingerprinting, etc.) should define their own
|
||||
// canonicalization specification and implement their own serializer rather
|
||||
// than relying on this API.
|
||||
//
|
||||
// If deterministic serialization is requested, map entries will be sorted
|
||||
// by keys in lexographical order. This is an implementation detail and
|
||||
// subject to change.
|
||||
func (p *Buffer) SetDeterministic(deterministic bool) { |
||||
p.deterministic = deterministic |
||||
} |
||||
|
||||
/* |
||||
* Helper routines for simplifying the creation of optional fields of basic type. |
||||
*/ |
||||
|
||||
// Bool is a helper routine that allocates a new bool value
|
||||
// to store v and returns a pointer to it.
|
||||
func Bool(v bool) *bool { |
||||
return &v |
||||
} |
||||
|
||||
// Int32 is a helper routine that allocates a new int32 value
|
||||
// to store v and returns a pointer to it.
|
||||
func Int32(v int32) *int32 { |
||||
return &v |
||||
} |
||||
|
||||
// Int is a helper routine that allocates a new int32 value
|
||||
// to store v and returns a pointer to it, but unlike Int32
|
||||
// its argument value is an int.
|
||||
func Int(v int) *int32 { |
||||
p := new(int32) |
||||
*p = int32(v) |
||||
return p |
||||
} |
||||
|
||||
// Int64 is a helper routine that allocates a new int64 value
|
||||
// to store v and returns a pointer to it.
|
||||
func Int64(v int64) *int64 { |
||||
return &v |
||||
} |
||||
|
||||
// Float32 is a helper routine that allocates a new float32 value
|
||||
// to store v and returns a pointer to it.
|
||||
func Float32(v float32) *float32 { |
||||
return &v |
||||
} |
||||
|
||||
// Float64 is a helper routine that allocates a new float64 value
|
||||
// to store v and returns a pointer to it.
|
||||
func Float64(v float64) *float64 { |
||||
return &v |
||||
} |
||||
|
||||
// Uint32 is a helper routine that allocates a new uint32 value
|
||||
// to store v and returns a pointer to it.
|
||||
func Uint32(v uint32) *uint32 { |
||||
return &v |
||||
} |
||||
|
||||
// Uint64 is a helper routine that allocates a new uint64 value
|
||||
// to store v and returns a pointer to it.
|
||||
func Uint64(v uint64) *uint64 { |
||||
return &v |
||||
} |
||||
|
||||
// String is a helper routine that allocates a new string value
|
||||
// to store v and returns a pointer to it.
|
||||
func String(v string) *string { |
||||
return &v |
||||
} |
||||
|
||||
// EnumName is a helper function to simplify printing protocol buffer enums
|
||||
// by name. Given an enum map and a value, it returns a useful string.
|
||||
func EnumName(m map[int32]string, v int32) string { |
||||
s, ok := m[v] |
||||
if ok { |
||||
return s |
||||
} |
||||
return strconv.Itoa(int(v)) |
||||
} |
||||
|
||||
// UnmarshalJSONEnum is a helper function to simplify recovering enum int values
|
||||
// from their JSON-encoded representation. Given a map from the enum's symbolic
|
||||
// names to its int values, and a byte buffer containing the JSON-encoded
|
||||
// value, it returns an int32 that can be cast to the enum type by the caller.
|
||||
//
|
||||
// The function can deal with both JSON representations, numeric and symbolic.
|
||||
func UnmarshalJSONEnum(m map[string]int32, data []byte, enumName string) (int32, error) { |
||||
if data[0] == '"' { |
||||
// New style: enums are strings.
|
||||
var repr string |
||||
if err := json.Unmarshal(data, &repr); err != nil { |
||||
return -1, err |
||||
} |
||||
val, ok := m[repr] |
||||
if !ok { |
||||
return 0, fmt.Errorf("unrecognized enum %s value %q", enumName, repr) |
||||
} |
||||
return val, nil |
||||
} |
||||
// Old style: enums are ints.
|
||||
var val int32 |
||||
if err := json.Unmarshal(data, &val); err != nil { |
||||
return 0, fmt.Errorf("cannot unmarshal %#q into enum %s", data, enumName) |
||||
} |
||||
return val, nil |
||||
} |
||||
|
||||
// DebugPrint dumps the encoded data in b in a debugging format with a header
|
||||
// including the string s. Used in testing but made available for general debugging.
|
||||
func (p *Buffer) DebugPrint(s string, b []byte) { |
||||
var u uint64 |
||||
|
||||
obuf := p.buf |
||||
index := p.index |
||||
p.buf = b |
||||
p.index = 0 |
||||
depth := 0 |
||||
|
||||
fmt.Printf("\n--- %s ---\n", s) |
||||
|
||||
out: |
||||
for { |
||||
for i := 0; i < depth; i++ { |
||||
fmt.Print(" ") |
||||
} |
||||
|
||||
index := p.index |
||||
if index == len(p.buf) { |
||||
break |
||||
} |
||||
|
||||
op, err := p.DecodeVarint() |
||||
if err != nil { |
||||
fmt.Printf("%3d: fetching op err %v\n", index, err) |
||||
break out |
||||
} |
||||
tag := op >> 3 |
||||
wire := op & 7 |
||||
|
||||
switch wire { |
||||
default: |
||||
fmt.Printf("%3d: t=%3d unknown wire=%d\n", |
||||
index, tag, wire) |
||||
break out |
||||
|
||||
case WireBytes: |
||||
var r []byte |
||||
|
||||
r, err = p.DecodeRawBytes(false) |
||||
if err != nil { |
||||
break out |
||||
} |
||||
fmt.Printf("%3d: t=%3d bytes [%d]", index, tag, len(r)) |
||||
if len(r) <= 6 { |
||||
for i := 0; i < len(r); i++ { |
||||
fmt.Printf(" %.2x", r[i]) |
||||
} |
||||
} else { |
||||
for i := 0; i < 3; i++ { |
||||
fmt.Printf(" %.2x", r[i]) |
||||
} |
||||
fmt.Printf(" ..") |
||||
for i := len(r) - 3; i < len(r); i++ { |
||||
fmt.Printf(" %.2x", r[i]) |
||||
} |
||||
} |
||||
fmt.Printf("\n") |
||||
|
||||
case WireFixed32: |
||||
u, err = p.DecodeFixed32() |
||||
if err != nil { |
||||
fmt.Printf("%3d: t=%3d fix32 err %v\n", index, tag, err) |
||||
break out |
||||
} |
||||
fmt.Printf("%3d: t=%3d fix32 %d\n", index, tag, u) |
||||
|
||||
case WireFixed64: |
||||
u, err = p.DecodeFixed64() |
||||
if err != nil { |
||||
fmt.Printf("%3d: t=%3d fix64 err %v\n", index, tag, err) |
||||
break out |
||||
} |
||||
fmt.Printf("%3d: t=%3d fix64 %d\n", index, tag, u) |
||||
|
||||
case WireVarint: |
||||
u, err = p.DecodeVarint() |
||||
if err != nil { |
||||
fmt.Printf("%3d: t=%3d varint err %v\n", index, tag, err) |
||||
break out |
||||
} |
||||
fmt.Printf("%3d: t=%3d varint %d\n", index, tag, u) |
||||
|
||||
case WireStartGroup: |
||||
fmt.Printf("%3d: t=%3d start\n", index, tag) |
||||
depth++ |
||||
|
||||
case WireEndGroup: |
||||
depth-- |
||||
fmt.Printf("%3d: t=%3d end\n", index, tag) |
||||
} |
||||
} |
||||
|
||||
if depth != 0 { |
||||
fmt.Printf("%3d: start-end not balanced %d\n", p.index, depth) |
||||
} |
||||
fmt.Printf("\n") |
||||
|
||||
p.buf = obuf |
||||
p.index = index |
||||
} |
||||
|
||||
// SetDefaults sets unset protocol buffer fields to their default values.
|
||||
// It only modifies fields that are both unset and have defined defaults.
|
||||
// It recursively sets default values in any non-nil sub-messages.
|
||||
func SetDefaults(pb Message) { |
||||
setDefaults(reflect.ValueOf(pb), true, false) |
||||
} |
||||
|
||||
// v is a pointer to a struct.
|
||||
func setDefaults(v reflect.Value, recur, zeros bool) { |
||||
v = v.Elem() |
||||
|
||||
defaultMu.RLock() |
||||
dm, ok := defaults[v.Type()] |
||||
defaultMu.RUnlock() |
||||
if !ok { |
||||
dm = buildDefaultMessage(v.Type()) |
||||
defaultMu.Lock() |
||||
defaults[v.Type()] = dm |
||||
defaultMu.Unlock() |
||||
} |
||||
|
||||
for _, sf := range dm.scalars { |
||||
f := v.Field(sf.index) |
||||
if !f.IsNil() { |
||||
// field already set
|
||||
continue |
||||
} |
||||
dv := sf.value |
||||
if dv == nil && !zeros { |
||||
// no explicit default, and don't want to set zeros
|
||||
continue |
||||
} |
||||
fptr := f.Addr().Interface() // **T
|
||||
// TODO: Consider batching the allocations we do here.
|
||||
switch sf.kind { |
||||
case reflect.Bool: |
||||
b := new(bool) |
||||
if dv != nil { |
||||
*b = dv.(bool) |
||||
} |
||||
*(fptr.(**bool)) = b |
||||
case reflect.Float32: |
||||
f := new(float32) |
||||
if dv != nil { |
||||
*f = dv.(float32) |
||||
} |
||||
*(fptr.(**float32)) = f |
||||
case reflect.Float64: |
||||
f := new(float64) |
||||
if dv != nil { |
||||
*f = dv.(float64) |
||||
} |
||||
*(fptr.(**float64)) = f |
||||
case reflect.Int32: |
||||
// might be an enum
|
||||
if ft := f.Type(); ft != int32PtrType { |
||||
// enum
|
||||
f.Set(reflect.New(ft.Elem())) |
||||
if dv != nil { |
||||
f.Elem().SetInt(int64(dv.(int32))) |
||||
} |
||||
} else { |
||||
// int32 field
|
||||
i := new(int32) |
||||
if dv != nil { |
||||
*i = dv.(int32) |
||||
} |
||||
*(fptr.(**int32)) = i |
||||
} |
||||
case reflect.Int64: |
||||
i := new(int64) |
||||
if dv != nil { |
||||
*i = dv.(int64) |
||||
} |
||||
*(fptr.(**int64)) = i |
||||
case reflect.String: |
||||
s := new(string) |
||||
if dv != nil { |
||||
*s = dv.(string) |
||||
} |
||||
*(fptr.(**string)) = s |
||||
case reflect.Uint8: |
||||
// exceptional case: []byte
|
||||
var b []byte |
||||
if dv != nil { |
||||
db := dv.([]byte) |
||||
b = make([]byte, len(db)) |
||||
copy(b, db) |
||||
} else { |
||||
b = []byte{} |
||||
} |
||||
*(fptr.(*[]byte)) = b |
||||
case reflect.Uint32: |
||||
u := new(uint32) |
||||
if dv != nil { |
||||
*u = dv.(uint32) |
||||
} |
||||
*(fptr.(**uint32)) = u |
||||
case reflect.Uint64: |
||||
u := new(uint64) |
||||
if dv != nil { |
||||
*u = dv.(uint64) |
||||
} |
||||
*(fptr.(**uint64)) = u |
||||
default: |
||||
log.Printf("proto: can't set default for field %v (sf.kind=%v)", f, sf.kind) |
||||
} |
||||
} |
||||
|
||||
for _, ni := range dm.nested { |
||||
f := v.Field(ni) |
||||
// f is *T or []*T or map[T]*T
|
||||
switch f.Kind() { |
||||
case reflect.Ptr: |
||||
if f.IsNil() { |
||||
continue |
||||
} |
||||
setDefaults(f, recur, zeros) |
||||
|
||||
case reflect.Slice: |
||||
for i := 0; i < f.Len(); i++ { |
||||
e := f.Index(i) |
||||
if e.IsNil() { |
||||
continue |
||||
} |
||||
setDefaults(e, recur, zeros) |
||||
} |
||||
|
||||
case reflect.Map: |
||||
for _, k := range f.MapKeys() { |
||||
e := f.MapIndex(k) |
||||
if e.IsNil() { |
||||
continue |
||||
} |
||||
setDefaults(e, recur, zeros) |
||||
} |
||||
} |
||||
} |
||||
} |
||||
|
||||
var ( |
||||
// defaults maps a protocol buffer struct type to a slice of the fields,
|
||||
// with its scalar fields set to their proto-declared non-zero default values.
|
||||
defaultMu sync.RWMutex |
||||
defaults = make(map[reflect.Type]defaultMessage) |
||||
|
||||
int32PtrType = reflect.TypeOf((*int32)(nil)) |
||||
) |
||||
|
||||
// defaultMessage represents information about the default values of a message.
|
||||
type defaultMessage struct { |
||||
scalars []scalarField |
||||
nested []int // struct field index of nested messages
|
||||
} |
||||
|
||||
type scalarField struct { |
||||
index int // struct field index
|
||||
kind reflect.Kind // element type (the T in *T or []T)
|
||||
value interface{} // the proto-declared default value, or nil
|
||||
} |
||||
|
||||
// t is a struct type.
|
||||
func buildDefaultMessage(t reflect.Type) (dm defaultMessage) { |
||||
sprop := GetProperties(t) |
||||
for _, prop := range sprop.Prop { |
||||
fi, ok := sprop.decoderTags.get(prop.Tag) |
||||
if !ok { |
||||
// XXX_unrecognized
|
||||
continue |
||||
} |
||||
ft := t.Field(fi).Type |
||||
|
||||
sf, nested, err := fieldDefault(ft, prop) |
||||
switch { |
||||
case err != nil: |
||||
log.Print(err) |
||||
case nested: |
||||
dm.nested = append(dm.nested, fi) |
||||
case sf != nil: |
||||
sf.index = fi |
||||
dm.scalars = append(dm.scalars, *sf) |
||||
} |
||||
} |
||||
|
||||
return dm |
||||
} |
||||
|
||||
// fieldDefault returns the scalarField for field type ft.
|
||||
// sf will be nil if the field can not have a default.
|
||||
// nestedMessage will be true if this is a nested message.
|
||||
// Note that sf.index is not set on return.
|
||||
func fieldDefault(ft reflect.Type, prop *Properties) (sf *scalarField, nestedMessage bool, err error) { |
||||
var canHaveDefault bool |
||||
switch ft.Kind() { |
||||
case reflect.Ptr: |
||||
if ft.Elem().Kind() == reflect.Struct { |
||||
nestedMessage = true |
||||
} else { |
||||
canHaveDefault = true // proto2 scalar field
|
||||
} |
||||
|
||||
case reflect.Slice: |
||||
switch ft.Elem().Kind() { |
||||
case reflect.Ptr: |
||||
nestedMessage = true // repeated message
|
||||
case reflect.Uint8: |
||||
canHaveDefault = true // bytes field
|
||||
} |
||||
|
||||
case reflect.Map: |
||||
if ft.Elem().Kind() == reflect.Ptr { |
||||
nestedMessage = true // map with message values
|
||||
} |
||||
} |
||||
|
||||
if !canHaveDefault { |
||||
if nestedMessage { |
||||
return nil, true, nil |
||||
} |
||||
return nil, false, nil |
||||
} |
||||
|
||||
// We now know that ft is a pointer or slice.
|
||||
sf = &scalarField{kind: ft.Elem().Kind()} |
||||
|
||||
// scalar fields without defaults
|
||||
if !prop.HasDefault { |
||||
return sf, false, nil |
||||
} |
||||
|
||||
// a scalar field: either *T or []byte
|
||||
switch ft.Elem().Kind() { |
||||
case reflect.Bool: |
||||
x, err := strconv.ParseBool(prop.Default) |
||||
if err != nil { |
||||
return nil, false, fmt.Errorf("proto: bad default bool %q: %v", prop.Default, err) |
||||
} |
||||
sf.value = x |
||||
case reflect.Float32: |
||||
x, err := strconv.ParseFloat(prop.Default, 32) |
||||
if err != nil { |
||||
return nil, false, fmt.Errorf("proto: bad default float32 %q: %v", prop.Default, err) |
||||
} |
||||
sf.value = float32(x) |
||||
case reflect.Float64: |
||||
x, err := strconv.ParseFloat(prop.Default, 64) |
||||
if err != nil { |
||||
return nil, false, fmt.Errorf("proto: bad default float64 %q: %v", prop.Default, err) |
||||
} |
||||
sf.value = x |
||||
case reflect.Int32: |
||||
x, err := strconv.ParseInt(prop.Default, 10, 32) |
||||
if err != nil { |
||||
return nil, false, fmt.Errorf("proto: bad default int32 %q: %v", prop.Default, err) |
||||
} |
||||
sf.value = int32(x) |
||||
case reflect.Int64: |
||||
x, err := strconv.ParseInt(prop.Default, 10, 64) |
||||
if err != nil { |
||||
return nil, false, fmt.Errorf("proto: bad default int64 %q: %v", prop.Default, err) |
||||
} |
||||
sf.value = x |
||||
case reflect.String: |
||||
sf.value = prop.Default |
||||
case reflect.Uint8: |
||||
// []byte (not *uint8)
|
||||
sf.value = []byte(prop.Default) |
||||
case reflect.Uint32: |
||||
x, err := strconv.ParseUint(prop.Default, 10, 32) |
||||
if err != nil { |
||||
return nil, false, fmt.Errorf("proto: bad default uint32 %q: %v", prop.Default, err) |
||||
} |
||||
sf.value = uint32(x) |
||||
case reflect.Uint64: |
||||
x, err := strconv.ParseUint(prop.Default, 10, 64) |
||||
if err != nil { |
||||
return nil, false, fmt.Errorf("proto: bad default uint64 %q: %v", prop.Default, err) |
||||
} |
||||
sf.value = x |
||||
default: |
||||
return nil, false, fmt.Errorf("proto: unhandled def kind %v", ft.Elem().Kind()) |
||||
} |
||||
|
||||
return sf, false, nil |
||||
} |
||||
|
||||
// mapKeys returns a sort.Interface to be used for sorting the map keys.
|
||||
// Map fields may have key types of non-float scalars, strings and enums.
|
||||
func mapKeys(vs []reflect.Value) sort.Interface { |
||||
s := mapKeySorter{vs: vs} |
||||
|
||||
// Type specialization per https://developers.google.com/protocol-buffers/docs/proto#maps.
|
||||
if len(vs) == 0 { |
||||
return s |
||||
} |
||||
switch vs[0].Kind() { |
||||
case reflect.Int32, reflect.Int64: |
||||
s.less = func(a, b reflect.Value) bool { return a.Int() < b.Int() } |
||||
case reflect.Uint32, reflect.Uint64: |
||||
s.less = func(a, b reflect.Value) bool { return a.Uint() < b.Uint() } |
||||
case reflect.Bool: |
||||
s.less = func(a, b reflect.Value) bool { return !a.Bool() && b.Bool() } // false < true
|
||||
case reflect.String: |
||||
s.less = func(a, b reflect.Value) bool { return a.String() < b.String() } |
||||
default: |
||||
panic(fmt.Sprintf("unsupported map key type: %v", vs[0].Kind())) |
||||
} |
||||
|
||||
return s |
||||
} |
||||
|
||||
type mapKeySorter struct { |
||||
vs []reflect.Value |
||||
less func(a, b reflect.Value) bool |
||||
} |
||||
|
||||
func (s mapKeySorter) Len() int { return len(s.vs) } |
||||
func (s mapKeySorter) Swap(i, j int) { s.vs[i], s.vs[j] = s.vs[j], s.vs[i] } |
||||
func (s mapKeySorter) Less(i, j int) bool { |
||||
return s.less(s.vs[i], s.vs[j]) |
||||
} |
||||
|
||||
// isProto3Zero reports whether v is a zero proto3 value.
|
||||
func isProto3Zero(v reflect.Value) bool { |
||||
switch v.Kind() { |
||||
case reflect.Bool: |
||||
return !v.Bool() |
||||
case reflect.Int32, reflect.Int64: |
||||
return v.Int() == 0 |
||||
case reflect.Uint32, reflect.Uint64: |
||||
return v.Uint() == 0 |
||||
case reflect.Float32, reflect.Float64: |
||||
return v.Float() == 0 |
||||
case reflect.String: |
||||
return v.String() == "" |
||||
} |
||||
return false |
||||
} |
||||
|
||||
const ( |
||||
// ProtoPackageIsVersion3 is referenced from generated protocol buffer files
|
||||
// to assert that that code is compatible with this version of the proto package.
|
||||
ProtoPackageIsVersion3 = true |
||||
|
||||
// ProtoPackageIsVersion2 is referenced from generated protocol buffer files
|
||||
// to assert that that code is compatible with this version of the proto package.
|
||||
ProtoPackageIsVersion2 = true |
||||
|
||||
// ProtoPackageIsVersion1 is referenced from generated protocol buffer files
|
||||
// to assert that that code is compatible with this version of the proto package.
|
||||
ProtoPackageIsVersion1 = true |
||||
) |
||||
|
||||
// InternalMessageInfo is a type used internally by generated .pb.go files.
|
||||
// This type is not intended to be used by non-generated code.
|
||||
// This type is not subject to any compatibility guarantee.
|
||||
type InternalMessageInfo struct { |
||||
marshal *marshalInfo |
||||
unmarshal *unmarshalInfo |
||||
merge *mergeInfo |
||||
discard *discardInfo |
||||
} |
||||
@ -1,181 +0,0 @@ |
||||
// Go support for Protocol Buffers - Google's data interchange format
|
||||
//
|
||||
// Copyright 2010 The Go Authors. All rights reserved.
|
||||
// https://github.com/golang/protobuf
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are
|
||||
// met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following disclaimer
|
||||
// in the documentation and/or other materials provided with the
|
||||
// distribution.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
package proto |
||||
|
||||
/* |
||||
* Support for message sets. |
||||
*/ |
||||
|
||||
import ( |
||||
"errors" |
||||
) |
||||
|
||||
// errNoMessageTypeID occurs when a protocol buffer does not have a message type ID.
|
||||
// A message type ID is required for storing a protocol buffer in a message set.
|
||||
var errNoMessageTypeID = errors.New("proto does not have a message type ID") |
||||
|
||||
// The first two types (_MessageSet_Item and messageSet)
|
||||
// model what the protocol compiler produces for the following protocol message:
|
||||
// message MessageSet {
|
||||
// repeated group Item = 1 {
|
||||
// required int32 type_id = 2;
|
||||
// required string message = 3;
|
||||
// };
|
||||
// }
|
||||
// That is the MessageSet wire format. We can't use a proto to generate these
|
||||
// because that would introduce a circular dependency between it and this package.
|
||||
|
||||
type _MessageSet_Item struct { |
||||
TypeId *int32 `protobuf:"varint,2,req,name=type_id"` |
||||
Message []byte `protobuf:"bytes,3,req,name=message"` |
||||
} |
||||
|
||||
type messageSet struct { |
||||
Item []*_MessageSet_Item `protobuf:"group,1,rep"` |
||||
XXX_unrecognized []byte |
||||
// TODO: caching?
|
||||
} |
||||
|
||||
// Make sure messageSet is a Message.
|
||||
var _ Message = (*messageSet)(nil) |
||||
|
||||
// messageTypeIder is an interface satisfied by a protocol buffer type
|
||||
// that may be stored in a MessageSet.
|
||||
type messageTypeIder interface { |
||||
MessageTypeId() int32 |
||||
} |
||||
|
||||
func (ms *messageSet) find(pb Message) *_MessageSet_Item { |
||||
mti, ok := pb.(messageTypeIder) |
||||
if !ok { |
||||
return nil |
||||
} |
||||
id := mti.MessageTypeId() |
||||
for _, item := range ms.Item { |
||||
if *item.TypeId == id { |
||||
return item |
||||
} |
||||
} |
||||
return nil |
||||
} |
||||
|
||||
func (ms *messageSet) Has(pb Message) bool { |
||||
return ms.find(pb) != nil |
||||
} |
||||
|
||||
func (ms *messageSet) Unmarshal(pb Message) error { |
||||
if item := ms.find(pb); item != nil { |
||||
return Unmarshal(item.Message, pb) |
||||
} |
||||
if _, ok := pb.(messageTypeIder); !ok { |
||||
return errNoMessageTypeID |
||||
} |
||||
return nil // TODO: return error instead?
|
||||
} |
||||
|
||||
func (ms *messageSet) Marshal(pb Message) error { |
||||
msg, err := Marshal(pb) |
||||
if err != nil { |
||||
return err |
||||
} |
||||
if item := ms.find(pb); item != nil { |
||||
// reuse existing item
|
||||
item.Message = msg |
||||
return nil |
||||
} |
||||
|
||||
mti, ok := pb.(messageTypeIder) |
||||
if !ok { |
||||
return errNoMessageTypeID |
||||
} |
||||
|
||||
mtid := mti.MessageTypeId() |
||||
ms.Item = append(ms.Item, &_MessageSet_Item{ |
||||
TypeId: &mtid, |
||||
Message: msg, |
||||
}) |
||||
return nil |
||||
} |
||||
|
||||
func (ms *messageSet) Reset() { *ms = messageSet{} } |
||||
func (ms *messageSet) String() string { return CompactTextString(ms) } |
||||
func (*messageSet) ProtoMessage() {} |
||||
|
||||
// Support for the message_set_wire_format message option.
|
||||
|
||||
func skipVarint(buf []byte) []byte { |
||||
i := 0 |
||||
for ; buf[i]&0x80 != 0; i++ { |
||||
} |
||||
return buf[i+1:] |
||||
} |
||||
|
||||
// unmarshalMessageSet decodes the extension map encoded in buf in the message set wire format.
|
||||
// It is called by Unmarshal methods on protocol buffer messages with the message_set_wire_format option.
|
||||
func unmarshalMessageSet(buf []byte, exts interface{}) error { |
||||
var m map[int32]Extension |
||||
switch exts := exts.(type) { |
||||
case *XXX_InternalExtensions: |
||||
m = exts.extensionsWrite() |
||||
case map[int32]Extension: |
||||
m = exts |
||||
default: |
||||
return errors.New("proto: not an extension map") |
||||
} |
||||
|
||||
ms := new(messageSet) |
||||
if err := Unmarshal(buf, ms); err != nil { |
||||
return err |
||||
} |
||||
for _, item := range ms.Item { |
||||
id := *item.TypeId |
||||
msg := item.Message |
||||
|
||||
// Restore wire type and field number varint, plus length varint.
|
||||
// Be careful to preserve duplicate items.
|
||||
b := EncodeVarint(uint64(id)<<3 | WireBytes) |
||||
if ext, ok := m[id]; ok { |
||||
// Existing data; rip off the tag and length varint
|
||||
// so we join the new data correctly.
|
||||
// We can assume that ext.enc is set because we are unmarshaling.
|
||||
o := ext.enc[len(b):] // skip wire type and field number
|
||||
_, n := DecodeVarint(o) // calculate length of length varint
|
||||
o = o[n:] // skip length varint
|
||||
msg = append(o, msg...) // join old data and new data
|
||||
} |
||||
b = append(b, EncodeVarint(uint64(len(msg)))...) |
||||
b = append(b, msg...) |
||||
|
||||
m[id] = Extension{enc: b} |
||||
} |
||||
return nil |
||||
} |
||||
@ -1,360 +0,0 @@ |
||||
// Go support for Protocol Buffers - Google's data interchange format
|
||||
//
|
||||
// Copyright 2012 The Go Authors. All rights reserved.
|
||||
// https://github.com/golang/protobuf
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are
|
||||
// met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following disclaimer
|
||||
// in the documentation and/or other materials provided with the
|
||||
// distribution.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
// +build purego appengine js
|
||||
|
||||
// This file contains an implementation of proto field accesses using package reflect.
|
||||
// It is slower than the code in pointer_unsafe.go but it avoids package unsafe and can
|
||||
// be used on App Engine.
|
||||
|
||||
package proto |
||||
|
||||
import ( |
||||
"reflect" |
||||
"sync" |
||||
) |
||||
|
||||
const unsafeAllowed = false |
||||
|
||||
// A field identifies a field in a struct, accessible from a pointer.
|
||||
// In this implementation, a field is identified by the sequence of field indices
|
||||
// passed to reflect's FieldByIndex.
|
||||
type field []int |
||||
|
||||
// toField returns a field equivalent to the given reflect field.
|
||||
func toField(f *reflect.StructField) field { |
||||
return f.Index |
||||
} |
||||
|
||||
// invalidField is an invalid field identifier.
|
||||
var invalidField = field(nil) |
||||
|
||||
// zeroField is a noop when calling pointer.offset.
|
||||
var zeroField = field([]int{}) |
||||
|
||||
// IsValid reports whether the field identifier is valid.
|
||||
func (f field) IsValid() bool { return f != nil } |
||||
|
||||
// The pointer type is for the table-driven decoder.
|
||||
// The implementation here uses a reflect.Value of pointer type to
|
||||
// create a generic pointer. In pointer_unsafe.go we use unsafe
|
||||
// instead of reflect to implement the same (but faster) interface.
|
||||
type pointer struct { |
||||
v reflect.Value |
||||
} |
||||
|
||||
// toPointer converts an interface of pointer type to a pointer
|
||||
// that points to the same target.
|
||||
func toPointer(i *Message) pointer { |
||||
return pointer{v: reflect.ValueOf(*i)} |
||||
} |
||||
|
||||
// toAddrPointer converts an interface to a pointer that points to
|
||||
// the interface data.
|
||||
func toAddrPointer(i *interface{}, isptr, deref bool) pointer { |
||||
v := reflect.ValueOf(*i) |
||||
u := reflect.New(v.Type()) |
||||
u.Elem().Set(v) |
||||
if deref { |
||||
u = u.Elem() |
||||
} |
||||
return pointer{v: u} |
||||
} |
||||
|
||||
// valToPointer converts v to a pointer. v must be of pointer type.
|
||||
func valToPointer(v reflect.Value) pointer { |
||||
return pointer{v: v} |
||||
} |
||||
|
||||
// offset converts from a pointer to a structure to a pointer to
|
||||
// one of its fields.
|
||||
func (p pointer) offset(f field) pointer { |
||||
return pointer{v: p.v.Elem().FieldByIndex(f).Addr()} |
||||
} |
||||
|
||||
func (p pointer) isNil() bool { |
||||
return p.v.IsNil() |
||||
} |
||||
|
||||
// grow updates the slice s in place to make it one element longer.
|
||||
// s must be addressable.
|
||||
// Returns the (addressable) new element.
|
||||
func grow(s reflect.Value) reflect.Value { |
||||
n, m := s.Len(), s.Cap() |
||||
if n < m { |
||||
s.SetLen(n + 1) |
||||
} else { |
||||
s.Set(reflect.Append(s, reflect.Zero(s.Type().Elem()))) |
||||
} |
||||
return s.Index(n) |
||||
} |
||||
|
||||
func (p pointer) toInt64() *int64 { |
||||
return p.v.Interface().(*int64) |
||||
} |
||||
func (p pointer) toInt64Ptr() **int64 { |
||||
return p.v.Interface().(**int64) |
||||
} |
||||
func (p pointer) toInt64Slice() *[]int64 { |
||||
return p.v.Interface().(*[]int64) |
||||
} |
||||
|
||||
var int32ptr = reflect.TypeOf((*int32)(nil)) |
||||
|
||||
func (p pointer) toInt32() *int32 { |
||||
return p.v.Convert(int32ptr).Interface().(*int32) |
||||
} |
||||
|
||||
// The toInt32Ptr/Slice methods don't work because of enums.
|
||||
// Instead, we must use set/get methods for the int32ptr/slice case.
|
||||
/* |
||||
func (p pointer) toInt32Ptr() **int32 { |
||||
return p.v.Interface().(**int32) |
||||
} |
||||
func (p pointer) toInt32Slice() *[]int32 { |
||||
return p.v.Interface().(*[]int32) |
||||
} |
||||
*/ |
||||
func (p pointer) getInt32Ptr() *int32 { |
||||
if p.v.Type().Elem().Elem() == reflect.TypeOf(int32(0)) { |
||||
// raw int32 type
|
||||
return p.v.Elem().Interface().(*int32) |
||||
} |
||||
// an enum
|
||||
return p.v.Elem().Convert(int32PtrType).Interface().(*int32) |
||||
} |
||||
func (p pointer) setInt32Ptr(v int32) { |
||||
// Allocate value in a *int32. Possibly convert that to a *enum.
|
||||
// Then assign it to a **int32 or **enum.
|
||||
// Note: we can convert *int32 to *enum, but we can't convert
|
||||
// **int32 to **enum!
|
||||
p.v.Elem().Set(reflect.ValueOf(&v).Convert(p.v.Type().Elem())) |
||||
} |
||||
|
||||
// getInt32Slice copies []int32 from p as a new slice.
|
||||
// This behavior differs from the implementation in pointer_unsafe.go.
|
||||
func (p pointer) getInt32Slice() []int32 { |
||||
if p.v.Type().Elem().Elem() == reflect.TypeOf(int32(0)) { |
||||
// raw int32 type
|
||||
return p.v.Elem().Interface().([]int32) |
||||
} |
||||
// an enum
|
||||
// Allocate a []int32, then assign []enum's values into it.
|
||||
// Note: we can't convert []enum to []int32.
|
||||
slice := p.v.Elem() |
||||
s := make([]int32, slice.Len()) |
||||
for i := 0; i < slice.Len(); i++ { |
||||
s[i] = int32(slice.Index(i).Int()) |
||||
} |
||||
return s |
||||
} |
||||
|
||||
// setInt32Slice copies []int32 into p as a new slice.
|
||||
// This behavior differs from the implementation in pointer_unsafe.go.
|
||||
func (p pointer) setInt32Slice(v []int32) { |
||||
if p.v.Type().Elem().Elem() == reflect.TypeOf(int32(0)) { |
||||
// raw int32 type
|
||||
p.v.Elem().Set(reflect.ValueOf(v)) |
||||
return |
||||
} |
||||
// an enum
|
||||
// Allocate a []enum, then assign []int32's values into it.
|
||||
// Note: we can't convert []enum to []int32.
|
||||
slice := reflect.MakeSlice(p.v.Type().Elem(), len(v), cap(v)) |
||||
for i, x := range v { |
||||
slice.Index(i).SetInt(int64(x)) |
||||
} |
||||
p.v.Elem().Set(slice) |
||||
} |
||||
func (p pointer) appendInt32Slice(v int32) { |
||||
grow(p.v.Elem()).SetInt(int64(v)) |
||||
} |
||||
|
||||
func (p pointer) toUint64() *uint64 { |
||||
return p.v.Interface().(*uint64) |
||||
} |
||||
func (p pointer) toUint64Ptr() **uint64 { |
||||
return p.v.Interface().(**uint64) |
||||
} |
||||
func (p pointer) toUint64Slice() *[]uint64 { |
||||
return p.v.Interface().(*[]uint64) |
||||
} |
||||
func (p pointer) toUint32() *uint32 { |
||||
return p.v.Interface().(*uint32) |
||||
} |
||||
func (p pointer) toUint32Ptr() **uint32 { |
||||
return p.v.Interface().(**uint32) |
||||
} |
||||
func (p pointer) toUint32Slice() *[]uint32 { |
||||
return p.v.Interface().(*[]uint32) |
||||
} |
||||
func (p pointer) toBool() *bool { |
||||
return p.v.Interface().(*bool) |
||||
} |
||||
func (p pointer) toBoolPtr() **bool { |
||||
return p.v.Interface().(**bool) |
||||
} |
||||
func (p pointer) toBoolSlice() *[]bool { |
||||
return p.v.Interface().(*[]bool) |
||||
} |
||||
func (p pointer) toFloat64() *float64 { |
||||
return p.v.Interface().(*float64) |
||||
} |
||||
func (p pointer) toFloat64Ptr() **float64 { |
||||
return p.v.Interface().(**float64) |
||||
} |
||||
func (p pointer) toFloat64Slice() *[]float64 { |
||||
return p.v.Interface().(*[]float64) |
||||
} |
||||
func (p pointer) toFloat32() *float32 { |
||||
return p.v.Interface().(*float32) |
||||
} |
||||
func (p pointer) toFloat32Ptr() **float32 { |
||||
return p.v.Interface().(**float32) |
||||
} |
||||
func (p pointer) toFloat32Slice() *[]float32 { |
||||
return p.v.Interface().(*[]float32) |
||||
} |
||||
func (p pointer) toString() *string { |
||||
return p.v.Interface().(*string) |
||||
} |
||||
func (p pointer) toStringPtr() **string { |
||||
return p.v.Interface().(**string) |
||||
} |
||||
func (p pointer) toStringSlice() *[]string { |
||||
return p.v.Interface().(*[]string) |
||||
} |
||||
func (p pointer) toBytes() *[]byte { |
||||
return p.v.Interface().(*[]byte) |
||||
} |
||||
func (p pointer) toBytesSlice() *[][]byte { |
||||
return p.v.Interface().(*[][]byte) |
||||
} |
||||
func (p pointer) toExtensions() *XXX_InternalExtensions { |
||||
return p.v.Interface().(*XXX_InternalExtensions) |
||||
} |
||||
func (p pointer) toOldExtensions() *map[int32]Extension { |
||||
return p.v.Interface().(*map[int32]Extension) |
||||
} |
||||
func (p pointer) getPointer() pointer { |
||||
return pointer{v: p.v.Elem()} |
||||
} |
||||
func (p pointer) setPointer(q pointer) { |
||||
p.v.Elem().Set(q.v) |
||||
} |
||||
func (p pointer) appendPointer(q pointer) { |
||||
grow(p.v.Elem()).Set(q.v) |
||||
} |
||||
|
||||
// getPointerSlice copies []*T from p as a new []pointer.
|
||||
// This behavior differs from the implementation in pointer_unsafe.go.
|
||||
func (p pointer) getPointerSlice() []pointer { |
||||
if p.v.IsNil() { |
||||
return nil |
||||
} |
||||
n := p.v.Elem().Len() |
||||
s := make([]pointer, n) |
||||
for i := 0; i < n; i++ { |
||||
s[i] = pointer{v: p.v.Elem().Index(i)} |
||||
} |
||||
return s |
||||
} |
||||
|
||||
// setPointerSlice copies []pointer into p as a new []*T.
|
||||
// This behavior differs from the implementation in pointer_unsafe.go.
|
||||
func (p pointer) setPointerSlice(v []pointer) { |
||||
if v == nil { |
||||
p.v.Elem().Set(reflect.New(p.v.Elem().Type()).Elem()) |
||||
return |
||||
} |
||||
s := reflect.MakeSlice(p.v.Elem().Type(), 0, len(v)) |
||||
for _, p := range v { |
||||
s = reflect.Append(s, p.v) |
||||
} |
||||
p.v.Elem().Set(s) |
||||
} |
||||
|
||||
// getInterfacePointer returns a pointer that points to the
|
||||
// interface data of the interface pointed by p.
|
||||
func (p pointer) getInterfacePointer() pointer { |
||||
if p.v.Elem().IsNil() { |
||||
return pointer{v: p.v.Elem()} |
||||
} |
||||
return pointer{v: p.v.Elem().Elem().Elem().Field(0).Addr()} // *interface -> interface -> *struct -> struct
|
||||
} |
||||
|
||||
func (p pointer) asPointerTo(t reflect.Type) reflect.Value { |
||||
// TODO: check that p.v.Type().Elem() == t?
|
||||
return p.v |
||||
} |
||||
|
||||
func atomicLoadUnmarshalInfo(p **unmarshalInfo) *unmarshalInfo { |
||||
atomicLock.Lock() |
||||
defer atomicLock.Unlock() |
||||
return *p |
||||
} |
||||
func atomicStoreUnmarshalInfo(p **unmarshalInfo, v *unmarshalInfo) { |
||||
atomicLock.Lock() |
||||
defer atomicLock.Unlock() |
||||
*p = v |
||||
} |
||||
func atomicLoadMarshalInfo(p **marshalInfo) *marshalInfo { |
||||
atomicLock.Lock() |
||||
defer atomicLock.Unlock() |
||||
return *p |
||||
} |
||||
func atomicStoreMarshalInfo(p **marshalInfo, v *marshalInfo) { |
||||
atomicLock.Lock() |
||||
defer atomicLock.Unlock() |
||||
*p = v |
||||
} |
||||
func atomicLoadMergeInfo(p **mergeInfo) *mergeInfo { |
||||
atomicLock.Lock() |
||||
defer atomicLock.Unlock() |
||||
return *p |
||||
} |
||||
func atomicStoreMergeInfo(p **mergeInfo, v *mergeInfo) { |
||||
atomicLock.Lock() |
||||
defer atomicLock.Unlock() |
||||
*p = v |
||||
} |
||||
func atomicLoadDiscardInfo(p **discardInfo) *discardInfo { |
||||
atomicLock.Lock() |
||||
defer atomicLock.Unlock() |
||||
return *p |
||||
} |
||||
func atomicStoreDiscardInfo(p **discardInfo, v *discardInfo) { |
||||
atomicLock.Lock() |
||||
defer atomicLock.Unlock() |
||||
*p = v |
||||
} |
||||
|
||||
var atomicLock sync.Mutex |
||||
@ -1,313 +0,0 @@ |
||||
// Go support for Protocol Buffers - Google's data interchange format
|
||||
//
|
||||
// Copyright 2012 The Go Authors. All rights reserved.
|
||||
// https://github.com/golang/protobuf
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are
|
||||
// met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following disclaimer
|
||||
// in the documentation and/or other materials provided with the
|
||||
// distribution.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
// +build !purego,!appengine,!js
|
||||
|
||||
// This file contains the implementation of the proto field accesses using package unsafe.
|
||||
|
||||
package proto |
||||
|
||||
import ( |
||||
"reflect" |
||||
"sync/atomic" |
||||
"unsafe" |
||||
) |
||||
|
||||
const unsafeAllowed = true |
||||
|
||||
// A field identifies a field in a struct, accessible from a pointer.
|
||||
// In this implementation, a field is identified by its byte offset from the start of the struct.
|
||||
type field uintptr |
||||
|
||||
// toField returns a field equivalent to the given reflect field.
|
||||
func toField(f *reflect.StructField) field { |
||||
return field(f.Offset) |
||||
} |
||||
|
||||
// invalidField is an invalid field identifier.
|
||||
const invalidField = ^field(0) |
||||
|
||||
// zeroField is a noop when calling pointer.offset.
|
||||
const zeroField = field(0) |
||||
|
||||
// IsValid reports whether the field identifier is valid.
|
||||
func (f field) IsValid() bool { |
||||
return f != invalidField |
||||
} |
||||
|
||||
// The pointer type below is for the new table-driven encoder/decoder.
|
||||
// The implementation here uses unsafe.Pointer to create a generic pointer.
|
||||
// In pointer_reflect.go we use reflect instead of unsafe to implement
|
||||
// the same (but slower) interface.
|
||||
type pointer struct { |
||||
p unsafe.Pointer |
||||
} |
||||
|
||||
// size of pointer
|
||||
var ptrSize = unsafe.Sizeof(uintptr(0)) |
||||
|
||||
// toPointer converts an interface of pointer type to a pointer
|
||||
// that points to the same target.
|
||||
func toPointer(i *Message) pointer { |
||||
// Super-tricky - read pointer out of data word of interface value.
|
||||
// Saves ~25ns over the equivalent:
|
||||
// return valToPointer(reflect.ValueOf(*i))
|
||||
return pointer{p: (*[2]unsafe.Pointer)(unsafe.Pointer(i))[1]} |
||||
} |
||||
|
||||
// toAddrPointer converts an interface to a pointer that points to
|
||||
// the interface data.
|
||||
func toAddrPointer(i *interface{}, isptr, deref bool) (p pointer) { |
||||
// Super-tricky - read or get the address of data word of interface value.
|
||||
if isptr { |
||||
// The interface is of pointer type, thus it is a direct interface.
|
||||
// The data word is the pointer data itself. We take its address.
|
||||
p = pointer{p: unsafe.Pointer(uintptr(unsafe.Pointer(i)) + ptrSize)} |
||||
} else { |
||||
// The interface is not of pointer type. The data word is the pointer
|
||||
// to the data.
|
||||
p = pointer{p: (*[2]unsafe.Pointer)(unsafe.Pointer(i))[1]} |
||||
} |
||||
if deref { |
||||
p.p = *(*unsafe.Pointer)(p.p) |
||||
} |
||||
return p |
||||
} |
||||
|
||||
// valToPointer converts v to a pointer. v must be of pointer type.
|
||||
func valToPointer(v reflect.Value) pointer { |
||||
return pointer{p: unsafe.Pointer(v.Pointer())} |
||||
} |
||||
|
||||
// offset converts from a pointer to a structure to a pointer to
|
||||
// one of its fields.
|
||||
func (p pointer) offset(f field) pointer { |
||||
// For safety, we should panic if !f.IsValid, however calling panic causes
|
||||
// this to no longer be inlineable, which is a serious performance cost.
|
||||
/* |
||||
if !f.IsValid() { |
||||
panic("invalid field") |
||||
} |
||||
*/ |
||||
return pointer{p: unsafe.Pointer(uintptr(p.p) + uintptr(f))} |
||||
} |
||||
|
||||
func (p pointer) isNil() bool { |
||||
return p.p == nil |
||||
} |
||||
|
||||
func (p pointer) toInt64() *int64 { |
||||
return (*int64)(p.p) |
||||
} |
||||
func (p pointer) toInt64Ptr() **int64 { |
||||
return (**int64)(p.p) |
||||
} |
||||
func (p pointer) toInt64Slice() *[]int64 { |
||||
return (*[]int64)(p.p) |
||||
} |
||||
func (p pointer) toInt32() *int32 { |
||||
return (*int32)(p.p) |
||||
} |
||||
|
||||
// See pointer_reflect.go for why toInt32Ptr/Slice doesn't exist.
|
||||
/* |
||||
func (p pointer) toInt32Ptr() **int32 { |
||||
return (**int32)(p.p) |
||||
} |
||||
func (p pointer) toInt32Slice() *[]int32 { |
||||
return (*[]int32)(p.p) |
||||
} |
||||
*/ |
||||
func (p pointer) getInt32Ptr() *int32 { |
||||
return *(**int32)(p.p) |
||||
} |
||||
func (p pointer) setInt32Ptr(v int32) { |
||||
*(**int32)(p.p) = &v |
||||
} |
||||
|
||||
// getInt32Slice loads a []int32 from p.
|
||||
// The value returned is aliased with the original slice.
|
||||
// This behavior differs from the implementation in pointer_reflect.go.
|
||||
func (p pointer) getInt32Slice() []int32 { |
||||
return *(*[]int32)(p.p) |
||||
} |
||||
|
||||
// setInt32Slice stores a []int32 to p.
|
||||
// The value set is aliased with the input slice.
|
||||
// This behavior differs from the implementation in pointer_reflect.go.
|
||||
func (p pointer) setInt32Slice(v []int32) { |
||||
*(*[]int32)(p.p) = v |
||||
} |
||||
|
||||
// TODO: Can we get rid of appendInt32Slice and use setInt32Slice instead?
|
||||
func (p pointer) appendInt32Slice(v int32) { |
||||
s := (*[]int32)(p.p) |
||||
*s = append(*s, v) |
||||
} |
||||
|
||||
func (p pointer) toUint64() *uint64 { |
||||
return (*uint64)(p.p) |
||||
} |
||||
func (p pointer) toUint64Ptr() **uint64 { |
||||
return (**uint64)(p.p) |
||||
} |
||||
func (p pointer) toUint64Slice() *[]uint64 { |
||||
return (*[]uint64)(p.p) |
||||
} |
||||
func (p pointer) toUint32() *uint32 { |
||||
return (*uint32)(p.p) |
||||
} |
||||
func (p pointer) toUint32Ptr() **uint32 { |
||||
return (**uint32)(p.p) |
||||
} |
||||
func (p pointer) toUint32Slice() *[]uint32 { |
||||
return (*[]uint32)(p.p) |
||||
} |
||||
func (p pointer) toBool() *bool { |
||||
return (*bool)(p.p) |
||||
} |
||||
func (p pointer) toBoolPtr() **bool { |
||||
return (**bool)(p.p) |
||||
} |
||||
func (p pointer) toBoolSlice() *[]bool { |
||||
return (*[]bool)(p.p) |
||||
} |
||||
func (p pointer) toFloat64() *float64 { |
||||
return (*float64)(p.p) |
||||
} |
||||
func (p pointer) toFloat64Ptr() **float64 { |
||||
return (**float64)(p.p) |
||||
} |
||||
func (p pointer) toFloat64Slice() *[]float64 { |
||||
return (*[]float64)(p.p) |
||||
} |
||||
func (p pointer) toFloat32() *float32 { |
||||
return (*float32)(p.p) |
||||
} |
||||
func (p pointer) toFloat32Ptr() **float32 { |
||||
return (**float32)(p.p) |
||||
} |
||||
func (p pointer) toFloat32Slice() *[]float32 { |
||||
return (*[]float32)(p.p) |
||||
} |
||||
func (p pointer) toString() *string { |
||||
return (*string)(p.p) |
||||
} |
||||
func (p pointer) toStringPtr() **string { |
||||
return (**string)(p.p) |
||||
} |
||||
func (p pointer) toStringSlice() *[]string { |
||||
return (*[]string)(p.p) |
||||
} |
||||
func (p pointer) toBytes() *[]byte { |
||||
return (*[]byte)(p.p) |
||||
} |
||||
func (p pointer) toBytesSlice() *[][]byte { |
||||
return (*[][]byte)(p.p) |
||||
} |
||||
func (p pointer) toExtensions() *XXX_InternalExtensions { |
||||
return (*XXX_InternalExtensions)(p.p) |
||||
} |
||||
func (p pointer) toOldExtensions() *map[int32]Extension { |
||||
return (*map[int32]Extension)(p.p) |
||||
} |
||||
|
||||
// getPointerSlice loads []*T from p as a []pointer.
|
||||
// The value returned is aliased with the original slice.
|
||||
// This behavior differs from the implementation in pointer_reflect.go.
|
||||
func (p pointer) getPointerSlice() []pointer { |
||||
// Super-tricky - p should point to a []*T where T is a
|
||||
// message type. We load it as []pointer.
|
||||
return *(*[]pointer)(p.p) |
||||
} |
||||
|
||||
// setPointerSlice stores []pointer into p as a []*T.
|
||||
// The value set is aliased with the input slice.
|
||||
// This behavior differs from the implementation in pointer_reflect.go.
|
||||
func (p pointer) setPointerSlice(v []pointer) { |
||||
// Super-tricky - p should point to a []*T where T is a
|
||||
// message type. We store it as []pointer.
|
||||
*(*[]pointer)(p.p) = v |
||||
} |
||||
|
||||
// getPointer loads the pointer at p and returns it.
|
||||
func (p pointer) getPointer() pointer { |
||||
return pointer{p: *(*unsafe.Pointer)(p.p)} |
||||
} |
||||
|
||||
// setPointer stores the pointer q at p.
|
||||
func (p pointer) setPointer(q pointer) { |
||||
*(*unsafe.Pointer)(p.p) = q.p |
||||
} |
||||
|
||||
// append q to the slice pointed to by p.
|
||||
func (p pointer) appendPointer(q pointer) { |
||||
s := (*[]unsafe.Pointer)(p.p) |
||||
*s = append(*s, q.p) |
||||
} |
||||
|
||||
// getInterfacePointer returns a pointer that points to the
|
||||
// interface data of the interface pointed by p.
|
||||
func (p pointer) getInterfacePointer() pointer { |
||||
// Super-tricky - read pointer out of data word of interface value.
|
||||
return pointer{p: (*(*[2]unsafe.Pointer)(p.p))[1]} |
||||
} |
||||
|
||||
// asPointerTo returns a reflect.Value that is a pointer to an
|
||||
// object of type t stored at p.
|
||||
func (p pointer) asPointerTo(t reflect.Type) reflect.Value { |
||||
return reflect.NewAt(t, p.p) |
||||
} |
||||
|
||||
func atomicLoadUnmarshalInfo(p **unmarshalInfo) *unmarshalInfo { |
||||
return (*unmarshalInfo)(atomic.LoadPointer((*unsafe.Pointer)(unsafe.Pointer(p)))) |
||||
} |
||||
func atomicStoreUnmarshalInfo(p **unmarshalInfo, v *unmarshalInfo) { |
||||
atomic.StorePointer((*unsafe.Pointer)(unsafe.Pointer(p)), unsafe.Pointer(v)) |
||||
} |
||||
func atomicLoadMarshalInfo(p **marshalInfo) *marshalInfo { |
||||
return (*marshalInfo)(atomic.LoadPointer((*unsafe.Pointer)(unsafe.Pointer(p)))) |
||||
} |
||||
func atomicStoreMarshalInfo(p **marshalInfo, v *marshalInfo) { |
||||
atomic.StorePointer((*unsafe.Pointer)(unsafe.Pointer(p)), unsafe.Pointer(v)) |
||||
} |
||||
func atomicLoadMergeInfo(p **mergeInfo) *mergeInfo { |
||||
return (*mergeInfo)(atomic.LoadPointer((*unsafe.Pointer)(unsafe.Pointer(p)))) |
||||
} |
||||
func atomicStoreMergeInfo(p **mergeInfo, v *mergeInfo) { |
||||
atomic.StorePointer((*unsafe.Pointer)(unsafe.Pointer(p)), unsafe.Pointer(v)) |
||||
} |
||||
func atomicLoadDiscardInfo(p **discardInfo) *discardInfo { |
||||
return (*discardInfo)(atomic.LoadPointer((*unsafe.Pointer)(unsafe.Pointer(p)))) |
||||
} |
||||
func atomicStoreDiscardInfo(p **discardInfo, v *discardInfo) { |
||||
atomic.StorePointer((*unsafe.Pointer)(unsafe.Pointer(p)), unsafe.Pointer(v)) |
||||
} |
||||
@ -0,0 +1,167 @@ |
||||
// Copyright 2019 The Go Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
// Package proto provides functionality for handling protocol buffer messages.
|
||||
// In particular, it provides marshaling and unmarshaling between a protobuf
|
||||
// message and the binary wire format.
|
||||
//
|
||||
// See https://developers.google.com/protocol-buffers/docs/gotutorial for
|
||||
// more information.
|
||||
//
|
||||
// Deprecated: Use the "google.golang.org/protobuf/proto" package instead.
|
||||
package proto |
||||
|
||||
import ( |
||||
protoV2 "google.golang.org/protobuf/proto" |
||||
"google.golang.org/protobuf/reflect/protoreflect" |
||||
"google.golang.org/protobuf/runtime/protoiface" |
||||
"google.golang.org/protobuf/runtime/protoimpl" |
||||
) |
||||
|
||||
const ( |
||||
ProtoPackageIsVersion1 = true |
||||
ProtoPackageIsVersion2 = true |
||||
ProtoPackageIsVersion3 = true |
||||
ProtoPackageIsVersion4 = true |
||||
) |
||||
|
||||
// GeneratedEnum is any enum type generated by protoc-gen-go
|
||||
// which is a named int32 kind.
|
||||
// This type exists for documentation purposes.
|
||||
type GeneratedEnum interface{} |
||||
|
||||
// GeneratedMessage is any message type generated by protoc-gen-go
|
||||
// which is a pointer to a named struct kind.
|
||||
// This type exists for documentation purposes.
|
||||
type GeneratedMessage interface{} |
||||
|
||||
// Message is a protocol buffer message.
|
||||
//
|
||||
// This is the v1 version of the message interface and is marginally better
|
||||
// than an empty interface as it lacks any method to programatically interact
|
||||
// with the contents of the message.
|
||||
//
|
||||
// A v2 message is declared in "google.golang.org/protobuf/proto".Message and
|
||||
// exposes protobuf reflection as a first-class feature of the interface.
|
||||
//
|
||||
// To convert a v1 message to a v2 message, use the MessageV2 function.
|
||||
// To convert a v2 message to a v1 message, use the MessageV1 function.
|
||||
type Message = protoiface.MessageV1 |
||||
|
||||
// MessageV1 converts either a v1 or v2 message to a v1 message.
|
||||
// It returns nil if m is nil.
|
||||
func MessageV1(m GeneratedMessage) protoiface.MessageV1 { |
||||
return protoimpl.X.ProtoMessageV1Of(m) |
||||
} |
||||
|
||||
// MessageV2 converts either a v1 or v2 message to a v2 message.
|
||||
// It returns nil if m is nil.
|
||||
func MessageV2(m GeneratedMessage) protoV2.Message { |
||||
return protoimpl.X.ProtoMessageV2Of(m) |
||||
} |
||||
|
||||
// MessageReflect returns a reflective view for a message.
|
||||
// It returns nil if m is nil.
|
||||
func MessageReflect(m Message) protoreflect.Message { |
||||
return protoimpl.X.MessageOf(m) |
||||
} |
||||
|
||||
// Marshaler is implemented by messages that can marshal themselves.
|
||||
// This interface is used by the following functions: Size, Marshal,
|
||||
// Buffer.Marshal, and Buffer.EncodeMessage.
|
||||
//
|
||||
// Deprecated: Do not implement.
|
||||
type Marshaler interface { |
||||
// Marshal formats the encoded bytes of the message.
|
||||
// It should be deterministic and emit valid protobuf wire data.
|
||||
// The caller takes ownership of the returned buffer.
|
||||
Marshal() ([]byte, error) |
||||
} |
||||
|
||||
// Unmarshaler is implemented by messages that can unmarshal themselves.
|
||||
// This interface is used by the following functions: Unmarshal, UnmarshalMerge,
|
||||
// Buffer.Unmarshal, Buffer.DecodeMessage, and Buffer.DecodeGroup.
|
||||
//
|
||||
// Deprecated: Do not implement.
|
||||
type Unmarshaler interface { |
||||
// Unmarshal parses the encoded bytes of the protobuf wire input.
|
||||
// The provided buffer is only valid for during method call.
|
||||
// It should not reset the receiver message.
|
||||
Unmarshal([]byte) error |
||||
} |
||||
|
||||
// Merger is implemented by messages that can merge themselves.
|
||||
// This interface is used by the following functions: Clone and Merge.
|
||||
//
|
||||
// Deprecated: Do not implement.
|
||||
type Merger interface { |
||||
// Merge merges the contents of src into the receiver message.
|
||||
// It clones all data structures in src such that it aliases no mutable
|
||||
// memory referenced by src.
|
||||
Merge(src Message) |
||||
} |
||||
|
||||
// RequiredNotSetError is an error type returned when
|
||||
// marshaling or unmarshaling a message with missing required fields.
|
||||
type RequiredNotSetError struct { |
||||
err error |
||||
} |
||||
|
||||
func (e *RequiredNotSetError) Error() string { |
||||
if e.err != nil { |
||||
return e.err.Error() |
||||
} |
||||
return "proto: required field not set" |
||||
} |
||||
func (e *RequiredNotSetError) RequiredNotSet() bool { |
||||
return true |
||||
} |
||||
|
||||
func checkRequiredNotSet(m protoV2.Message) error { |
||||
if err := protoV2.CheckInitialized(m); err != nil { |
||||
return &RequiredNotSetError{err: err} |
||||
} |
||||
return nil |
||||
} |
||||
|
||||
// Clone returns a deep copy of src.
|
||||
func Clone(src Message) Message { |
||||
return MessageV1(protoV2.Clone(MessageV2(src))) |
||||
} |
||||
|
||||
// Merge merges src into dst, which must be messages of the same type.
|
||||
//
|
||||
// Populated scalar fields in src are copied to dst, while populated
|
||||
// singular messages in src are merged into dst by recursively calling Merge.
|
||||
// The elements of every list field in src is appended to the corresponded
|
||||
// list fields in dst. The entries of every map field in src is copied into
|
||||
// the corresponding map field in dst, possibly replacing existing entries.
|
||||
// The unknown fields of src are appended to the unknown fields of dst.
|
||||
func Merge(dst, src Message) { |
||||
protoV2.Merge(MessageV2(dst), MessageV2(src)) |
||||
} |
||||
|
||||
// Equal reports whether two messages are equal.
|
||||
// If two messages marshal to the same bytes under deterministic serialization,
|
||||
// then Equal is guaranteed to report true.
|
||||
//
|
||||
// Two messages are equal if they are the same protobuf message type,
|
||||
// have the same set of populated known and extension field values,
|
||||
// and the same set of unknown fields values.
|
||||
//
|
||||
// Scalar values are compared with the equivalent of the == operator in Go,
|
||||
// except bytes values which are compared using bytes.Equal and
|
||||
// floating point values which specially treat NaNs as equal.
|
||||
// Message values are compared by recursively calling Equal.
|
||||
// Lists are equal if each element value is also equal.
|
||||
// Maps are equal if they have the same set of keys, where the pair of values
|
||||
// for each key is also equal.
|
||||
func Equal(x, y Message) bool { |
||||
return protoV2.Equal(MessageV2(x), MessageV2(y)) |
||||
} |
||||
|
||||
func isMessageSet(md protoreflect.MessageDescriptor) bool { |
||||
ms, ok := md.(interface{ IsMessageSet() bool }) |
||||
return ok && ms.IsMessageSet() |
||||
} |
||||
@ -0,0 +1,323 @@ |
||||
// Copyright 2019 The Go Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
package proto |
||||
|
||||
import ( |
||||
"bytes" |
||||
"compress/gzip" |
||||
"fmt" |
||||
"io/ioutil" |
||||
"reflect" |
||||
"strings" |
||||
"sync" |
||||
|
||||
"google.golang.org/protobuf/reflect/protoreflect" |
||||
"google.golang.org/protobuf/reflect/protoregistry" |
||||
"google.golang.org/protobuf/runtime/protoimpl" |
||||
) |
||||
|
||||
// filePath is the path to the proto source file.
|
||||
type filePath = string // e.g., "google/protobuf/descriptor.proto"
|
||||
|
||||
// fileDescGZIP is the compressed contents of the encoded FileDescriptorProto.
|
||||
type fileDescGZIP = []byte |
||||
|
||||
var fileCache sync.Map // map[filePath]fileDescGZIP
|
||||
|
||||
// RegisterFile is called from generated code to register the compressed
|
||||
// FileDescriptorProto with the file path for a proto source file.
|
||||
//
|
||||
// Deprecated: Use protoregistry.GlobalFiles.Register instead.
|
||||
func RegisterFile(s filePath, d fileDescGZIP) { |
||||
// Decompress the descriptor.
|
||||
zr, err := gzip.NewReader(bytes.NewReader(d)) |
||||
if err != nil { |
||||
panic(fmt.Sprintf("proto: invalid compressed file descriptor: %v", err)) |
||||
} |
||||
b, err := ioutil.ReadAll(zr) |
||||
if err != nil { |
||||
panic(fmt.Sprintf("proto: invalid compressed file descriptor: %v", err)) |
||||
} |
||||
|
||||
// Construct a protoreflect.FileDescriptor from the raw descriptor.
|
||||
// Note that DescBuilder.Build automatically registers the constructed
|
||||
// file descriptor with the v2 registry.
|
||||
protoimpl.DescBuilder{RawDescriptor: b}.Build() |
||||
|
||||
// Locally cache the raw descriptor form for the file.
|
||||
fileCache.Store(s, d) |
||||
} |
||||
|
||||
// FileDescriptor returns the compressed FileDescriptorProto given the file path
|
||||
// for a proto source file. It returns nil if not found.
|
||||
//
|
||||
// Deprecated: Use protoregistry.GlobalFiles.RangeFilesByPath instead.
|
||||
func FileDescriptor(s filePath) fileDescGZIP { |
||||
if v, ok := fileCache.Load(s); ok { |
||||
return v.(fileDescGZIP) |
||||
} |
||||
|
||||
// Find the descriptor in the v2 registry.
|
||||
var b []byte |
||||
if fd, _ := protoregistry.GlobalFiles.FindFileByPath(s); fd != nil { |
||||
if fd, ok := fd.(interface{ ProtoLegacyRawDesc() []byte }); ok { |
||||
b = fd.ProtoLegacyRawDesc() |
||||
} else { |
||||
// TODO: Use protodesc.ToFileDescriptorProto to construct
|
||||
// a descriptorpb.FileDescriptorProto and marshal it.
|
||||
// However, doing so causes the proto package to have a dependency
|
||||
// on descriptorpb, leading to cyclic dependency issues.
|
||||
} |
||||
} |
||||
|
||||
// Locally cache the raw descriptor form for the file.
|
||||
if len(b) > 0 { |
||||
v, _ := fileCache.LoadOrStore(s, protoimpl.X.CompressGZIP(b)) |
||||
return v.(fileDescGZIP) |
||||
} |
||||
return nil |
||||
} |
||||
|
||||
// enumName is the name of an enum. For historical reasons, the enum name is
|
||||
// neither the full Go name nor the full protobuf name of the enum.
|
||||
// The name is the dot-separated combination of just the proto package that the
|
||||
// enum is declared within followed by the Go type name of the generated enum.
|
||||
type enumName = string // e.g., "my.proto.package.GoMessage_GoEnum"
|
||||
|
||||
// enumsByName maps enum values by name to their numeric counterpart.
|
||||
type enumsByName = map[string]int32 |
||||
|
||||
// enumsByNumber maps enum values by number to their name counterpart.
|
||||
type enumsByNumber = map[int32]string |
||||
|
||||
var enumCache sync.Map // map[enumName]enumsByName
|
||||
var numFilesCache sync.Map // map[protoreflect.FullName]int
|
||||
|
||||
// RegisterEnum is called from the generated code to register the mapping of
|
||||
// enum value names to enum numbers for the enum identified by s.
|
||||
//
|
||||
// Deprecated: Use protoregistry.GlobalTypes.Register instead.
|
||||
func RegisterEnum(s enumName, _ enumsByNumber, m enumsByName) { |
||||
if _, ok := enumCache.Load(s); ok { |
||||
panic("proto: duplicate enum registered: " + s) |
||||
} |
||||
enumCache.Store(s, m) |
||||
|
||||
// This does not forward registration to the v2 registry since this API
|
||||
// lacks sufficient information to construct a complete v2 enum descriptor.
|
||||
} |
||||
|
||||
// EnumValueMap returns the mapping from enum value names to enum numbers for
|
||||
// the enum of the given name. It returns nil if not found.
|
||||
//
|
||||
// Deprecated: Use protoregistry.GlobalTypes.FindEnumByName instead.
|
||||
func EnumValueMap(s enumName) enumsByName { |
||||
if v, ok := enumCache.Load(s); ok { |
||||
return v.(enumsByName) |
||||
} |
||||
|
||||
// Check whether the cache is stale. If the number of files in the current
|
||||
// package differs, then it means that some enums may have been recently
|
||||
// registered upstream that we do not know about.
|
||||
var protoPkg protoreflect.FullName |
||||
if i := strings.LastIndexByte(s, '.'); i >= 0 { |
||||
protoPkg = protoreflect.FullName(s[:i]) |
||||
} |
||||
v, _ := numFilesCache.Load(protoPkg) |
||||
numFiles, _ := v.(int) |
||||
if protoregistry.GlobalFiles.NumFilesByPackage(protoPkg) == numFiles { |
||||
return nil // cache is up-to-date; was not found earlier
|
||||
} |
||||
|
||||
// Update the enum cache for all enums declared in the given proto package.
|
||||
numFiles = 0 |
||||
protoregistry.GlobalFiles.RangeFilesByPackage(protoPkg, func(fd protoreflect.FileDescriptor) bool { |
||||
walkEnums(fd, func(ed protoreflect.EnumDescriptor) { |
||||
name := protoimpl.X.LegacyEnumName(ed) |
||||
if _, ok := enumCache.Load(name); !ok { |
||||
m := make(enumsByName) |
||||
evs := ed.Values() |
||||
for i := evs.Len() - 1; i >= 0; i-- { |
||||
ev := evs.Get(i) |
||||
m[string(ev.Name())] = int32(ev.Number()) |
||||
} |
||||
enumCache.LoadOrStore(name, m) |
||||
} |
||||
}) |
||||
numFiles++ |
||||
return true |
||||
}) |
||||
numFilesCache.Store(protoPkg, numFiles) |
||||
|
||||
// Check cache again for enum map.
|
||||
if v, ok := enumCache.Load(s); ok { |
||||
return v.(enumsByName) |
||||
} |
||||
return nil |
||||
} |
||||
|
||||
// walkEnums recursively walks all enums declared in d.
|
||||
func walkEnums(d interface { |
||||
Enums() protoreflect.EnumDescriptors |
||||
Messages() protoreflect.MessageDescriptors |
||||
}, f func(protoreflect.EnumDescriptor)) { |
||||
eds := d.Enums() |
||||
for i := eds.Len() - 1; i >= 0; i-- { |
||||
f(eds.Get(i)) |
||||
} |
||||
mds := d.Messages() |
||||
for i := mds.Len() - 1; i >= 0; i-- { |
||||
walkEnums(mds.Get(i), f) |
||||
} |
||||
} |
||||
|
||||
// messageName is the full name of protobuf message.
|
||||
type messageName = string |
||||
|
||||
var messageTypeCache sync.Map // map[messageName]reflect.Type
|
||||
|
||||
// RegisterType is called from generated code to register the message Go type
|
||||
// for a message of the given name.
|
||||
//
|
||||
// Deprecated: Use protoregistry.GlobalTypes.Register instead.
|
||||
func RegisterType(m Message, s messageName) { |
||||
mt := protoimpl.X.LegacyMessageTypeOf(m, protoreflect.FullName(s)) |
||||
if err := protoregistry.GlobalTypes.RegisterMessage(mt); err != nil { |
||||
panic(err) |
||||
} |
||||
messageTypeCache.Store(s, reflect.TypeOf(m)) |
||||
} |
||||
|
||||
// RegisterMapType is called from generated code to register the Go map type
|
||||
// for a protobuf message representing a map entry.
|
||||
//
|
||||
// Deprecated: Do not use.
|
||||
func RegisterMapType(m interface{}, s messageName) { |
||||
t := reflect.TypeOf(m) |
||||
if t.Kind() != reflect.Map { |
||||
panic(fmt.Sprintf("invalid map kind: %v", t)) |
||||
} |
||||
if _, ok := messageTypeCache.Load(s); ok { |
||||
panic(fmt.Errorf("proto: duplicate proto message registered: %s", s)) |
||||
} |
||||
messageTypeCache.Store(s, t) |
||||
} |
||||
|
||||
// MessageType returns the message type for a named message.
|
||||
// It returns nil if not found.
|
||||
//
|
||||
// Deprecated: Use protoregistry.GlobalTypes.FindMessageByName instead.
|
||||
func MessageType(s messageName) reflect.Type { |
||||
if v, ok := messageTypeCache.Load(s); ok { |
||||
return v.(reflect.Type) |
||||
} |
||||
|
||||
// Derive the message type from the v2 registry.
|
||||
var t reflect.Type |
||||
if mt, _ := protoregistry.GlobalTypes.FindMessageByName(protoreflect.FullName(s)); mt != nil { |
||||
t = messageGoType(mt) |
||||
} |
||||
|
||||
// If we could not get a concrete type, it is possible that it is a
|
||||
// pseudo-message for a map entry.
|
||||
if t == nil { |
||||
d, _ := protoregistry.GlobalFiles.FindDescriptorByName(protoreflect.FullName(s)) |
||||
if md, _ := d.(protoreflect.MessageDescriptor); md != nil && md.IsMapEntry() { |
||||
kt := goTypeForField(md.Fields().ByNumber(1)) |
||||
vt := goTypeForField(md.Fields().ByNumber(2)) |
||||
t = reflect.MapOf(kt, vt) |
||||
} |
||||
} |
||||
|
||||
// Locally cache the message type for the given name.
|
||||
if t != nil { |
||||
v, _ := messageTypeCache.LoadOrStore(s, t) |
||||
return v.(reflect.Type) |
||||
} |
||||
return nil |
||||
} |
||||
|
||||
func goTypeForField(fd protoreflect.FieldDescriptor) reflect.Type { |
||||
switch k := fd.Kind(); k { |
||||
case protoreflect.EnumKind: |
||||
if et, _ := protoregistry.GlobalTypes.FindEnumByName(fd.Enum().FullName()); et != nil { |
||||
return enumGoType(et) |
||||
} |
||||
return reflect.TypeOf(protoreflect.EnumNumber(0)) |
||||
case protoreflect.MessageKind, protoreflect.GroupKind: |
||||
if mt, _ := protoregistry.GlobalTypes.FindMessageByName(fd.Message().FullName()); mt != nil { |
||||
return messageGoType(mt) |
||||
} |
||||
return reflect.TypeOf((*protoreflect.Message)(nil)).Elem() |
||||
default: |
||||
return reflect.TypeOf(fd.Default().Interface()) |
||||
} |
||||
} |
||||
|
||||
func enumGoType(et protoreflect.EnumType) reflect.Type { |
||||
return reflect.TypeOf(et.New(0)) |
||||
} |
||||
|
||||
func messageGoType(mt protoreflect.MessageType) reflect.Type { |
||||
return reflect.TypeOf(MessageV1(mt.Zero().Interface())) |
||||
} |
||||
|
||||
// MessageName returns the full protobuf name for the given message type.
|
||||
//
|
||||
// Deprecated: Use protoreflect.MessageDescriptor.FullName instead.
|
||||
func MessageName(m Message) messageName { |
||||
if m == nil { |
||||
return "" |
||||
} |
||||
if m, ok := m.(interface{ XXX_MessageName() messageName }); ok { |
||||
return m.XXX_MessageName() |
||||
} |
||||
return messageName(protoimpl.X.MessageDescriptorOf(m).FullName()) |
||||
} |
||||
|
||||
// RegisterExtension is called from the generated code to register
|
||||
// the extension descriptor.
|
||||
//
|
||||
// Deprecated: Use protoregistry.GlobalTypes.Register instead.
|
||||
func RegisterExtension(d *ExtensionDesc) { |
||||
if err := protoregistry.GlobalTypes.RegisterExtension(d); err != nil { |
||||
panic(err) |
||||
} |
||||
} |
||||
|
||||
type extensionsByNumber = map[int32]*ExtensionDesc |
||||
|
||||
var extensionCache sync.Map // map[messageName]extensionsByNumber
|
||||
|
||||
// RegisteredExtensions returns a map of the registered extensions for the
|
||||
// provided protobuf message, indexed by the extension field number.
|
||||
//
|
||||
// Deprecated: Use protoregistry.GlobalTypes.RangeExtensionsByMessage instead.
|
||||
func RegisteredExtensions(m Message) extensionsByNumber { |
||||
// Check whether the cache is stale. If the number of extensions for
|
||||
// the given message differs, then it means that some extensions were
|
||||
// recently registered upstream that we do not know about.
|
||||
s := MessageName(m) |
||||
v, _ := extensionCache.Load(s) |
||||
xs, _ := v.(extensionsByNumber) |
||||
if protoregistry.GlobalTypes.NumExtensionsByMessage(protoreflect.FullName(s)) == len(xs) { |
||||
return xs // cache is up-to-date
|
||||
} |
||||
|
||||
// Cache is stale, re-compute the extensions map.
|
||||
xs = make(extensionsByNumber) |
||||
protoregistry.GlobalTypes.RangeExtensionsByMessage(protoreflect.FullName(s), func(xt protoreflect.ExtensionType) bool { |
||||
if xd, ok := xt.(*ExtensionDesc); ok { |
||||
xs[int32(xt.TypeDescriptor().Number())] = xd |
||||
} else { |
||||
// TODO: This implies that the protoreflect.ExtensionType is a
|
||||
// custom type not generated by protoc-gen-go. We could try and
|
||||
// convert the type to an ExtensionDesc.
|
||||
} |
||||
return true |
||||
}) |
||||
extensionCache.Store(s, xs) |
||||
return xs |
||||
} |
||||
File diff suppressed because it is too large
Load Diff
@ -1,654 +0,0 @@ |
||||
// Go support for Protocol Buffers - Google's data interchange format
|
||||
//
|
||||
// Copyright 2016 The Go Authors. All rights reserved.
|
||||
// https://github.com/golang/protobuf
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are
|
||||
// met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following disclaimer
|
||||
// in the documentation and/or other materials provided with the
|
||||
// distribution.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
package proto |
||||
|
||||
import ( |
||||
"fmt" |
||||
"reflect" |
||||
"strings" |
||||
"sync" |
||||
"sync/atomic" |
||||
) |
||||
|
||||
// Merge merges the src message into dst.
|
||||
// This assumes that dst and src of the same type and are non-nil.
|
||||
func (a *InternalMessageInfo) Merge(dst, src Message) { |
||||
mi := atomicLoadMergeInfo(&a.merge) |
||||
if mi == nil { |
||||
mi = getMergeInfo(reflect.TypeOf(dst).Elem()) |
||||
atomicStoreMergeInfo(&a.merge, mi) |
||||
} |
||||
mi.merge(toPointer(&dst), toPointer(&src)) |
||||
} |
||||
|
||||
type mergeInfo struct { |
||||
typ reflect.Type |
||||
|
||||
initialized int32 // 0: only typ is valid, 1: everything is valid
|
||||
lock sync.Mutex |
||||
|
||||
fields []mergeFieldInfo |
||||
unrecognized field // Offset of XXX_unrecognized
|
||||
} |
||||
|
||||
type mergeFieldInfo struct { |
||||
field field // Offset of field, guaranteed to be valid
|
||||
|
||||
// isPointer reports whether the value in the field is a pointer.
|
||||
// This is true for the following situations:
|
||||
// * Pointer to struct
|
||||
// * Pointer to basic type (proto2 only)
|
||||
// * Slice (first value in slice header is a pointer)
|
||||
// * String (first value in string header is a pointer)
|
||||
isPointer bool |
||||
|
||||
// basicWidth reports the width of the field assuming that it is directly
|
||||
// embedded in the struct (as is the case for basic types in proto3).
|
||||
// The possible values are:
|
||||
// 0: invalid
|
||||
// 1: bool
|
||||
// 4: int32, uint32, float32
|
||||
// 8: int64, uint64, float64
|
||||
basicWidth int |
||||
|
||||
// Where dst and src are pointers to the types being merged.
|
||||
merge func(dst, src pointer) |
||||
} |
||||
|
||||
var ( |
||||
mergeInfoMap = map[reflect.Type]*mergeInfo{} |
||||
mergeInfoLock sync.Mutex |
||||
) |
||||
|
||||
func getMergeInfo(t reflect.Type) *mergeInfo { |
||||
mergeInfoLock.Lock() |
||||
defer mergeInfoLock.Unlock() |
||||
mi := mergeInfoMap[t] |
||||
if mi == nil { |
||||
mi = &mergeInfo{typ: t} |
||||
mergeInfoMap[t] = mi |
||||
} |
||||
return mi |
||||
} |
||||
|
||||
// merge merges src into dst assuming they are both of type *mi.typ.
|
||||
func (mi *mergeInfo) merge(dst, src pointer) { |
||||
if dst.isNil() { |
||||
panic("proto: nil destination") |
||||
} |
||||
if src.isNil() { |
||||
return // Nothing to do.
|
||||
} |
||||
|
||||
if atomic.LoadInt32(&mi.initialized) == 0 { |
||||
mi.computeMergeInfo() |
||||
} |
||||
|
||||
for _, fi := range mi.fields { |
||||
sfp := src.offset(fi.field) |
||||
|
||||
// As an optimization, we can avoid the merge function call cost
|
||||
// if we know for sure that the source will have no effect
|
||||
// by checking if it is the zero value.
|
||||
if unsafeAllowed { |
||||
if fi.isPointer && sfp.getPointer().isNil() { // Could be slice or string
|
||||
continue |
||||
} |
||||
if fi.basicWidth > 0 { |
||||
switch { |
||||
case fi.basicWidth == 1 && !*sfp.toBool(): |
||||
continue |
||||
case fi.basicWidth == 4 && *sfp.toUint32() == 0: |
||||
continue |
||||
case fi.basicWidth == 8 && *sfp.toUint64() == 0: |
||||
continue |
||||
} |
||||
} |
||||
} |
||||
|
||||
dfp := dst.offset(fi.field) |
||||
fi.merge(dfp, sfp) |
||||
} |
||||
|
||||
// TODO: Make this faster?
|
||||
out := dst.asPointerTo(mi.typ).Elem() |
||||
in := src.asPointerTo(mi.typ).Elem() |
||||
if emIn, err := extendable(in.Addr().Interface()); err == nil { |
||||
emOut, _ := extendable(out.Addr().Interface()) |
||||
mIn, muIn := emIn.extensionsRead() |
||||
if mIn != nil { |
||||
mOut := emOut.extensionsWrite() |
||||
muIn.Lock() |
||||
mergeExtension(mOut, mIn) |
||||
muIn.Unlock() |
||||
} |
||||
} |
||||
|
||||
if mi.unrecognized.IsValid() { |
||||
if b := *src.offset(mi.unrecognized).toBytes(); len(b) > 0 { |
||||
*dst.offset(mi.unrecognized).toBytes() = append([]byte(nil), b...) |
||||
} |
||||
} |
||||
} |
||||
|
||||
func (mi *mergeInfo) computeMergeInfo() { |
||||
mi.lock.Lock() |
||||
defer mi.lock.Unlock() |
||||
if mi.initialized != 0 { |
||||
return |
||||
} |
||||
t := mi.typ |
||||
n := t.NumField() |
||||
|
||||
props := GetProperties(t) |
||||
for i := 0; i < n; i++ { |
||||
f := t.Field(i) |
||||
if strings.HasPrefix(f.Name, "XXX_") { |
||||
continue |
||||
} |
||||
|
||||
mfi := mergeFieldInfo{field: toField(&f)} |
||||
tf := f.Type |
||||
|
||||
// As an optimization, we can avoid the merge function call cost
|
||||
// if we know for sure that the source will have no effect
|
||||
// by checking if it is the zero value.
|
||||
if unsafeAllowed { |
||||
switch tf.Kind() { |
||||
case reflect.Ptr, reflect.Slice, reflect.String: |
||||
// As a special case, we assume slices and strings are pointers
|
||||
// since we know that the first field in the SliceSlice or
|
||||
// StringHeader is a data pointer.
|
||||
mfi.isPointer = true |
||||
case reflect.Bool: |
||||
mfi.basicWidth = 1 |
||||
case reflect.Int32, reflect.Uint32, reflect.Float32: |
||||
mfi.basicWidth = 4 |
||||
case reflect.Int64, reflect.Uint64, reflect.Float64: |
||||
mfi.basicWidth = 8 |
||||
} |
||||
} |
||||
|
||||
// Unwrap tf to get at its most basic type.
|
||||
var isPointer, isSlice bool |
||||
if tf.Kind() == reflect.Slice && tf.Elem().Kind() != reflect.Uint8 { |
||||
isSlice = true |
||||
tf = tf.Elem() |
||||
} |
||||
if tf.Kind() == reflect.Ptr { |
||||
isPointer = true |
||||
tf = tf.Elem() |
||||
} |
||||
if isPointer && isSlice && tf.Kind() != reflect.Struct { |
||||
panic("both pointer and slice for basic type in " + tf.Name()) |
||||
} |
||||
|
||||
switch tf.Kind() { |
||||
case reflect.Int32: |
||||
switch { |
||||
case isSlice: // E.g., []int32
|
||||
mfi.merge = func(dst, src pointer) { |
||||
// NOTE: toInt32Slice is not defined (see pointer_reflect.go).
|
||||
/* |
||||
sfsp := src.toInt32Slice() |
||||
if *sfsp != nil { |
||||
dfsp := dst.toInt32Slice() |
||||
*dfsp = append(*dfsp, *sfsp...) |
||||
if *dfsp == nil { |
||||
*dfsp = []int64{} |
||||
} |
||||
} |
||||
*/ |
||||
sfs := src.getInt32Slice() |
||||
if sfs != nil { |
||||
dfs := dst.getInt32Slice() |
||||
dfs = append(dfs, sfs...) |
||||
if dfs == nil { |
||||
dfs = []int32{} |
||||
} |
||||
dst.setInt32Slice(dfs) |
||||
} |
||||
} |
||||
case isPointer: // E.g., *int32
|
||||
mfi.merge = func(dst, src pointer) { |
||||
// NOTE: toInt32Ptr is not defined (see pointer_reflect.go).
|
||||
/* |
||||
sfpp := src.toInt32Ptr() |
||||
if *sfpp != nil { |
||||
dfpp := dst.toInt32Ptr() |
||||
if *dfpp == nil { |
||||
*dfpp = Int32(**sfpp) |
||||
} else { |
||||
**dfpp = **sfpp |
||||
} |
||||
} |
||||
*/ |
||||
sfp := src.getInt32Ptr() |
||||
if sfp != nil { |
||||
dfp := dst.getInt32Ptr() |
||||
if dfp == nil { |
||||
dst.setInt32Ptr(*sfp) |
||||
} else { |
||||
*dfp = *sfp |
||||
} |
||||
} |
||||
} |
||||
default: // E.g., int32
|
||||
mfi.merge = func(dst, src pointer) { |
||||
if v := *src.toInt32(); v != 0 { |
||||
*dst.toInt32() = v |
||||
} |
||||
} |
||||
} |
||||
case reflect.Int64: |
||||
switch { |
||||
case isSlice: // E.g., []int64
|
||||
mfi.merge = func(dst, src pointer) { |
||||
sfsp := src.toInt64Slice() |
||||
if *sfsp != nil { |
||||
dfsp := dst.toInt64Slice() |
||||
*dfsp = append(*dfsp, *sfsp...) |
||||
if *dfsp == nil { |
||||
*dfsp = []int64{} |
||||
} |
||||
} |
||||
} |
||||
case isPointer: // E.g., *int64
|
||||
mfi.merge = func(dst, src pointer) { |
||||
sfpp := src.toInt64Ptr() |
||||
if *sfpp != nil { |
||||
dfpp := dst.toInt64Ptr() |
||||
if *dfpp == nil { |
||||
*dfpp = Int64(**sfpp) |
||||
} else { |
||||
**dfpp = **sfpp |
||||
} |
||||
} |
||||
} |
||||
default: // E.g., int64
|
||||
mfi.merge = func(dst, src pointer) { |
||||
if v := *src.toInt64(); v != 0 { |
||||
*dst.toInt64() = v |
||||
} |
||||
} |
||||
} |
||||
case reflect.Uint32: |
||||
switch { |
||||
case isSlice: // E.g., []uint32
|
||||
mfi.merge = func(dst, src pointer) { |
||||
sfsp := src.toUint32Slice() |
||||
if *sfsp != nil { |
||||
dfsp := dst.toUint32Slice() |
||||
*dfsp = append(*dfsp, *sfsp...) |
||||
if *dfsp == nil { |
||||
*dfsp = []uint32{} |
||||
} |
||||
} |
||||
} |
||||
case isPointer: // E.g., *uint32
|
||||
mfi.merge = func(dst, src pointer) { |
||||
sfpp := src.toUint32Ptr() |
||||
if *sfpp != nil { |
||||
dfpp := dst.toUint32Ptr() |
||||
if *dfpp == nil { |
||||
*dfpp = Uint32(**sfpp) |
||||
} else { |
||||
**dfpp = **sfpp |
||||
} |
||||
} |
||||
} |
||||
default: // E.g., uint32
|
||||
mfi.merge = func(dst, src pointer) { |
||||
if v := *src.toUint32(); v != 0 { |
||||
*dst.toUint32() = v |
||||
} |
||||
} |
||||
} |
||||
case reflect.Uint64: |
||||
switch { |
||||
case isSlice: // E.g., []uint64
|
||||
mfi.merge = func(dst, src pointer) { |
||||
sfsp := src.toUint64Slice() |
||||
if *sfsp != nil { |
||||
dfsp := dst.toUint64Slice() |
||||
*dfsp = append(*dfsp, *sfsp...) |
||||
if *dfsp == nil { |
||||
*dfsp = []uint64{} |
||||
} |
||||
} |
||||
} |
||||
case isPointer: // E.g., *uint64
|
||||
mfi.merge = func(dst, src pointer) { |
||||
sfpp := src.toUint64Ptr() |
||||
if *sfpp != nil { |
||||
dfpp := dst.toUint64Ptr() |
||||
if *dfpp == nil { |
||||
*dfpp = Uint64(**sfpp) |
||||
} else { |
||||
**dfpp = **sfpp |
||||
} |
||||
} |
||||
} |
||||
default: // E.g., uint64
|
||||
mfi.merge = func(dst, src pointer) { |
||||
if v := *src.toUint64(); v != 0 { |
||||
*dst.toUint64() = v |
||||
} |
||||
} |
||||
} |
||||
case reflect.Float32: |
||||
switch { |
||||
case isSlice: // E.g., []float32
|
||||
mfi.merge = func(dst, src pointer) { |
||||
sfsp := src.toFloat32Slice() |
||||
if *sfsp != nil { |
||||
dfsp := dst.toFloat32Slice() |
||||
*dfsp = append(*dfsp, *sfsp...) |
||||
if *dfsp == nil { |
||||
*dfsp = []float32{} |
||||
} |
||||
} |
||||
} |
||||
case isPointer: // E.g., *float32
|
||||
mfi.merge = func(dst, src pointer) { |
||||
sfpp := src.toFloat32Ptr() |
||||
if *sfpp != nil { |
||||
dfpp := dst.toFloat32Ptr() |
||||
if *dfpp == nil { |
||||
*dfpp = Float32(**sfpp) |
||||
} else { |
||||
**dfpp = **sfpp |
||||
} |
||||
} |
||||
} |
||||
default: // E.g., float32
|
||||
mfi.merge = func(dst, src pointer) { |
||||
if v := *src.toFloat32(); v != 0 { |
||||
*dst.toFloat32() = v |
||||
} |
||||
} |
||||
} |
||||
case reflect.Float64: |
||||
switch { |
||||
case isSlice: // E.g., []float64
|
||||
mfi.merge = func(dst, src pointer) { |
||||
sfsp := src.toFloat64Slice() |
||||
if *sfsp != nil { |
||||
dfsp := dst.toFloat64Slice() |
||||
*dfsp = append(*dfsp, *sfsp...) |
||||
if *dfsp == nil { |
||||
*dfsp = []float64{} |
||||
} |
||||
} |
||||
} |
||||
case isPointer: // E.g., *float64
|
||||
mfi.merge = func(dst, src pointer) { |
||||
sfpp := src.toFloat64Ptr() |
||||
if *sfpp != nil { |
||||
dfpp := dst.toFloat64Ptr() |
||||
if *dfpp == nil { |
||||
*dfpp = Float64(**sfpp) |
||||
} else { |
||||
**dfpp = **sfpp |
||||
} |
||||
} |
||||
} |
||||
default: // E.g., float64
|
||||
mfi.merge = func(dst, src pointer) { |
||||
if v := *src.toFloat64(); v != 0 { |
||||
*dst.toFloat64() = v |
||||
} |
||||
} |
||||
} |
||||
case reflect.Bool: |
||||
switch { |
||||
case isSlice: // E.g., []bool
|
||||
mfi.merge = func(dst, src pointer) { |
||||
sfsp := src.toBoolSlice() |
||||
if *sfsp != nil { |
||||
dfsp := dst.toBoolSlice() |
||||
*dfsp = append(*dfsp, *sfsp...) |
||||
if *dfsp == nil { |
||||
*dfsp = []bool{} |
||||
} |
||||
} |
||||
} |
||||
case isPointer: // E.g., *bool
|
||||
mfi.merge = func(dst, src pointer) { |
||||
sfpp := src.toBoolPtr() |
||||
if *sfpp != nil { |
||||
dfpp := dst.toBoolPtr() |
||||
if *dfpp == nil { |
||||
*dfpp = Bool(**sfpp) |
||||
} else { |
||||
**dfpp = **sfpp |
||||
} |
||||
} |
||||
} |
||||
default: // E.g., bool
|
||||
mfi.merge = func(dst, src pointer) { |
||||
if v := *src.toBool(); v { |
||||
*dst.toBool() = v |
||||
} |
||||
} |
||||
} |
||||
case reflect.String: |
||||
switch { |
||||
case isSlice: // E.g., []string
|
||||
mfi.merge = func(dst, src pointer) { |
||||
sfsp := src.toStringSlice() |
||||
if *sfsp != nil { |
||||
dfsp := dst.toStringSlice() |
||||
*dfsp = append(*dfsp, *sfsp...) |
||||
if *dfsp == nil { |
||||
*dfsp = []string{} |
||||
} |
||||
} |
||||
} |
||||
case isPointer: // E.g., *string
|
||||
mfi.merge = func(dst, src pointer) { |
||||
sfpp := src.toStringPtr() |
||||
if *sfpp != nil { |
||||
dfpp := dst.toStringPtr() |
||||
if *dfpp == nil { |
||||
*dfpp = String(**sfpp) |
||||
} else { |
||||
**dfpp = **sfpp |
||||
} |
||||
} |
||||
} |
||||
default: // E.g., string
|
||||
mfi.merge = func(dst, src pointer) { |
||||
if v := *src.toString(); v != "" { |
||||
*dst.toString() = v |
||||
} |
||||
} |
||||
} |
||||
case reflect.Slice: |
||||
isProto3 := props.Prop[i].proto3 |
||||
switch { |
||||
case isPointer: |
||||
panic("bad pointer in byte slice case in " + tf.Name()) |
||||
case tf.Elem().Kind() != reflect.Uint8: |
||||
panic("bad element kind in byte slice case in " + tf.Name()) |
||||
case isSlice: // E.g., [][]byte
|
||||
mfi.merge = func(dst, src pointer) { |
||||
sbsp := src.toBytesSlice() |
||||
if *sbsp != nil { |
||||
dbsp := dst.toBytesSlice() |
||||
for _, sb := range *sbsp { |
||||
if sb == nil { |
||||
*dbsp = append(*dbsp, nil) |
||||
} else { |
||||
*dbsp = append(*dbsp, append([]byte{}, sb...)) |
||||
} |
||||
} |
||||
if *dbsp == nil { |
||||
*dbsp = [][]byte{} |
||||
} |
||||
} |
||||
} |
||||
default: // E.g., []byte
|
||||
mfi.merge = func(dst, src pointer) { |
||||
sbp := src.toBytes() |
||||
if *sbp != nil { |
||||
dbp := dst.toBytes() |
||||
if !isProto3 || len(*sbp) > 0 { |
||||
*dbp = append([]byte{}, *sbp...) |
||||
} |
||||
} |
||||
} |
||||
} |
||||
case reflect.Struct: |
||||
switch { |
||||
case !isPointer: |
||||
panic(fmt.Sprintf("message field %s without pointer", tf)) |
||||
case isSlice: // E.g., []*pb.T
|
||||
mi := getMergeInfo(tf) |
||||
mfi.merge = func(dst, src pointer) { |
||||
sps := src.getPointerSlice() |
||||
if sps != nil { |
||||
dps := dst.getPointerSlice() |
||||
for _, sp := range sps { |
||||
var dp pointer |
||||
if !sp.isNil() { |
||||
dp = valToPointer(reflect.New(tf)) |
||||
mi.merge(dp, sp) |
||||
} |
||||
dps = append(dps, dp) |
||||
} |
||||
if dps == nil { |
||||
dps = []pointer{} |
||||
} |
||||
dst.setPointerSlice(dps) |
||||
} |
||||
} |
||||
default: // E.g., *pb.T
|
||||
mi := getMergeInfo(tf) |
||||
mfi.merge = func(dst, src pointer) { |
||||
sp := src.getPointer() |
||||
if !sp.isNil() { |
||||
dp := dst.getPointer() |
||||
if dp.isNil() { |
||||
dp = valToPointer(reflect.New(tf)) |
||||
dst.setPointer(dp) |
||||
} |
||||
mi.merge(dp, sp) |
||||
} |
||||
} |
||||
} |
||||
case reflect.Map: |
||||
switch { |
||||
case isPointer || isSlice: |
||||
panic("bad pointer or slice in map case in " + tf.Name()) |
||||
default: // E.g., map[K]V
|
||||
mfi.merge = func(dst, src pointer) { |
||||
sm := src.asPointerTo(tf).Elem() |
||||
if sm.Len() == 0 { |
||||
return |
||||
} |
||||
dm := dst.asPointerTo(tf).Elem() |
||||
if dm.IsNil() { |
||||
dm.Set(reflect.MakeMap(tf)) |
||||
} |
||||
|
||||
switch tf.Elem().Kind() { |
||||
case reflect.Ptr: // Proto struct (e.g., *T)
|
||||
for _, key := range sm.MapKeys() { |
||||
val := sm.MapIndex(key) |
||||
val = reflect.ValueOf(Clone(val.Interface().(Message))) |
||||
dm.SetMapIndex(key, val) |
||||
} |
||||
case reflect.Slice: // E.g. Bytes type (e.g., []byte)
|
||||
for _, key := range sm.MapKeys() { |
||||
val := sm.MapIndex(key) |
||||
val = reflect.ValueOf(append([]byte{}, val.Bytes()...)) |
||||
dm.SetMapIndex(key, val) |
||||
} |
||||
default: // Basic type (e.g., string)
|
||||
for _, key := range sm.MapKeys() { |
||||
val := sm.MapIndex(key) |
||||
dm.SetMapIndex(key, val) |
||||
} |
||||
} |
||||
} |
||||
} |
||||
case reflect.Interface: |
||||
// Must be oneof field.
|
||||
switch { |
||||
case isPointer || isSlice: |
||||
panic("bad pointer or slice in interface case in " + tf.Name()) |
||||
default: // E.g., interface{}
|
||||
// TODO: Make this faster?
|
||||
mfi.merge = func(dst, src pointer) { |
||||
su := src.asPointerTo(tf).Elem() |
||||
if !su.IsNil() { |
||||
du := dst.asPointerTo(tf).Elem() |
||||
typ := su.Elem().Type() |
||||
if du.IsNil() || du.Elem().Type() != typ { |
||||
du.Set(reflect.New(typ.Elem())) // Initialize interface if empty
|
||||
} |
||||
sv := su.Elem().Elem().Field(0) |
||||
if sv.Kind() == reflect.Ptr && sv.IsNil() { |
||||
return |
||||
} |
||||
dv := du.Elem().Elem().Field(0) |
||||
if dv.Kind() == reflect.Ptr && dv.IsNil() { |
||||
dv.Set(reflect.New(sv.Type().Elem())) // Initialize proto message if empty
|
||||
} |
||||
switch sv.Type().Kind() { |
||||
case reflect.Ptr: // Proto struct (e.g., *T)
|
||||
Merge(dv.Interface().(Message), sv.Interface().(Message)) |
||||
case reflect.Slice: // E.g. Bytes type (e.g., []byte)
|
||||
dv.Set(reflect.ValueOf(append([]byte{}, sv.Bytes()...))) |
||||
default: // Basic type (e.g., string)
|
||||
dv.Set(sv) |
||||
} |
||||
} |
||||
} |
||||
} |
||||
default: |
||||
panic(fmt.Sprintf("merger not found for type:%s", tf)) |
||||
} |
||||
mi.fields = append(mi.fields, mfi) |
||||
} |
||||
|
||||
mi.unrecognized = invalidField |
||||
if f, ok := t.FieldByName("XXX_unrecognized"); ok { |
||||
if f.Type != reflect.TypeOf([]byte{}) { |
||||
panic("expected XXX_unrecognized to be of type []byte") |
||||
} |
||||
mi.unrecognized = toField(&f) |
||||
} |
||||
|
||||
atomic.StoreInt32(&mi.initialized, 1) |
||||
} |
||||
File diff suppressed because it is too large
Load Diff
@ -1,843 +0,0 @@ |
||||
// Go support for Protocol Buffers - Google's data interchange format
|
||||
//
|
||||
// Copyright 2010 The Go Authors. All rights reserved.
|
||||
// https://github.com/golang/protobuf
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are
|
||||
// met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following disclaimer
|
||||
// in the documentation and/or other materials provided with the
|
||||
// distribution.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
package proto |
||||
|
||||
// Functions for writing the text protocol buffer format.
|
||||
|
||||
import ( |
||||
"bufio" |
||||
"bytes" |
||||
"encoding" |
||||
"errors" |
||||
"fmt" |
||||
"io" |
||||
"log" |
||||
"math" |
||||
"reflect" |
||||
"sort" |
||||
"strings" |
||||
) |
||||
|
||||
var ( |
||||
newline = []byte("\n") |
||||
spaces = []byte(" ") |
||||
endBraceNewline = []byte("}\n") |
||||
backslashN = []byte{'\\', 'n'} |
||||
backslashR = []byte{'\\', 'r'} |
||||
backslashT = []byte{'\\', 't'} |
||||
backslashDQ = []byte{'\\', '"'} |
||||
backslashBS = []byte{'\\', '\\'} |
||||
posInf = []byte("inf") |
||||
negInf = []byte("-inf") |
||||
nan = []byte("nan") |
||||
) |
||||
|
||||
type writer interface { |
||||
io.Writer |
||||
WriteByte(byte) error |
||||
} |
||||
|
||||
// textWriter is an io.Writer that tracks its indentation level.
|
||||
type textWriter struct { |
||||
ind int |
||||
complete bool // if the current position is a complete line
|
||||
compact bool // whether to write out as a one-liner
|
||||
w writer |
||||
} |
||||
|
||||
func (w *textWriter) WriteString(s string) (n int, err error) { |
||||
if !strings.Contains(s, "\n") { |
||||
if !w.compact && w.complete { |
||||
w.writeIndent() |
||||
} |
||||
w.complete = false |
||||
return io.WriteString(w.w, s) |
||||
} |
||||
// WriteString is typically called without newlines, so this
|
||||
// codepath and its copy are rare. We copy to avoid
|
||||
// duplicating all of Write's logic here.
|
||||
return w.Write([]byte(s)) |
||||
} |
||||
|
||||
func (w *textWriter) Write(p []byte) (n int, err error) { |
||||
newlines := bytes.Count(p, newline) |
||||
if newlines == 0 { |
||||
if !w.compact && w.complete { |
||||
w.writeIndent() |
||||
} |
||||
n, err = w.w.Write(p) |
||||
w.complete = false |
||||
return n, err |
||||
} |
||||
|
||||
frags := bytes.SplitN(p, newline, newlines+1) |
||||
if w.compact { |
||||
for i, frag := range frags { |
||||
if i > 0 { |
||||
if err := w.w.WriteByte(' '); err != nil { |
||||
return n, err |
||||
} |
||||
n++ |
||||
} |
||||
nn, err := w.w.Write(frag) |
||||
n += nn |
||||
if err != nil { |
||||
return n, err |
||||
} |
||||
} |
||||
return n, nil |
||||
} |
||||
|
||||
for i, frag := range frags { |
||||
if w.complete { |
||||
w.writeIndent() |
||||
} |
||||
nn, err := w.w.Write(frag) |
||||
n += nn |
||||
if err != nil { |
||||
return n, err |
||||
} |
||||
if i+1 < len(frags) { |
||||
if err := w.w.WriteByte('\n'); err != nil { |
||||
return n, err |
||||
} |
||||
n++ |
||||
} |
||||
} |
||||
w.complete = len(frags[len(frags)-1]) == 0 |
||||
return n, nil |
||||
} |
||||
|
||||
func (w *textWriter) WriteByte(c byte) error { |
||||
if w.compact && c == '\n' { |
||||
c = ' ' |
||||
} |
||||
if !w.compact && w.complete { |
||||
w.writeIndent() |
||||
} |
||||
err := w.w.WriteByte(c) |
||||
w.complete = c == '\n' |
||||
return err |
||||
} |
||||
|
||||
func (w *textWriter) indent() { w.ind++ } |
||||
|
||||
func (w *textWriter) unindent() { |
||||
if w.ind == 0 { |
||||
log.Print("proto: textWriter unindented too far") |
||||
return |
||||
} |
||||
w.ind-- |
||||
} |
||||
|
||||
func writeName(w *textWriter, props *Properties) error { |
||||
if _, err := w.WriteString(props.OrigName); err != nil { |
||||
return err |
||||
} |
||||
if props.Wire != "group" { |
||||
return w.WriteByte(':') |
||||
} |
||||
return nil |
||||
} |
||||
|
||||
func requiresQuotes(u string) bool { |
||||
// When type URL contains any characters except [0-9A-Za-z./\-]*, it must be quoted.
|
||||
for _, ch := range u { |
||||
switch { |
||||
case ch == '.' || ch == '/' || ch == '_': |
||||
continue |
||||
case '0' <= ch && ch <= '9': |
||||
continue |
||||
case 'A' <= ch && ch <= 'Z': |
||||
continue |
||||
case 'a' <= ch && ch <= 'z': |
||||
continue |
||||
default: |
||||
return true |
||||
} |
||||
} |
||||
return false |
||||
} |
||||
|
||||
// isAny reports whether sv is a google.protobuf.Any message
|
||||
func isAny(sv reflect.Value) bool { |
||||
type wkt interface { |
||||
XXX_WellKnownType() string |
||||
} |
||||
t, ok := sv.Addr().Interface().(wkt) |
||||
return ok && t.XXX_WellKnownType() == "Any" |
||||
} |
||||
|
||||
// writeProto3Any writes an expanded google.protobuf.Any message.
|
||||
//
|
||||
// It returns (false, nil) if sv value can't be unmarshaled (e.g. because
|
||||
// required messages are not linked in).
|
||||
//
|
||||
// It returns (true, error) when sv was written in expanded format or an error
|
||||
// was encountered.
|
||||
func (tm *TextMarshaler) writeProto3Any(w *textWriter, sv reflect.Value) (bool, error) { |
||||
turl := sv.FieldByName("TypeUrl") |
||||
val := sv.FieldByName("Value") |
||||
if !turl.IsValid() || !val.IsValid() { |
||||
return true, errors.New("proto: invalid google.protobuf.Any message") |
||||
} |
||||
|
||||
b, ok := val.Interface().([]byte) |
||||
if !ok { |
||||
return true, errors.New("proto: invalid google.protobuf.Any message") |
||||
} |
||||
|
||||
parts := strings.Split(turl.String(), "/") |
||||
mt := MessageType(parts[len(parts)-1]) |
||||
if mt == nil { |
||||
return false, nil |
||||
} |
||||
m := reflect.New(mt.Elem()) |
||||
if err := Unmarshal(b, m.Interface().(Message)); err != nil { |
||||
return false, nil |
||||
} |
||||
w.Write([]byte("[")) |
||||
u := turl.String() |
||||
if requiresQuotes(u) { |
||||
writeString(w, u) |
||||
} else { |
||||
w.Write([]byte(u)) |
||||
} |
||||
if w.compact { |
||||
w.Write([]byte("]:<")) |
||||
} else { |
||||
w.Write([]byte("]: <\n")) |
||||
w.ind++ |
||||
} |
||||
if err := tm.writeStruct(w, m.Elem()); err != nil { |
||||
return true, err |
||||
} |
||||
if w.compact { |
||||
w.Write([]byte("> ")) |
||||
} else { |
||||
w.ind-- |
||||
w.Write([]byte(">\n")) |
||||
} |
||||
return true, nil |
||||
} |
||||
|
||||
func (tm *TextMarshaler) writeStruct(w *textWriter, sv reflect.Value) error { |
||||
if tm.ExpandAny && isAny(sv) { |
||||
if canExpand, err := tm.writeProto3Any(w, sv); canExpand { |
||||
return err |
||||
} |
||||
} |
||||
st := sv.Type() |
||||
sprops := GetProperties(st) |
||||
for i := 0; i < sv.NumField(); i++ { |
||||
fv := sv.Field(i) |
||||
props := sprops.Prop[i] |
||||
name := st.Field(i).Name |
||||
|
||||
if name == "XXX_NoUnkeyedLiteral" { |
||||
continue |
||||
} |
||||
|
||||
if strings.HasPrefix(name, "XXX_") { |
||||
// There are two XXX_ fields:
|
||||
// XXX_unrecognized []byte
|
||||
// XXX_extensions map[int32]proto.Extension
|
||||
// The first is handled here;
|
||||
// the second is handled at the bottom of this function.
|
||||
if name == "XXX_unrecognized" && !fv.IsNil() { |
||||
if err := writeUnknownStruct(w, fv.Interface().([]byte)); err != nil { |
||||
return err |
||||
} |
||||
} |
||||
continue |
||||
} |
||||
if fv.Kind() == reflect.Ptr && fv.IsNil() { |
||||
// Field not filled in. This could be an optional field or
|
||||
// a required field that wasn't filled in. Either way, there
|
||||
// isn't anything we can show for it.
|
||||
continue |
||||
} |
||||
if fv.Kind() == reflect.Slice && fv.IsNil() { |
||||
// Repeated field that is empty, or a bytes field that is unused.
|
||||
continue |
||||
} |
||||
|
||||
if props.Repeated && fv.Kind() == reflect.Slice { |
||||
// Repeated field.
|
||||
for j := 0; j < fv.Len(); j++ { |
||||
if err := writeName(w, props); err != nil { |
||||
return err |
||||
} |
||||
if !w.compact { |
||||
if err := w.WriteByte(' '); err != nil { |
||||
return err |
||||
} |
||||
} |
||||
v := fv.Index(j) |
||||
if v.Kind() == reflect.Ptr && v.IsNil() { |
||||
// A nil message in a repeated field is not valid,
|
||||
// but we can handle that more gracefully than panicking.
|
||||
if _, err := w.Write([]byte("<nil>\n")); err != nil { |
||||
return err |
||||
} |
||||
continue |
||||
} |
||||
if err := tm.writeAny(w, v, props); err != nil { |
||||
return err |
||||
} |
||||
if err := w.WriteByte('\n'); err != nil { |
||||
return err |
||||
} |
||||
} |
||||
continue |
||||
} |
||||
if fv.Kind() == reflect.Map { |
||||
// Map fields are rendered as a repeated struct with key/value fields.
|
||||
keys := fv.MapKeys() |
||||
sort.Sort(mapKeys(keys)) |
||||
for _, key := range keys { |
||||
val := fv.MapIndex(key) |
||||
if err := writeName(w, props); err != nil { |
||||
return err |
||||
} |
||||
if !w.compact { |
||||
if err := w.WriteByte(' '); err != nil { |
||||
return err |
||||
} |
||||
} |
||||
// open struct
|
||||
if err := w.WriteByte('<'); err != nil { |
||||
return err |
||||
} |
||||
if !w.compact { |
||||
if err := w.WriteByte('\n'); err != nil { |
||||
return err |
||||
} |
||||
} |
||||
w.indent() |
||||
// key
|
||||
if _, err := w.WriteString("key:"); err != nil { |
||||
return err |
||||
} |
||||
if !w.compact { |
||||
if err := w.WriteByte(' '); err != nil { |
||||
return err |
||||
} |
||||
} |
||||
if err := tm.writeAny(w, key, props.MapKeyProp); err != nil { |
||||
return err |
||||
} |
||||
if err := w.WriteByte('\n'); err != nil { |
||||
return err |
||||
} |
||||
// nil values aren't legal, but we can avoid panicking because of them.
|
||||
if val.Kind() != reflect.Ptr || !val.IsNil() { |
||||
// value
|
||||
if _, err := w.WriteString("value:"); err != nil { |
||||
return err |
||||
} |
||||
if !w.compact { |
||||
if err := w.WriteByte(' '); err != nil { |
||||
return err |
||||
} |
||||
} |
||||
if err := tm.writeAny(w, val, props.MapValProp); err != nil { |
||||
return err |
||||
} |
||||
if err := w.WriteByte('\n'); err != nil { |
||||
return err |
||||
} |
||||
} |
||||
// close struct
|
||||
w.unindent() |
||||
if err := w.WriteByte('>'); err != nil { |
||||
return err |
||||
} |
||||
if err := w.WriteByte('\n'); err != nil { |
||||
return err |
||||
} |
||||
} |
||||
continue |
||||
} |
||||
if props.proto3 && fv.Kind() == reflect.Slice && fv.Len() == 0 { |
||||
// empty bytes field
|
||||
continue |
||||
} |
||||
if fv.Kind() != reflect.Ptr && fv.Kind() != reflect.Slice { |
||||
// proto3 non-repeated scalar field; skip if zero value
|
||||
if isProto3Zero(fv) { |
||||
continue |
||||
} |
||||
} |
||||
|
||||
if fv.Kind() == reflect.Interface { |
||||
// Check if it is a oneof.
|
||||
if st.Field(i).Tag.Get("protobuf_oneof") != "" { |
||||
// fv is nil, or holds a pointer to generated struct.
|
||||
// That generated struct has exactly one field,
|
||||
// which has a protobuf struct tag.
|
||||
if fv.IsNil() { |
||||
continue |
||||
} |
||||
inner := fv.Elem().Elem() // interface -> *T -> T
|
||||
tag := inner.Type().Field(0).Tag.Get("protobuf") |
||||
props = new(Properties) // Overwrite the outer props var, but not its pointee.
|
||||
props.Parse(tag) |
||||
// Write the value in the oneof, not the oneof itself.
|
||||
fv = inner.Field(0) |
||||
|
||||
// Special case to cope with malformed messages gracefully:
|
||||
// If the value in the oneof is a nil pointer, don't panic
|
||||
// in writeAny.
|
||||
if fv.Kind() == reflect.Ptr && fv.IsNil() { |
||||
// Use errors.New so writeAny won't render quotes.
|
||||
msg := errors.New("/* nil */") |
||||
fv = reflect.ValueOf(&msg).Elem() |
||||
} |
||||
} |
||||
} |
||||
|
||||
if err := writeName(w, props); err != nil { |
||||
return err |
||||
} |
||||
if !w.compact { |
||||
if err := w.WriteByte(' '); err != nil { |
||||
return err |
||||
} |
||||
} |
||||
|
||||
// Enums have a String method, so writeAny will work fine.
|
||||
if err := tm.writeAny(w, fv, props); err != nil { |
||||
return err |
||||
} |
||||
|
||||
if err := w.WriteByte('\n'); err != nil { |
||||
return err |
||||
} |
||||
} |
||||
|
||||
// Extensions (the XXX_extensions field).
|
||||
pv := sv.Addr() |
||||
if _, err := extendable(pv.Interface()); err == nil { |
||||
if err := tm.writeExtensions(w, pv); err != nil { |
||||
return err |
||||
} |
||||
} |
||||
|
||||
return nil |
||||
} |
||||
|
||||
// writeAny writes an arbitrary field.
|
||||
func (tm *TextMarshaler) writeAny(w *textWriter, v reflect.Value, props *Properties) error { |
||||
v = reflect.Indirect(v) |
||||
|
||||
// Floats have special cases.
|
||||
if v.Kind() == reflect.Float32 || v.Kind() == reflect.Float64 { |
||||
x := v.Float() |
||||
var b []byte |
||||
switch { |
||||
case math.IsInf(x, 1): |
||||
b = posInf |
||||
case math.IsInf(x, -1): |
||||
b = negInf |
||||
case math.IsNaN(x): |
||||
b = nan |
||||
} |
||||
if b != nil { |
||||
_, err := w.Write(b) |
||||
return err |
||||
} |
||||
// Other values are handled below.
|
||||
} |
||||
|
||||
// We don't attempt to serialise every possible value type; only those
|
||||
// that can occur in protocol buffers.
|
||||
switch v.Kind() { |
||||
case reflect.Slice: |
||||
// Should only be a []byte; repeated fields are handled in writeStruct.
|
||||
if err := writeString(w, string(v.Bytes())); err != nil { |
||||
return err |
||||
} |
||||
case reflect.String: |
||||
if err := writeString(w, v.String()); err != nil { |
||||
return err |
||||
} |
||||
case reflect.Struct: |
||||
// Required/optional group/message.
|
||||
var bra, ket byte = '<', '>' |
||||
if props != nil && props.Wire == "group" { |
||||
bra, ket = '{', '}' |
||||
} |
||||
if err := w.WriteByte(bra); err != nil { |
||||
return err |
||||
} |
||||
if !w.compact { |
||||
if err := w.WriteByte('\n'); err != nil { |
||||
return err |
||||
} |
||||
} |
||||
w.indent() |
||||
if v.CanAddr() { |
||||
// Calling v.Interface on a struct causes the reflect package to
|
||||
// copy the entire struct. This is racy with the new Marshaler
|
||||
// since we atomically update the XXX_sizecache.
|
||||
//
|
||||
// Thus, we retrieve a pointer to the struct if possible to avoid
|
||||
// a race since v.Interface on the pointer doesn't copy the struct.
|
||||
//
|
||||
// If v is not addressable, then we are not worried about a race
|
||||
// since it implies that the binary Marshaler cannot possibly be
|
||||
// mutating this value.
|
||||
v = v.Addr() |
||||
} |
||||
if etm, ok := v.Interface().(encoding.TextMarshaler); ok { |
||||
text, err := etm.MarshalText() |
||||
if err != nil { |
||||
return err |
||||
} |
||||
if _, err = w.Write(text); err != nil { |
||||
return err |
||||
} |
||||
} else { |
||||
if v.Kind() == reflect.Ptr { |
||||
v = v.Elem() |
||||
} |
||||
if err := tm.writeStruct(w, v); err != nil { |
||||
return err |
||||
} |
||||
} |
||||
w.unindent() |
||||
if err := w.WriteByte(ket); err != nil { |
||||
return err |
||||
} |
||||
default: |
||||
_, err := fmt.Fprint(w, v.Interface()) |
||||
return err |
||||
} |
||||
return nil |
||||
} |
||||
|
||||
// equivalent to C's isprint.
|
||||
func isprint(c byte) bool { |
||||
return c >= 0x20 && c < 0x7f |
||||
} |
||||
|
||||
// writeString writes a string in the protocol buffer text format.
|
||||
// It is similar to strconv.Quote except we don't use Go escape sequences,
|
||||
// we treat the string as a byte sequence, and we use octal escapes.
|
||||
// These differences are to maintain interoperability with the other
|
||||
// languages' implementations of the text format.
|
||||
func writeString(w *textWriter, s string) error { |
||||
// use WriteByte here to get any needed indent
|
||||
if err := w.WriteByte('"'); err != nil { |
||||
return err |
||||
} |
||||
// Loop over the bytes, not the runes.
|
||||
for i := 0; i < len(s); i++ { |
||||
var err error |
||||
// Divergence from C++: we don't escape apostrophes.
|
||||
// There's no need to escape them, and the C++ parser
|
||||
// copes with a naked apostrophe.
|
||||
switch c := s[i]; c { |
||||
case '\n': |
||||
_, err = w.w.Write(backslashN) |
||||
case '\r': |
||||
_, err = w.w.Write(backslashR) |
||||
case '\t': |
||||
_, err = w.w.Write(backslashT) |
||||
case '"': |
||||
_, err = w.w.Write(backslashDQ) |
||||
case '\\': |
||||
_, err = w.w.Write(backslashBS) |
||||
default: |
||||
if isprint(c) { |
||||
err = w.w.WriteByte(c) |
||||
} else { |
||||
_, err = fmt.Fprintf(w.w, "\\%03o", c) |
||||
} |
||||
} |
||||
if err != nil { |
||||
return err |
||||
} |
||||
} |
||||
return w.WriteByte('"') |
||||
} |
||||
|
||||
func writeUnknownStruct(w *textWriter, data []byte) (err error) { |
||||
if !w.compact { |
||||
if _, err := fmt.Fprintf(w, "/* %d unknown bytes */\n", len(data)); err != nil { |
||||
return err |
||||
} |
||||
} |
||||
b := NewBuffer(data) |
||||
for b.index < len(b.buf) { |
||||
x, err := b.DecodeVarint() |
||||
if err != nil { |
||||
_, err := fmt.Fprintf(w, "/* %v */\n", err) |
||||
return err |
||||
} |
||||
wire, tag := x&7, x>>3 |
||||
if wire == WireEndGroup { |
||||
w.unindent() |
||||
if _, err := w.Write(endBraceNewline); err != nil { |
||||
return err |
||||
} |
||||
continue |
||||
} |
||||
if _, err := fmt.Fprint(w, tag); err != nil { |
||||
return err |
||||
} |
||||
if wire != WireStartGroup { |
||||
if err := w.WriteByte(':'); err != nil { |
||||
return err |
||||
} |
||||
} |
||||
if !w.compact || wire == WireStartGroup { |
||||
if err := w.WriteByte(' '); err != nil { |
||||
return err |
||||
} |
||||
} |
||||
switch wire { |
||||
case WireBytes: |
||||
buf, e := b.DecodeRawBytes(false) |
||||
if e == nil { |
||||
_, err = fmt.Fprintf(w, "%q", buf) |
||||
} else { |
||||
_, err = fmt.Fprintf(w, "/* %v */", e) |
||||
} |
||||
case WireFixed32: |
||||
x, err = b.DecodeFixed32() |
||||
err = writeUnknownInt(w, x, err) |
||||
case WireFixed64: |
||||
x, err = b.DecodeFixed64() |
||||
err = writeUnknownInt(w, x, err) |
||||
case WireStartGroup: |
||||
err = w.WriteByte('{') |
||||
w.indent() |
||||
case WireVarint: |
||||
x, err = b.DecodeVarint() |
||||
err = writeUnknownInt(w, x, err) |
||||
default: |
||||
_, err = fmt.Fprintf(w, "/* unknown wire type %d */", wire) |
||||
} |
||||
if err != nil { |
||||
return err |
||||
} |
||||
if err = w.WriteByte('\n'); err != nil { |
||||
return err |
||||
} |
||||
} |
||||
return nil |
||||
} |
||||
|
||||
func writeUnknownInt(w *textWriter, x uint64, err error) error { |
||||
if err == nil { |
||||
_, err = fmt.Fprint(w, x) |
||||
} else { |
||||
_, err = fmt.Fprintf(w, "/* %v */", err) |
||||
} |
||||
return err |
||||
} |
||||
|
||||
type int32Slice []int32 |
||||
|
||||
func (s int32Slice) Len() int { return len(s) } |
||||
func (s int32Slice) Less(i, j int) bool { return s[i] < s[j] } |
||||
func (s int32Slice) Swap(i, j int) { s[i], s[j] = s[j], s[i] } |
||||
|
||||
// writeExtensions writes all the extensions in pv.
|
||||
// pv is assumed to be a pointer to a protocol message struct that is extendable.
|
||||
func (tm *TextMarshaler) writeExtensions(w *textWriter, pv reflect.Value) error { |
||||
emap := extensionMaps[pv.Type().Elem()] |
||||
ep, _ := extendable(pv.Interface()) |
||||
|
||||
// Order the extensions by ID.
|
||||
// This isn't strictly necessary, but it will give us
|
||||
// canonical output, which will also make testing easier.
|
||||
m, mu := ep.extensionsRead() |
||||
if m == nil { |
||||
return nil |
||||
} |
||||
mu.Lock() |
||||
ids := make([]int32, 0, len(m)) |
||||
for id := range m { |
||||
ids = append(ids, id) |
||||
} |
||||
sort.Sort(int32Slice(ids)) |
||||
mu.Unlock() |
||||
|
||||
for _, extNum := range ids { |
||||
ext := m[extNum] |
||||
var desc *ExtensionDesc |
||||
if emap != nil { |
||||
desc = emap[extNum] |
||||
} |
||||
if desc == nil { |
||||
// Unknown extension.
|
||||
if err := writeUnknownStruct(w, ext.enc); err != nil { |
||||
return err |
||||
} |
||||
continue |
||||
} |
||||
|
||||
pb, err := GetExtension(ep, desc) |
||||
if err != nil { |
||||
return fmt.Errorf("failed getting extension: %v", err) |
||||
} |
||||
|
||||
// Repeated extensions will appear as a slice.
|
||||
if !desc.repeated() { |
||||
if err := tm.writeExtension(w, desc.Name, pb); err != nil { |
||||
return err |
||||
} |
||||
} else { |
||||
v := reflect.ValueOf(pb) |
||||
for i := 0; i < v.Len(); i++ { |
||||
if err := tm.writeExtension(w, desc.Name, v.Index(i).Interface()); err != nil { |
||||
return err |
||||
} |
||||
} |
||||
} |
||||
} |
||||
return nil |
||||
} |
||||
|
||||
func (tm *TextMarshaler) writeExtension(w *textWriter, name string, pb interface{}) error { |
||||
if _, err := fmt.Fprintf(w, "[%s]:", name); err != nil { |
||||
return err |
||||
} |
||||
if !w.compact { |
||||
if err := w.WriteByte(' '); err != nil { |
||||
return err |
||||
} |
||||
} |
||||
if err := tm.writeAny(w, reflect.ValueOf(pb), nil); err != nil { |
||||
return err |
||||
} |
||||
if err := w.WriteByte('\n'); err != nil { |
||||
return err |
||||
} |
||||
return nil |
||||
} |
||||
|
||||
func (w *textWriter) writeIndent() { |
||||
if !w.complete { |
||||
return |
||||
} |
||||
remain := w.ind * 2 |
||||
for remain > 0 { |
||||
n := remain |
||||
if n > len(spaces) { |
||||
n = len(spaces) |
||||
} |
||||
w.w.Write(spaces[:n]) |
||||
remain -= n |
||||
} |
||||
w.complete = false |
||||
} |
||||
|
||||
// TextMarshaler is a configurable text format marshaler.
|
||||
type TextMarshaler struct { |
||||
Compact bool // use compact text format (one line).
|
||||
ExpandAny bool // expand google.protobuf.Any messages of known types
|
||||
} |
||||
|
||||
// Marshal writes a given protocol buffer in text format.
|
||||
// The only errors returned are from w.
|
||||
func (tm *TextMarshaler) Marshal(w io.Writer, pb Message) error { |
||||
val := reflect.ValueOf(pb) |
||||
if pb == nil || val.IsNil() { |
||||
w.Write([]byte("<nil>")) |
||||
return nil |
||||
} |
||||
var bw *bufio.Writer |
||||
ww, ok := w.(writer) |
||||
if !ok { |
||||
bw = bufio.NewWriter(w) |
||||
ww = bw |
||||
} |
||||
aw := &textWriter{ |
||||
w: ww, |
||||
complete: true, |
||||
compact: tm.Compact, |
||||
} |
||||
|
||||
if etm, ok := pb.(encoding.TextMarshaler); ok { |
||||
text, err := etm.MarshalText() |
||||
if err != nil { |
||||
return err |
||||
} |
||||
if _, err = aw.Write(text); err != nil { |
||||
return err |
||||
} |
||||
if bw != nil { |
||||
return bw.Flush() |
||||
} |
||||
return nil |
||||
} |
||||
// Dereference the received pointer so we don't have outer < and >.
|
||||
v := reflect.Indirect(val) |
||||
if err := tm.writeStruct(aw, v); err != nil { |
||||
return err |
||||
} |
||||
if bw != nil { |
||||
return bw.Flush() |
||||
} |
||||
return nil |
||||
} |
||||
|
||||
// Text is the same as Marshal, but returns the string directly.
|
||||
func (tm *TextMarshaler) Text(pb Message) string { |
||||
var buf bytes.Buffer |
||||
tm.Marshal(&buf, pb) |
||||
return buf.String() |
||||
} |
||||
|
||||
var ( |
||||
defaultTextMarshaler = TextMarshaler{} |
||||
compactTextMarshaler = TextMarshaler{Compact: true} |
||||
) |
||||
|
||||
// TODO: consider removing some of the Marshal functions below.
|
||||
|
||||
// MarshalText writes a given protocol buffer in text format.
|
||||
// The only errors returned are from w.
|
||||
func MarshalText(w io.Writer, pb Message) error { return defaultTextMarshaler.Marshal(w, pb) } |
||||
|
||||
// MarshalTextString is the same as MarshalText, but returns the string directly.
|
||||
func MarshalTextString(pb Message) string { return defaultTextMarshaler.Text(pb) } |
||||
|
||||
// CompactText writes a given protocol buffer in compact text format (one line).
|
||||
func CompactText(w io.Writer, pb Message) error { return compactTextMarshaler.Marshal(w, pb) } |
||||
|
||||
// CompactTextString is the same as CompactText, but returns the string directly.
|
||||
func CompactTextString(pb Message) string { return compactTextMarshaler.Text(pb) } |
||||
@ -0,0 +1,801 @@ |
||||
// Copyright 2010 The Go Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
package proto |
||||
|
||||
import ( |
||||
"encoding" |
||||
"errors" |
||||
"fmt" |
||||
"reflect" |
||||
"strconv" |
||||
"strings" |
||||
"unicode/utf8" |
||||
|
||||
"google.golang.org/protobuf/encoding/prototext" |
||||
protoV2 "google.golang.org/protobuf/proto" |
||||
"google.golang.org/protobuf/reflect/protoreflect" |
||||
"google.golang.org/protobuf/reflect/protoregistry" |
||||
) |
||||
|
||||
const wrapTextUnmarshalV2 = false |
||||
|
||||
// ParseError is returned by UnmarshalText.
|
||||
type ParseError struct { |
||||
Message string |
||||
|
||||
// Deprecated: Do not use.
|
||||
Line, Offset int |
||||
} |
||||
|
||||
func (e *ParseError) Error() string { |
||||
if wrapTextUnmarshalV2 { |
||||
return e.Message |
||||
} |
||||
if e.Line == 1 { |
||||
return fmt.Sprintf("line 1.%d: %v", e.Offset, e.Message) |
||||
} |
||||
return fmt.Sprintf("line %d: %v", e.Line, e.Message) |
||||
} |
||||
|
||||
// UnmarshalText parses a proto text formatted string into m.
|
||||
func UnmarshalText(s string, m Message) error { |
||||
if u, ok := m.(encoding.TextUnmarshaler); ok { |
||||
return u.UnmarshalText([]byte(s)) |
||||
} |
||||
|
||||
m.Reset() |
||||
mi := MessageV2(m) |
||||
|
||||
if wrapTextUnmarshalV2 { |
||||
err := prototext.UnmarshalOptions{ |
||||
AllowPartial: true, |
||||
}.Unmarshal([]byte(s), mi) |
||||
if err != nil { |
||||
return &ParseError{Message: err.Error()} |
||||
} |
||||
return checkRequiredNotSet(mi) |
||||
} else { |
||||
if err := newTextParser(s).unmarshalMessage(mi.ProtoReflect(), ""); err != nil { |
||||
return err |
||||
} |
||||
return checkRequiredNotSet(mi) |
||||
} |
||||
} |
||||
|
||||
type textParser struct { |
||||
s string // remaining input
|
||||
done bool // whether the parsing is finished (success or error)
|
||||
backed bool // whether back() was called
|
||||
offset, line int |
||||
cur token |
||||
} |
||||
|
||||
type token struct { |
||||
value string |
||||
err *ParseError |
||||
line int // line number
|
||||
offset int // byte number from start of input, not start of line
|
||||
unquoted string // the unquoted version of value, if it was a quoted string
|
||||
} |
||||
|
||||
func newTextParser(s string) *textParser { |
||||
p := new(textParser) |
||||
p.s = s |
||||
p.line = 1 |
||||
p.cur.line = 1 |
||||
return p |
||||
} |
||||
|
||||
func (p *textParser) unmarshalMessage(m protoreflect.Message, terminator string) (err error) { |
||||
md := m.Descriptor() |
||||
fds := md.Fields() |
||||
|
||||
// A struct is a sequence of "name: value", terminated by one of
|
||||
// '>' or '}', or the end of the input. A name may also be
|
||||
// "[extension]" or "[type/url]".
|
||||
//
|
||||
// The whole struct can also be an expanded Any message, like:
|
||||
// [type/url] < ... struct contents ... >
|
||||
seen := make(map[protoreflect.FieldNumber]bool) |
||||
for { |
||||
tok := p.next() |
||||
if tok.err != nil { |
||||
return tok.err |
||||
} |
||||
if tok.value == terminator { |
||||
break |
||||
} |
||||
if tok.value == "[" { |
||||
if err := p.unmarshalExtensionOrAny(m, seen); err != nil { |
||||
return err |
||||
} |
||||
continue |
||||
} |
||||
|
||||
// This is a normal, non-extension field.
|
||||
name := protoreflect.Name(tok.value) |
||||
fd := fds.ByName(name) |
||||
switch { |
||||
case fd == nil: |
||||
gd := fds.ByName(protoreflect.Name(strings.ToLower(string(name)))) |
||||
if gd != nil && gd.Kind() == protoreflect.GroupKind && gd.Message().Name() == name { |
||||
fd = gd |
||||
} |
||||
case fd.Kind() == protoreflect.GroupKind && fd.Message().Name() != name: |
||||
fd = nil |
||||
case fd.IsWeak() && fd.Message().IsPlaceholder(): |
||||
fd = nil |
||||
} |
||||
if fd == nil { |
||||
typeName := string(md.FullName()) |
||||
if m, ok := m.Interface().(Message); ok { |
||||
t := reflect.TypeOf(m) |
||||
if t.Kind() == reflect.Ptr { |
||||
typeName = t.Elem().String() |
||||
} |
||||
} |
||||
return p.errorf("unknown field name %q in %v", name, typeName) |
||||
} |
||||
if od := fd.ContainingOneof(); od != nil && m.WhichOneof(od) != nil { |
||||
return p.errorf("field '%s' would overwrite already parsed oneof '%s'", name, od.Name()) |
||||
} |
||||
if fd.Cardinality() != protoreflect.Repeated && seen[fd.Number()] { |
||||
return p.errorf("non-repeated field %q was repeated", fd.Name()) |
||||
} |
||||
seen[fd.Number()] = true |
||||
|
||||
// Consume any colon.
|
||||
if err := p.checkForColon(fd); err != nil { |
||||
return err |
||||
} |
||||
|
||||
// Parse into the field.
|
||||
v := m.Get(fd) |
||||
if !m.Has(fd) && (fd.IsList() || fd.IsMap() || fd.Message() != nil) { |
||||
v = m.Mutable(fd) |
||||
} |
||||
if v, err = p.unmarshalValue(v, fd); err != nil { |
||||
return err |
||||
} |
||||
m.Set(fd, v) |
||||
|
||||
if err := p.consumeOptionalSeparator(); err != nil { |
||||
return err |
||||
} |
||||
} |
||||
return nil |
||||
} |
||||
|
||||
func (p *textParser) unmarshalExtensionOrAny(m protoreflect.Message, seen map[protoreflect.FieldNumber]bool) error { |
||||
name, err := p.consumeExtensionOrAnyName() |
||||
if err != nil { |
||||
return err |
||||
} |
||||
|
||||
// If it contains a slash, it's an Any type URL.
|
||||
if slashIdx := strings.LastIndex(name, "/"); slashIdx >= 0 { |
||||
tok := p.next() |
||||
if tok.err != nil { |
||||
return tok.err |
||||
} |
||||
// consume an optional colon
|
||||
if tok.value == ":" { |
||||
tok = p.next() |
||||
if tok.err != nil { |
||||
return tok.err |
||||
} |
||||
} |
||||
|
||||
var terminator string |
||||
switch tok.value { |
||||
case "<": |
||||
terminator = ">" |
||||
case "{": |
||||
terminator = "}" |
||||
default: |
||||
return p.errorf("expected '{' or '<', found %q", tok.value) |
||||
} |
||||
|
||||
mt, err := protoregistry.GlobalTypes.FindMessageByURL(name) |
||||
if err != nil { |
||||
return p.errorf("unrecognized message %q in google.protobuf.Any", name[slashIdx+len("/"):]) |
||||
} |
||||
m2 := mt.New() |
||||
if err := p.unmarshalMessage(m2, terminator); err != nil { |
||||
return err |
||||
} |
||||
b, err := protoV2.Marshal(m2.Interface()) |
||||
if err != nil { |
||||
return p.errorf("failed to marshal message of type %q: %v", name[slashIdx+len("/"):], err) |
||||
} |
||||
|
||||
urlFD := m.Descriptor().Fields().ByName("type_url") |
||||
valFD := m.Descriptor().Fields().ByName("value") |
||||
if seen[urlFD.Number()] { |
||||
return p.errorf("Any message unpacked multiple times, or %q already set", urlFD.Name()) |
||||
} |
||||
if seen[valFD.Number()] { |
||||
return p.errorf("Any message unpacked multiple times, or %q already set", valFD.Name()) |
||||
} |
||||
m.Set(urlFD, protoreflect.ValueOfString(name)) |
||||
m.Set(valFD, protoreflect.ValueOfBytes(b)) |
||||
seen[urlFD.Number()] = true |
||||
seen[valFD.Number()] = true |
||||
return nil |
||||
} |
||||
|
||||
xname := protoreflect.FullName(name) |
||||
xt, _ := protoregistry.GlobalTypes.FindExtensionByName(xname) |
||||
if xt == nil && isMessageSet(m.Descriptor()) { |
||||
xt, _ = protoregistry.GlobalTypes.FindExtensionByName(xname.Append("message_set_extension")) |
||||
} |
||||
if xt == nil { |
||||
return p.errorf("unrecognized extension %q", name) |
||||
} |
||||
fd := xt.TypeDescriptor() |
||||
if fd.ContainingMessage().FullName() != m.Descriptor().FullName() { |
||||
return p.errorf("extension field %q does not extend message %q", name, m.Descriptor().FullName()) |
||||
} |
||||
|
||||
if err := p.checkForColon(fd); err != nil { |
||||
return err |
||||
} |
||||
|
||||
v := m.Get(fd) |
||||
if !m.Has(fd) && (fd.IsList() || fd.IsMap() || fd.Message() != nil) { |
||||
v = m.Mutable(fd) |
||||
} |
||||
v, err = p.unmarshalValue(v, fd) |
||||
if err != nil { |
||||
return err |
||||
} |
||||
m.Set(fd, v) |
||||
return p.consumeOptionalSeparator() |
||||
} |
||||
|
||||
func (p *textParser) unmarshalValue(v protoreflect.Value, fd protoreflect.FieldDescriptor) (protoreflect.Value, error) { |
||||
tok := p.next() |
||||
if tok.err != nil { |
||||
return v, tok.err |
||||
} |
||||
if tok.value == "" { |
||||
return v, p.errorf("unexpected EOF") |
||||
} |
||||
|
||||
switch { |
||||
case fd.IsList(): |
||||
lv := v.List() |
||||
var err error |
||||
if tok.value == "[" { |
||||
// Repeated field with list notation, like [1,2,3].
|
||||
for { |
||||
vv := lv.NewElement() |
||||
vv, err = p.unmarshalSingularValue(vv, fd) |
||||
if err != nil { |
||||
return v, err |
||||
} |
||||
lv.Append(vv) |
||||
|
||||
tok := p.next() |
||||
if tok.err != nil { |
||||
return v, tok.err |
||||
} |
||||
if tok.value == "]" { |
||||
break |
||||
} |
||||
if tok.value != "," { |
||||
return v, p.errorf("Expected ']' or ',' found %q", tok.value) |
||||
} |
||||
} |
||||
return v, nil |
||||
} |
||||
|
||||
// One value of the repeated field.
|
||||
p.back() |
||||
vv := lv.NewElement() |
||||
vv, err = p.unmarshalSingularValue(vv, fd) |
||||
if err != nil { |
||||
return v, err |
||||
} |
||||
lv.Append(vv) |
||||
return v, nil |
||||
case fd.IsMap(): |
||||
// The map entry should be this sequence of tokens:
|
||||
// < key : KEY value : VALUE >
|
||||
// However, implementations may omit key or value, and technically
|
||||
// we should support them in any order.
|
||||
var terminator string |
||||
switch tok.value { |
||||
case "<": |
||||
terminator = ">" |
||||
case "{": |
||||
terminator = "}" |
||||
default: |
||||
return v, p.errorf("expected '{' or '<', found %q", tok.value) |
||||
} |
||||
|
||||
keyFD := fd.MapKey() |
||||
valFD := fd.MapValue() |
||||
|
||||
mv := v.Map() |
||||
kv := keyFD.Default() |
||||
vv := mv.NewValue() |
||||
for { |
||||
tok := p.next() |
||||
if tok.err != nil { |
||||
return v, tok.err |
||||
} |
||||
if tok.value == terminator { |
||||
break |
||||
} |
||||
var err error |
||||
switch tok.value { |
||||
case "key": |
||||
if err := p.consumeToken(":"); err != nil { |
||||
return v, err |
||||
} |
||||
if kv, err = p.unmarshalSingularValue(kv, keyFD); err != nil { |
||||
return v, err |
||||
} |
||||
if err := p.consumeOptionalSeparator(); err != nil { |
||||
return v, err |
||||
} |
||||
case "value": |
||||
if err := p.checkForColon(valFD); err != nil { |
||||
return v, err |
||||
} |
||||
if vv, err = p.unmarshalSingularValue(vv, valFD); err != nil { |
||||
return v, err |
||||
} |
||||
if err := p.consumeOptionalSeparator(); err != nil { |
||||
return v, err |
||||
} |
||||
default: |
||||
p.back() |
||||
return v, p.errorf(`expected "key", "value", or %q, found %q`, terminator, tok.value) |
||||
} |
||||
} |
||||
mv.Set(kv.MapKey(), vv) |
||||
return v, nil |
||||
default: |
||||
p.back() |
||||
return p.unmarshalSingularValue(v, fd) |
||||
} |
||||
} |
||||
|
||||
func (p *textParser) unmarshalSingularValue(v protoreflect.Value, fd protoreflect.FieldDescriptor) (protoreflect.Value, error) { |
||||
tok := p.next() |
||||
if tok.err != nil { |
||||
return v, tok.err |
||||
} |
||||
if tok.value == "" { |
||||
return v, p.errorf("unexpected EOF") |
||||
} |
||||
|
||||
switch fd.Kind() { |
||||
case protoreflect.BoolKind: |
||||
switch tok.value { |
||||
case "true", "1", "t", "True": |
||||
return protoreflect.ValueOfBool(true), nil |
||||
case "false", "0", "f", "False": |
||||
return protoreflect.ValueOfBool(false), nil |
||||
} |
||||
case protoreflect.Int32Kind, protoreflect.Sint32Kind, protoreflect.Sfixed32Kind: |
||||
if x, err := strconv.ParseInt(tok.value, 0, 32); err == nil { |
||||
return protoreflect.ValueOfInt32(int32(x)), nil |
||||
} |
||||
|
||||
// The C++ parser accepts large positive hex numbers that uses
|
||||
// two's complement arithmetic to represent negative numbers.
|
||||
// This feature is here for backwards compatibility with C++.
|
||||
if strings.HasPrefix(tok.value, "0x") { |
||||
if x, err := strconv.ParseUint(tok.value, 0, 32); err == nil { |
||||
return protoreflect.ValueOfInt32(int32(-(int64(^x) + 1))), nil |
||||
} |
||||
} |
||||
case protoreflect.Int64Kind, protoreflect.Sint64Kind, protoreflect.Sfixed64Kind: |
||||
if x, err := strconv.ParseInt(tok.value, 0, 64); err == nil { |
||||
return protoreflect.ValueOfInt64(int64(x)), nil |
||||
} |
||||
|
||||
// The C++ parser accepts large positive hex numbers that uses
|
||||
// two's complement arithmetic to represent negative numbers.
|
||||
// This feature is here for backwards compatibility with C++.
|
||||
if strings.HasPrefix(tok.value, "0x") { |
||||
if x, err := strconv.ParseUint(tok.value, 0, 64); err == nil { |
||||
return protoreflect.ValueOfInt64(int64(-(int64(^x) + 1))), nil |
||||
} |
||||
} |
||||
case protoreflect.Uint32Kind, protoreflect.Fixed32Kind: |
||||
if x, err := strconv.ParseUint(tok.value, 0, 32); err == nil { |
||||
return protoreflect.ValueOfUint32(uint32(x)), nil |
||||
} |
||||
case protoreflect.Uint64Kind, protoreflect.Fixed64Kind: |
||||
if x, err := strconv.ParseUint(tok.value, 0, 64); err == nil { |
||||
return protoreflect.ValueOfUint64(uint64(x)), nil |
||||
} |
||||
case protoreflect.FloatKind: |
||||
// Ignore 'f' for compatibility with output generated by C++,
|
||||
// but don't remove 'f' when the value is "-inf" or "inf".
|
||||
v := tok.value |
||||
if strings.HasSuffix(v, "f") && v != "-inf" && v != "inf" { |
||||
v = v[:len(v)-len("f")] |
||||
} |
||||
if x, err := strconv.ParseFloat(v, 32); err == nil { |
||||
return protoreflect.ValueOfFloat32(float32(x)), nil |
||||
} |
||||
case protoreflect.DoubleKind: |
||||
// Ignore 'f' for compatibility with output generated by C++,
|
||||
// but don't remove 'f' when the value is "-inf" or "inf".
|
||||
v := tok.value |
||||
if strings.HasSuffix(v, "f") && v != "-inf" && v != "inf" { |
||||
v = v[:len(v)-len("f")] |
||||
} |
||||
if x, err := strconv.ParseFloat(v, 64); err == nil { |
||||
return protoreflect.ValueOfFloat64(float64(x)), nil |
||||
} |
||||
case protoreflect.StringKind: |
||||
if isQuote(tok.value[0]) { |
||||
return protoreflect.ValueOfString(tok.unquoted), nil |
||||
} |
||||
case protoreflect.BytesKind: |
||||
if isQuote(tok.value[0]) { |
||||
return protoreflect.ValueOfBytes([]byte(tok.unquoted)), nil |
||||
} |
||||
case protoreflect.EnumKind: |
||||
if x, err := strconv.ParseInt(tok.value, 0, 32); err == nil { |
||||
return protoreflect.ValueOfEnum(protoreflect.EnumNumber(x)), nil |
||||
} |
||||
vd := fd.Enum().Values().ByName(protoreflect.Name(tok.value)) |
||||
if vd != nil { |
||||
return protoreflect.ValueOfEnum(vd.Number()), nil |
||||
} |
||||
case protoreflect.MessageKind, protoreflect.GroupKind: |
||||
var terminator string |
||||
switch tok.value { |
||||
case "{": |
||||
terminator = "}" |
||||
case "<": |
||||
terminator = ">" |
||||
default: |
||||
return v, p.errorf("expected '{' or '<', found %q", tok.value) |
||||
} |
||||
err := p.unmarshalMessage(v.Message(), terminator) |
||||
return v, err |
||||
default: |
||||
panic(fmt.Sprintf("invalid kind %v", fd.Kind())) |
||||
} |
||||
return v, p.errorf("invalid %v: %v", fd.Kind(), tok.value) |
||||
} |
||||
|
||||
// Consume a ':' from the input stream (if the next token is a colon),
|
||||
// returning an error if a colon is needed but not present.
|
||||
func (p *textParser) checkForColon(fd protoreflect.FieldDescriptor) *ParseError { |
||||
tok := p.next() |
||||
if tok.err != nil { |
||||
return tok.err |
||||
} |
||||
if tok.value != ":" { |
||||
if fd.Message() == nil { |
||||
return p.errorf("expected ':', found %q", tok.value) |
||||
} |
||||
p.back() |
||||
} |
||||
return nil |
||||
} |
||||
|
||||
// consumeExtensionOrAnyName consumes an extension name or an Any type URL and
|
||||
// the following ']'. It returns the name or URL consumed.
|
||||
func (p *textParser) consumeExtensionOrAnyName() (string, error) { |
||||
tok := p.next() |
||||
if tok.err != nil { |
||||
return "", tok.err |
||||
} |
||||
|
||||
// If extension name or type url is quoted, it's a single token.
|
||||
if len(tok.value) > 2 && isQuote(tok.value[0]) && tok.value[len(tok.value)-1] == tok.value[0] { |
||||
name, err := unquoteC(tok.value[1:len(tok.value)-1], rune(tok.value[0])) |
||||
if err != nil { |
||||
return "", err |
||||
} |
||||
return name, p.consumeToken("]") |
||||
} |
||||
|
||||
// Consume everything up to "]"
|
||||
var parts []string |
||||
for tok.value != "]" { |
||||
parts = append(parts, tok.value) |
||||
tok = p.next() |
||||
if tok.err != nil { |
||||
return "", p.errorf("unrecognized type_url or extension name: %s", tok.err) |
||||
} |
||||
if p.done && tok.value != "]" { |
||||
return "", p.errorf("unclosed type_url or extension name") |
||||
} |
||||
} |
||||
return strings.Join(parts, ""), nil |
||||
} |
||||
|
||||
// consumeOptionalSeparator consumes an optional semicolon or comma.
|
||||
// It is used in unmarshalMessage to provide backward compatibility.
|
||||
func (p *textParser) consumeOptionalSeparator() error { |
||||
tok := p.next() |
||||
if tok.err != nil { |
||||
return tok.err |
||||
} |
||||
if tok.value != ";" && tok.value != "," { |
||||
p.back() |
||||
} |
||||
return nil |
||||
} |
||||
|
||||
func (p *textParser) errorf(format string, a ...interface{}) *ParseError { |
||||
pe := &ParseError{fmt.Sprintf(format, a...), p.cur.line, p.cur.offset} |
||||
p.cur.err = pe |
||||
p.done = true |
||||
return pe |
||||
} |
||||
|
||||
func (p *textParser) skipWhitespace() { |
||||
i := 0 |
||||
for i < len(p.s) && (isWhitespace(p.s[i]) || p.s[i] == '#') { |
||||
if p.s[i] == '#' { |
||||
// comment; skip to end of line or input
|
||||
for i < len(p.s) && p.s[i] != '\n' { |
||||
i++ |
||||
} |
||||
if i == len(p.s) { |
||||
break |
||||
} |
||||
} |
||||
if p.s[i] == '\n' { |
||||
p.line++ |
||||
} |
||||
i++ |
||||
} |
||||
p.offset += i |
||||
p.s = p.s[i:len(p.s)] |
||||
if len(p.s) == 0 { |
||||
p.done = true |
||||
} |
||||
} |
||||
|
||||
func (p *textParser) advance() { |
||||
// Skip whitespace
|
||||
p.skipWhitespace() |
||||
if p.done { |
||||
return |
||||
} |
||||
|
||||
// Start of non-whitespace
|
||||
p.cur.err = nil |
||||
p.cur.offset, p.cur.line = p.offset, p.line |
||||
p.cur.unquoted = "" |
||||
switch p.s[0] { |
||||
case '<', '>', '{', '}', ':', '[', ']', ';', ',', '/': |
||||
// Single symbol
|
||||
p.cur.value, p.s = p.s[0:1], p.s[1:len(p.s)] |
||||
case '"', '\'': |
||||
// Quoted string
|
||||
i := 1 |
||||
for i < len(p.s) && p.s[i] != p.s[0] && p.s[i] != '\n' { |
||||
if p.s[i] == '\\' && i+1 < len(p.s) { |
||||
// skip escaped char
|
||||
i++ |
||||
} |
||||
i++ |
||||
} |
||||
if i >= len(p.s) || p.s[i] != p.s[0] { |
||||
p.errorf("unmatched quote") |
||||
return |
||||
} |
||||
unq, err := unquoteC(p.s[1:i], rune(p.s[0])) |
||||
if err != nil { |
||||
p.errorf("invalid quoted string %s: %v", p.s[0:i+1], err) |
||||
return |
||||
} |
||||
p.cur.value, p.s = p.s[0:i+1], p.s[i+1:len(p.s)] |
||||
p.cur.unquoted = unq |
||||
default: |
||||
i := 0 |
||||
for i < len(p.s) && isIdentOrNumberChar(p.s[i]) { |
||||
i++ |
||||
} |
||||
if i == 0 { |
||||
p.errorf("unexpected byte %#x", p.s[0]) |
||||
return |
||||
} |
||||
p.cur.value, p.s = p.s[0:i], p.s[i:len(p.s)] |
||||
} |
||||
p.offset += len(p.cur.value) |
||||
} |
||||
|
||||
// Back off the parser by one token. Can only be done between calls to next().
|
||||
// It makes the next advance() a no-op.
|
||||
func (p *textParser) back() { p.backed = true } |
||||
|
||||
// Advances the parser and returns the new current token.
|
||||
func (p *textParser) next() *token { |
||||
if p.backed || p.done { |
||||
p.backed = false |
||||
return &p.cur |
||||
} |
||||
p.advance() |
||||
if p.done { |
||||
p.cur.value = "" |
||||
} else if len(p.cur.value) > 0 && isQuote(p.cur.value[0]) { |
||||
// Look for multiple quoted strings separated by whitespace,
|
||||
// and concatenate them.
|
||||
cat := p.cur |
||||
for { |
||||
p.skipWhitespace() |
||||
if p.done || !isQuote(p.s[0]) { |
||||
break |
||||
} |
||||
p.advance() |
||||
if p.cur.err != nil { |
||||
return &p.cur |
||||
} |
||||
cat.value += " " + p.cur.value |
||||
cat.unquoted += p.cur.unquoted |
||||
} |
||||
p.done = false // parser may have seen EOF, but we want to return cat
|
||||
p.cur = cat |
||||
} |
||||
return &p.cur |
||||
} |
||||
|
||||
func (p *textParser) consumeToken(s string) error { |
||||
tok := p.next() |
||||
if tok.err != nil { |
||||
return tok.err |
||||
} |
||||
if tok.value != s { |
||||
p.back() |
||||
return p.errorf("expected %q, found %q", s, tok.value) |
||||
} |
||||
return nil |
||||
} |
||||
|
||||
var errBadUTF8 = errors.New("proto: bad UTF-8") |
||||
|
||||
func unquoteC(s string, quote rune) (string, error) { |
||||
// This is based on C++'s tokenizer.cc.
|
||||
// Despite its name, this is *not* parsing C syntax.
|
||||
// For instance, "\0" is an invalid quoted string.
|
||||
|
||||
// Avoid allocation in trivial cases.
|
||||
simple := true |
||||
for _, r := range s { |
||||
if r == '\\' || r == quote { |
||||
simple = false |
||||
break |
||||
} |
||||
} |
||||
if simple { |
||||
return s, nil |
||||
} |
||||
|
||||
buf := make([]byte, 0, 3*len(s)/2) |
||||
for len(s) > 0 { |
||||
r, n := utf8.DecodeRuneInString(s) |
||||
if r == utf8.RuneError && n == 1 { |
||||
return "", errBadUTF8 |
||||
} |
||||
s = s[n:] |
||||
if r != '\\' { |
||||
if r < utf8.RuneSelf { |
||||
buf = append(buf, byte(r)) |
||||
} else { |
||||
buf = append(buf, string(r)...) |
||||
} |
||||
continue |
||||
} |
||||
|
||||
ch, tail, err := unescape(s) |
||||
if err != nil { |
||||
return "", err |
||||
} |
||||
buf = append(buf, ch...) |
||||
s = tail |
||||
} |
||||
return string(buf), nil |
||||
} |
||||
|
||||
func unescape(s string) (ch string, tail string, err error) { |
||||
r, n := utf8.DecodeRuneInString(s) |
||||
if r == utf8.RuneError && n == 1 { |
||||
return "", "", errBadUTF8 |
||||
} |
||||
s = s[n:] |
||||
switch r { |
||||
case 'a': |
||||
return "\a", s, nil |
||||
case 'b': |
||||
return "\b", s, nil |
||||
case 'f': |
||||
return "\f", s, nil |
||||
case 'n': |
||||
return "\n", s, nil |
||||
case 'r': |
||||
return "\r", s, nil |
||||
case 't': |
||||
return "\t", s, nil |
||||
case 'v': |
||||
return "\v", s, nil |
||||
case '?': |
||||
return "?", s, nil // trigraph workaround
|
||||
case '\'', '"', '\\': |
||||
return string(r), s, nil |
||||
case '0', '1', '2', '3', '4', '5', '6', '7': |
||||
if len(s) < 2 { |
||||
return "", "", fmt.Errorf(`\%c requires 2 following digits`, r) |
||||
} |
||||
ss := string(r) + s[:2] |
||||
s = s[2:] |
||||
i, err := strconv.ParseUint(ss, 8, 8) |
||||
if err != nil { |
||||
return "", "", fmt.Errorf(`\%s contains non-octal digits`, ss) |
||||
} |
||||
return string([]byte{byte(i)}), s, nil |
||||
case 'x', 'X', 'u', 'U': |
||||
var n int |
||||
switch r { |
||||
case 'x', 'X': |
||||
n = 2 |
||||
case 'u': |
||||
n = 4 |
||||
case 'U': |
||||
n = 8 |
||||
} |
||||
if len(s) < n { |
||||
return "", "", fmt.Errorf(`\%c requires %d following digits`, r, n) |
||||
} |
||||
ss := s[:n] |
||||
s = s[n:] |
||||
i, err := strconv.ParseUint(ss, 16, 64) |
||||
if err != nil { |
||||
return "", "", fmt.Errorf(`\%c%s contains non-hexadecimal digits`, r, ss) |
||||
} |
||||
if r == 'x' || r == 'X' { |
||||
return string([]byte{byte(i)}), s, nil |
||||
} |
||||
if i > utf8.MaxRune { |
||||
return "", "", fmt.Errorf(`\%c%s is not a valid Unicode code point`, r, ss) |
||||
} |
||||
return string(i), s, nil |
||||
} |
||||
return "", "", fmt.Errorf(`unknown escape \%c`, r) |
||||
} |
||||
|
||||
func isIdentOrNumberChar(c byte) bool { |
||||
switch { |
||||
case 'A' <= c && c <= 'Z', 'a' <= c && c <= 'z': |
||||
return true |
||||
case '0' <= c && c <= '9': |
||||
return true |
||||
} |
||||
switch c { |
||||
case '-', '+', '.', '_': |
||||
return true |
||||
} |
||||
return false |
||||
} |
||||
|
||||
func isWhitespace(c byte) bool { |
||||
switch c { |
||||
case ' ', '\t', '\n', '\r': |
||||
return true |
||||
} |
||||
return false |
||||
} |
||||
|
||||
func isQuote(c byte) bool { |
||||
switch c { |
||||
case '"', '\'': |
||||
return true |
||||
} |
||||
return false |
||||
} |
||||
@ -0,0 +1,560 @@ |
||||
// Copyright 2010 The Go Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
package proto |
||||
|
||||
import ( |
||||
"bytes" |
||||
"encoding" |
||||
"fmt" |
||||
"io" |
||||
"math" |
||||
"sort" |
||||
"strings" |
||||
|
||||
"google.golang.org/protobuf/encoding/prototext" |
||||
"google.golang.org/protobuf/encoding/protowire" |
||||
"google.golang.org/protobuf/proto" |
||||
"google.golang.org/protobuf/reflect/protoreflect" |
||||
"google.golang.org/protobuf/reflect/protoregistry" |
||||
) |
||||
|
||||
const wrapTextMarshalV2 = false |
||||
|
||||
// TextMarshaler is a configurable text format marshaler.
|
||||
type TextMarshaler struct { |
||||
Compact bool // use compact text format (one line)
|
||||
ExpandAny bool // expand google.protobuf.Any messages of known types
|
||||
} |
||||
|
||||
// Marshal writes the proto text format of m to w.
|
||||
func (tm *TextMarshaler) Marshal(w io.Writer, m Message) error { |
||||
b, err := tm.marshal(m) |
||||
if len(b) > 0 { |
||||
if _, err := w.Write(b); err != nil { |
||||
return err |
||||
} |
||||
} |
||||
return err |
||||
} |
||||
|
||||
// Text returns a proto text formatted string of m.
|
||||
func (tm *TextMarshaler) Text(m Message) string { |
||||
b, _ := tm.marshal(m) |
||||
return string(b) |
||||
} |
||||
|
||||
func (tm *TextMarshaler) marshal(m Message) ([]byte, error) { |
||||
mr := MessageReflect(m) |
||||
if mr == nil || !mr.IsValid() { |
||||
return []byte("<nil>"), nil |
||||
} |
||||
|
||||
if wrapTextMarshalV2 { |
||||
if m, ok := m.(encoding.TextMarshaler); ok { |
||||
return m.MarshalText() |
||||
} |
||||
|
||||
opts := prototext.MarshalOptions{ |
||||
AllowPartial: true, |
||||
EmitUnknown: true, |
||||
} |
||||
if !tm.Compact { |
||||
opts.Indent = " " |
||||
} |
||||
if !tm.ExpandAny { |
||||
opts.Resolver = (*protoregistry.Types)(nil) |
||||
} |
||||
return opts.Marshal(mr.Interface()) |
||||
} else { |
||||
w := &textWriter{ |
||||
compact: tm.Compact, |
||||
expandAny: tm.ExpandAny, |
||||
complete: true, |
||||
} |
||||
|
||||
if m, ok := m.(encoding.TextMarshaler); ok { |
||||
b, err := m.MarshalText() |
||||
if err != nil { |
||||
return nil, err |
||||
} |
||||
w.Write(b) |
||||
return w.buf, nil |
||||
} |
||||
|
||||
err := w.writeMessage(mr) |
||||
return w.buf, err |
||||
} |
||||
} |
||||
|
||||
var ( |
||||
defaultTextMarshaler = TextMarshaler{} |
||||
compactTextMarshaler = TextMarshaler{Compact: true} |
||||
) |
||||
|
||||
// MarshalText writes the proto text format of m to w.
|
||||
func MarshalText(w io.Writer, pb Message) error { return defaultTextMarshaler.Marshal(w, pb) } |
||||
|
||||
// MarshalTextString returns a proto text formatted string of m.
|
||||
func MarshalTextString(pb Message) string { return defaultTextMarshaler.Text(pb) } |
||||
|
||||
// CompactText writes the compact proto text format of m to w.
|
||||
func CompactText(w io.Writer, pb Message) error { return compactTextMarshaler.Marshal(w, pb) } |
||||
|
||||
// CompactTextString returns a compact proto text formatted string of m.
|
||||
func CompactTextString(pb Message) string { return compactTextMarshaler.Text(pb) } |
||||
|
||||
var ( |
||||
newline = []byte("\n") |
||||
endBraceNewline = []byte("}\n") |
||||
posInf = []byte("inf") |
||||
negInf = []byte("-inf") |
||||
nan = []byte("nan") |
||||
) |
||||
|
||||
// textWriter is an io.Writer that tracks its indentation level.
|
||||
type textWriter struct { |
||||
compact bool // same as TextMarshaler.Compact
|
||||
expandAny bool // same as TextMarshaler.ExpandAny
|
||||
complete bool // whether the current position is a complete line
|
||||
indent int // indentation level; never negative
|
||||
buf []byte |
||||
} |
||||
|
||||
func (w *textWriter) Write(p []byte) (n int, _ error) { |
||||
newlines := bytes.Count(p, newline) |
||||
if newlines == 0 { |
||||
if !w.compact && w.complete { |
||||
w.writeIndent() |
||||
} |
||||
w.buf = append(w.buf, p...) |
||||
w.complete = false |
||||
return len(p), nil |
||||
} |
||||
|
||||
frags := bytes.SplitN(p, newline, newlines+1) |
||||
if w.compact { |
||||
for i, frag := range frags { |
||||
if i > 0 { |
||||
w.buf = append(w.buf, ' ') |
||||
n++ |
||||
} |
||||
w.buf = append(w.buf, frag...) |
||||
n += len(frag) |
||||
} |
||||
return n, nil |
||||
} |
||||
|
||||
for i, frag := range frags { |
||||
if w.complete { |
||||
w.writeIndent() |
||||
} |
||||
w.buf = append(w.buf, frag...) |
||||
n += len(frag) |
||||
if i+1 < len(frags) { |
||||
w.buf = append(w.buf, '\n') |
||||
n++ |
||||
} |
||||
} |
||||
w.complete = len(frags[len(frags)-1]) == 0 |
||||
return n, nil |
||||
} |
||||
|
||||
func (w *textWriter) WriteByte(c byte) error { |
||||
if w.compact && c == '\n' { |
||||
c = ' ' |
||||
} |
||||
if !w.compact && w.complete { |
||||
w.writeIndent() |
||||
} |
||||
w.buf = append(w.buf, c) |
||||
w.complete = c == '\n' |
||||
return nil |
||||
} |
||||
|
||||
func (w *textWriter) writeName(fd protoreflect.FieldDescriptor) { |
||||
if !w.compact && w.complete { |
||||
w.writeIndent() |
||||
} |
||||
w.complete = false |
||||
|
||||
if fd.Kind() != protoreflect.GroupKind { |
||||
w.buf = append(w.buf, fd.Name()...) |
||||
w.WriteByte(':') |
||||
} else { |
||||
// Use message type name for group field name.
|
||||
w.buf = append(w.buf, fd.Message().Name()...) |
||||
} |
||||
|
||||
if !w.compact { |
||||
w.WriteByte(' ') |
||||
} |
||||
} |
||||
|
||||
func requiresQuotes(u string) bool { |
||||
// When type URL contains any characters except [0-9A-Za-z./\-]*, it must be quoted.
|
||||
for _, ch := range u { |
||||
switch { |
||||
case ch == '.' || ch == '/' || ch == '_': |
||||
continue |
||||
case '0' <= ch && ch <= '9': |
||||
continue |
||||
case 'A' <= ch && ch <= 'Z': |
||||
continue |
||||
case 'a' <= ch && ch <= 'z': |
||||
continue |
||||
default: |
||||
return true |
||||
} |
||||
} |
||||
return false |
||||
} |
||||
|
||||
// writeProto3Any writes an expanded google.protobuf.Any message.
|
||||
//
|
||||
// It returns (false, nil) if sv value can't be unmarshaled (e.g. because
|
||||
// required messages are not linked in).
|
||||
//
|
||||
// It returns (true, error) when sv was written in expanded format or an error
|
||||
// was encountered.
|
||||
func (w *textWriter) writeProto3Any(m protoreflect.Message) (bool, error) { |
||||
md := m.Descriptor() |
||||
fdURL := md.Fields().ByName("type_url") |
||||
fdVal := md.Fields().ByName("value") |
||||
|
||||
url := m.Get(fdURL).String() |
||||
mt, err := protoregistry.GlobalTypes.FindMessageByURL(url) |
||||
if err != nil { |
||||
return false, nil |
||||
} |
||||
|
||||
b := m.Get(fdVal).Bytes() |
||||
m2 := mt.New() |
||||
if err := proto.Unmarshal(b, m2.Interface()); err != nil { |
||||
return false, nil |
||||
} |
||||
w.Write([]byte("[")) |
||||
if requiresQuotes(url) { |
||||
w.writeQuotedString(url) |
||||
} else { |
||||
w.Write([]byte(url)) |
||||
} |
||||
if w.compact { |
||||
w.Write([]byte("]:<")) |
||||
} else { |
||||
w.Write([]byte("]: <\n")) |
||||
w.indent++ |
||||
} |
||||
if err := w.writeMessage(m2); err != nil { |
||||
return true, err |
||||
} |
||||
if w.compact { |
||||
w.Write([]byte("> ")) |
||||
} else { |
||||
w.indent-- |
||||
w.Write([]byte(">\n")) |
||||
} |
||||
return true, nil |
||||
} |
||||
|
||||
func (w *textWriter) writeMessage(m protoreflect.Message) error { |
||||
md := m.Descriptor() |
||||
if w.expandAny && md.FullName() == "google.protobuf.Any" { |
||||
if canExpand, err := w.writeProto3Any(m); canExpand { |
||||
return err |
||||
} |
||||
} |
||||
|
||||
fds := md.Fields() |
||||
for i := 0; i < fds.Len(); { |
||||
fd := fds.Get(i) |
||||
if od := fd.ContainingOneof(); od != nil { |
||||
fd = m.WhichOneof(od) |
||||
i += od.Fields().Len() |
||||
} else { |
||||
i++ |
||||
} |
||||
if fd == nil || !m.Has(fd) { |
||||
continue |
||||
} |
||||
|
||||
switch { |
||||
case fd.IsList(): |
||||
lv := m.Get(fd).List() |
||||
for j := 0; j < lv.Len(); j++ { |
||||
w.writeName(fd) |
||||
v := lv.Get(j) |
||||
if err := w.writeSingularValue(v, fd); err != nil { |
||||
return err |
||||
} |
||||
w.WriteByte('\n') |
||||
} |
||||
case fd.IsMap(): |
||||
kfd := fd.MapKey() |
||||
vfd := fd.MapValue() |
||||
mv := m.Get(fd).Map() |
||||
|
||||
type entry struct{ key, val protoreflect.Value } |
||||
var entries []entry |
||||
mv.Range(func(k protoreflect.MapKey, v protoreflect.Value) bool { |
||||
entries = append(entries, entry{k.Value(), v}) |
||||
return true |
||||
}) |
||||
sort.Slice(entries, func(i, j int) bool { |
||||
switch kfd.Kind() { |
||||
case protoreflect.BoolKind: |
||||
return !entries[i].key.Bool() && entries[j].key.Bool() |
||||
case protoreflect.Int32Kind, protoreflect.Sint32Kind, protoreflect.Sfixed32Kind, protoreflect.Int64Kind, protoreflect.Sint64Kind, protoreflect.Sfixed64Kind: |
||||
return entries[i].key.Int() < entries[j].key.Int() |
||||
case protoreflect.Uint32Kind, protoreflect.Fixed32Kind, protoreflect.Uint64Kind, protoreflect.Fixed64Kind: |
||||
return entries[i].key.Uint() < entries[j].key.Uint() |
||||
case protoreflect.StringKind: |
||||
return entries[i].key.String() < entries[j].key.String() |
||||
default: |
||||
panic("invalid kind") |
||||
} |
||||
}) |
||||
for _, entry := range entries { |
||||
w.writeName(fd) |
||||
w.WriteByte('<') |
||||
if !w.compact { |
||||
w.WriteByte('\n') |
||||
} |
||||
w.indent++ |
||||
w.writeName(kfd) |
||||
if err := w.writeSingularValue(entry.key, kfd); err != nil { |
||||
return err |
||||
} |
||||
w.WriteByte('\n') |
||||
w.writeName(vfd) |
||||
if err := w.writeSingularValue(entry.val, vfd); err != nil { |
||||
return err |
||||
} |
||||
w.WriteByte('\n') |
||||
w.indent-- |
||||
w.WriteByte('>') |
||||
w.WriteByte('\n') |
||||
} |
||||
default: |
||||
w.writeName(fd) |
||||
if err := w.writeSingularValue(m.Get(fd), fd); err != nil { |
||||
return err |
||||
} |
||||
w.WriteByte('\n') |
||||
} |
||||
} |
||||
|
||||
if b := m.GetUnknown(); len(b) > 0 { |
||||
w.writeUnknownFields(b) |
||||
} |
||||
return w.writeExtensions(m) |
||||
} |
||||
|
||||
func (w *textWriter) writeSingularValue(v protoreflect.Value, fd protoreflect.FieldDescriptor) error { |
||||
switch fd.Kind() { |
||||
case protoreflect.FloatKind, protoreflect.DoubleKind: |
||||
switch vf := v.Float(); { |
||||
case math.IsInf(vf, +1): |
||||
w.Write(posInf) |
||||
case math.IsInf(vf, -1): |
||||
w.Write(negInf) |
||||
case math.IsNaN(vf): |
||||
w.Write(nan) |
||||
default: |
||||
fmt.Fprint(w, v.Interface()) |
||||
} |
||||
case protoreflect.StringKind: |
||||
// NOTE: This does not validate UTF-8 for historical reasons.
|
||||
w.writeQuotedString(string(v.String())) |
||||
case protoreflect.BytesKind: |
||||
w.writeQuotedString(string(v.Bytes())) |
||||
case protoreflect.MessageKind, protoreflect.GroupKind: |
||||
var bra, ket byte = '<', '>' |
||||
if fd.Kind() == protoreflect.GroupKind { |
||||
bra, ket = '{', '}' |
||||
} |
||||
w.WriteByte(bra) |
||||
if !w.compact { |
||||
w.WriteByte('\n') |
||||
} |
||||
w.indent++ |
||||
m := v.Message() |
||||
if m2, ok := m.Interface().(encoding.TextMarshaler); ok { |
||||
b, err := m2.MarshalText() |
||||
if err != nil { |
||||
return err |
||||
} |
||||
w.Write(b) |
||||
} else { |
||||
w.writeMessage(m) |
||||
} |
||||
w.indent-- |
||||
w.WriteByte(ket) |
||||
case protoreflect.EnumKind: |
||||
if ev := fd.Enum().Values().ByNumber(v.Enum()); ev != nil { |
||||
fmt.Fprint(w, ev.Name()) |
||||
} else { |
||||
fmt.Fprint(w, v.Enum()) |
||||
} |
||||
default: |
||||
fmt.Fprint(w, v.Interface()) |
||||
} |
||||
return nil |
||||
} |
||||
|
||||
// writeQuotedString writes a quoted string in the protocol buffer text format.
|
||||
func (w *textWriter) writeQuotedString(s string) { |
||||
w.WriteByte('"') |
||||
for i := 0; i < len(s); i++ { |
||||
switch c := s[i]; c { |
||||
case '\n': |
||||
w.buf = append(w.buf, `\n`...) |
||||
case '\r': |
||||
w.buf = append(w.buf, `\r`...) |
||||
case '\t': |
||||
w.buf = append(w.buf, `\t`...) |
||||
case '"': |
||||
w.buf = append(w.buf, `\"`...) |
||||
case '\\': |
||||
w.buf = append(w.buf, `\\`...) |
||||
default: |
||||
if isPrint := c >= 0x20 && c < 0x7f; isPrint { |
||||
w.buf = append(w.buf, c) |
||||
} else { |
||||
w.buf = append(w.buf, fmt.Sprintf(`\%03o`, c)...) |
||||
} |
||||
} |
||||
} |
||||
w.WriteByte('"') |
||||
} |
||||
|
||||
func (w *textWriter) writeUnknownFields(b []byte) { |
||||
if !w.compact { |
||||
fmt.Fprintf(w, "/* %d unknown bytes */\n", len(b)) |
||||
} |
||||
|
||||
for len(b) > 0 { |
||||
num, wtyp, n := protowire.ConsumeTag(b) |
||||
if n < 0 { |
||||
return |
||||
} |
||||
b = b[n:] |
||||
|
||||
if wtyp == protowire.EndGroupType { |
||||
w.indent-- |
||||
w.Write(endBraceNewline) |
||||
continue |
||||
} |
||||
fmt.Fprint(w, num) |
||||
if wtyp != protowire.StartGroupType { |
||||
w.WriteByte(':') |
||||
} |
||||
if !w.compact || wtyp == protowire.StartGroupType { |
||||
w.WriteByte(' ') |
||||
} |
||||
switch wtyp { |
||||
case protowire.VarintType: |
||||
v, n := protowire.ConsumeVarint(b) |
||||
if n < 0 { |
||||
return |
||||
} |
||||
b = b[n:] |
||||
fmt.Fprint(w, v) |
||||
case protowire.Fixed32Type: |
||||
v, n := protowire.ConsumeFixed32(b) |
||||
if n < 0 { |
||||
return |
||||
} |
||||
b = b[n:] |
||||
fmt.Fprint(w, v) |
||||
case protowire.Fixed64Type: |
||||
v, n := protowire.ConsumeFixed64(b) |
||||
if n < 0 { |
||||
return |
||||
} |
||||
b = b[n:] |
||||
fmt.Fprint(w, v) |
||||
case protowire.BytesType: |
||||
v, n := protowire.ConsumeBytes(b) |
||||
if n < 0 { |
||||
return |
||||
} |
||||
b = b[n:] |
||||
fmt.Fprintf(w, "%q", v) |
||||
case protowire.StartGroupType: |
||||
w.WriteByte('{') |
||||
w.indent++ |
||||
default: |
||||
fmt.Fprintf(w, "/* unknown wire type %d */", wtyp) |
||||
} |
||||
w.WriteByte('\n') |
||||
} |
||||
} |
||||
|
||||
// writeExtensions writes all the extensions in m.
|
||||
func (w *textWriter) writeExtensions(m protoreflect.Message) error { |
||||
md := m.Descriptor() |
||||
if md.ExtensionRanges().Len() == 0 { |
||||
return nil |
||||
} |
||||
|
||||
type ext struct { |
||||
desc protoreflect.FieldDescriptor |
||||
val protoreflect.Value |
||||
} |
||||
var exts []ext |
||||
m.Range(func(fd protoreflect.FieldDescriptor, v protoreflect.Value) bool { |
||||
if fd.IsExtension() { |
||||
exts = append(exts, ext{fd, v}) |
||||
} |
||||
return true |
||||
}) |
||||
sort.Slice(exts, func(i, j int) bool { |
||||
return exts[i].desc.Number() < exts[j].desc.Number() |
||||
}) |
||||
|
||||
for _, ext := range exts { |
||||
// For message set, use the name of the message as the extension name.
|
||||
name := string(ext.desc.FullName()) |
||||
if isMessageSet(ext.desc.ContainingMessage()) { |
||||
name = strings.TrimSuffix(name, ".message_set_extension") |
||||
} |
||||
|
||||
if !ext.desc.IsList() { |
||||
if err := w.writeSingularExtension(name, ext.val, ext.desc); err != nil { |
||||
return err |
||||
} |
||||
} else { |
||||
lv := ext.val.List() |
||||
for i := 0; i < lv.Len(); i++ { |
||||
if err := w.writeSingularExtension(name, lv.Get(i), ext.desc); err != nil { |
||||
return err |
||||
} |
||||
} |
||||
} |
||||
} |
||||
return nil |
||||
} |
||||
|
||||
func (w *textWriter) writeSingularExtension(name string, v protoreflect.Value, fd protoreflect.FieldDescriptor) error { |
||||
fmt.Fprintf(w, "[%s]:", name) |
||||
if !w.compact { |
||||
w.WriteByte(' ') |
||||
} |
||||
if err := w.writeSingularValue(v, fd); err != nil { |
||||
return err |
||||
} |
||||
w.WriteByte('\n') |
||||
return nil |
||||
} |
||||
|
||||
func (w *textWriter) writeIndent() { |
||||
if !w.complete { |
||||
return |
||||
} |
||||
for i := 0; i < w.indent*2; i++ { |
||||
w.buf = append(w.buf, ' ') |
||||
} |
||||
w.complete = false |
||||
} |
||||
@ -1,880 +0,0 @@ |
||||
// Go support for Protocol Buffers - Google's data interchange format
|
||||
//
|
||||
// Copyright 2010 The Go Authors. All rights reserved.
|
||||
// https://github.com/golang/protobuf
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are
|
||||
// met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following disclaimer
|
||||
// in the documentation and/or other materials provided with the
|
||||
// distribution.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
package proto |
||||
|
||||
// Functions for parsing the Text protocol buffer format.
|
||||
// TODO: message sets.
|
||||
|
||||
import ( |
||||
"encoding" |
||||
"errors" |
||||
"fmt" |
||||
"reflect" |
||||
"strconv" |
||||
"strings" |
||||
"unicode/utf8" |
||||
) |
||||
|
||||
// Error string emitted when deserializing Any and fields are already set
|
||||
const anyRepeatedlyUnpacked = "Any message unpacked multiple times, or %q already set" |
||||
|
||||
type ParseError struct { |
||||
Message string |
||||
Line int // 1-based line number
|
||||
Offset int // 0-based byte offset from start of input
|
||||
} |
||||
|
||||
func (p *ParseError) Error() string { |
||||
if p.Line == 1 { |
||||
// show offset only for first line
|
||||
return fmt.Sprintf("line 1.%d: %v", p.Offset, p.Message) |
||||
} |
||||
return fmt.Sprintf("line %d: %v", p.Line, p.Message) |
||||
} |
||||
|
||||
type token struct { |
||||
value string |
||||
err *ParseError |
||||
line int // line number
|
||||
offset int // byte number from start of input, not start of line
|
||||
unquoted string // the unquoted version of value, if it was a quoted string
|
||||
} |
||||
|
||||
func (t *token) String() string { |
||||
if t.err == nil { |
||||
return fmt.Sprintf("%q (line=%d, offset=%d)", t.value, t.line, t.offset) |
||||
} |
||||
return fmt.Sprintf("parse error: %v", t.err) |
||||
} |
||||
|
||||
type textParser struct { |
||||
s string // remaining input
|
||||
done bool // whether the parsing is finished (success or error)
|
||||
backed bool // whether back() was called
|
||||
offset, line int |
||||
cur token |
||||
} |
||||
|
||||
func newTextParser(s string) *textParser { |
||||
p := new(textParser) |
||||
p.s = s |
||||
p.line = 1 |
||||
p.cur.line = 1 |
||||
return p |
||||
} |
||||
|
||||
func (p *textParser) errorf(format string, a ...interface{}) *ParseError { |
||||
pe := &ParseError{fmt.Sprintf(format, a...), p.cur.line, p.cur.offset} |
||||
p.cur.err = pe |
||||
p.done = true |
||||
return pe |
||||
} |
||||
|
||||
// Numbers and identifiers are matched by [-+._A-Za-z0-9]
|
||||
func isIdentOrNumberChar(c byte) bool { |
||||
switch { |
||||
case 'A' <= c && c <= 'Z', 'a' <= c && c <= 'z': |
||||
return true |
||||
case '0' <= c && c <= '9': |
||||
return true |
||||
} |
||||
switch c { |
||||
case '-', '+', '.', '_': |
||||
return true |
||||
} |
||||
return false |
||||
} |
||||
|
||||
func isWhitespace(c byte) bool { |
||||
switch c { |
||||
case ' ', '\t', '\n', '\r': |
||||
return true |
||||
} |
||||
return false |
||||
} |
||||
|
||||
func isQuote(c byte) bool { |
||||
switch c { |
||||
case '"', '\'': |
||||
return true |
||||
} |
||||
return false |
||||
} |
||||
|
||||
func (p *textParser) skipWhitespace() { |
||||
i := 0 |
||||
for i < len(p.s) && (isWhitespace(p.s[i]) || p.s[i] == '#') { |
||||
if p.s[i] == '#' { |
||||
// comment; skip to end of line or input
|
||||
for i < len(p.s) && p.s[i] != '\n' { |
||||
i++ |
||||
} |
||||
if i == len(p.s) { |
||||
break |
||||
} |
||||
} |
||||
if p.s[i] == '\n' { |
||||
p.line++ |
||||
} |
||||
i++ |
||||
} |
||||
p.offset += i |
||||
p.s = p.s[i:len(p.s)] |
||||
if len(p.s) == 0 { |
||||
p.done = true |
||||
} |
||||
} |
||||
|
||||
func (p *textParser) advance() { |
||||
// Skip whitespace
|
||||
p.skipWhitespace() |
||||
if p.done { |
||||
return |
||||
} |
||||
|
||||
// Start of non-whitespace
|
||||
p.cur.err = nil |
||||
p.cur.offset, p.cur.line = p.offset, p.line |
||||
p.cur.unquoted = "" |
||||
switch p.s[0] { |
||||
case '<', '>', '{', '}', ':', '[', ']', ';', ',', '/': |
||||
// Single symbol
|
||||
p.cur.value, p.s = p.s[0:1], p.s[1:len(p.s)] |
||||
case '"', '\'': |
||||
// Quoted string
|
||||
i := 1 |
||||
for i < len(p.s) && p.s[i] != p.s[0] && p.s[i] != '\n' { |
||||
if p.s[i] == '\\' && i+1 < len(p.s) { |
||||
// skip escaped char
|
||||
i++ |
||||
} |
||||
i++ |
||||
} |
||||
if i >= len(p.s) || p.s[i] != p.s[0] { |
||||
p.errorf("unmatched quote") |
||||
return |
||||
} |
||||
unq, err := unquoteC(p.s[1:i], rune(p.s[0])) |
||||
if err != nil { |
||||
p.errorf("invalid quoted string %s: %v", p.s[0:i+1], err) |
||||
return |
||||
} |
||||
p.cur.value, p.s = p.s[0:i+1], p.s[i+1:len(p.s)] |
||||
p.cur.unquoted = unq |
||||
default: |
||||
i := 0 |
||||
for i < len(p.s) && isIdentOrNumberChar(p.s[i]) { |
||||
i++ |
||||
} |
||||
if i == 0 { |
||||
p.errorf("unexpected byte %#x", p.s[0]) |
||||
return |
||||
} |
||||
p.cur.value, p.s = p.s[0:i], p.s[i:len(p.s)] |
||||
} |
||||
p.offset += len(p.cur.value) |
||||
} |
||||
|
||||
var ( |
||||
errBadUTF8 = errors.New("proto: bad UTF-8") |
||||
) |
||||
|
||||
func unquoteC(s string, quote rune) (string, error) { |
||||
// This is based on C++'s tokenizer.cc.
|
||||
// Despite its name, this is *not* parsing C syntax.
|
||||
// For instance, "\0" is an invalid quoted string.
|
||||
|
||||
// Avoid allocation in trivial cases.
|
||||
simple := true |
||||
for _, r := range s { |
||||
if r == '\\' || r == quote { |
||||
simple = false |
||||
break |
||||
} |
||||
} |
||||
if simple { |
||||
return s, nil |
||||
} |
||||
|
||||
buf := make([]byte, 0, 3*len(s)/2) |
||||
for len(s) > 0 { |
||||
r, n := utf8.DecodeRuneInString(s) |
||||
if r == utf8.RuneError && n == 1 { |
||||
return "", errBadUTF8 |
||||
} |
||||
s = s[n:] |
||||
if r != '\\' { |
||||
if r < utf8.RuneSelf { |
||||
buf = append(buf, byte(r)) |
||||
} else { |
||||
buf = append(buf, string(r)...) |
||||
} |
||||
continue |
||||
} |
||||
|
||||
ch, tail, err := unescape(s) |
||||
if err != nil { |
||||
return "", err |
||||
} |
||||
buf = append(buf, ch...) |
||||
s = tail |
||||
} |
||||
return string(buf), nil |
||||
} |
||||
|
||||
func unescape(s string) (ch string, tail string, err error) { |
||||
r, n := utf8.DecodeRuneInString(s) |
||||
if r == utf8.RuneError && n == 1 { |
||||
return "", "", errBadUTF8 |
||||
} |
||||
s = s[n:] |
||||
switch r { |
||||
case 'a': |
||||
return "\a", s, nil |
||||
case 'b': |
||||
return "\b", s, nil |
||||
case 'f': |
||||
return "\f", s, nil |
||||
case 'n': |
||||
return "\n", s, nil |
||||
case 'r': |
||||
return "\r", s, nil |
||||
case 't': |
||||
return "\t", s, nil |
||||
case 'v': |
||||
return "\v", s, nil |
||||
case '?': |
||||
return "?", s, nil // trigraph workaround
|
||||
case '\'', '"', '\\': |
||||
return string(r), s, nil |
||||
case '0', '1', '2', '3', '4', '5', '6', '7': |
||||
if len(s) < 2 { |
||||
return "", "", fmt.Errorf(`\%c requires 2 following digits`, r) |
||||
} |
||||
ss := string(r) + s[:2] |
||||
s = s[2:] |
||||
i, err := strconv.ParseUint(ss, 8, 8) |
||||
if err != nil { |
||||
return "", "", fmt.Errorf(`\%s contains non-octal digits`, ss) |
||||
} |
||||
return string([]byte{byte(i)}), s, nil |
||||
case 'x', 'X', 'u', 'U': |
||||
var n int |
||||
switch r { |
||||
case 'x', 'X': |
||||
n = 2 |
||||
case 'u': |
||||
n = 4 |
||||
case 'U': |
||||
n = 8 |
||||
} |
||||
if len(s) < n { |
||||
return "", "", fmt.Errorf(`\%c requires %d following digits`, r, n) |
||||
} |
||||
ss := s[:n] |
||||
s = s[n:] |
||||
i, err := strconv.ParseUint(ss, 16, 64) |
||||
if err != nil { |
||||
return "", "", fmt.Errorf(`\%c%s contains non-hexadecimal digits`, r, ss) |
||||
} |
||||
if r == 'x' || r == 'X' { |
||||
return string([]byte{byte(i)}), s, nil |
||||
} |
||||
if i > utf8.MaxRune { |
||||
return "", "", fmt.Errorf(`\%c%s is not a valid Unicode code point`, r, ss) |
||||
} |
||||
return string(i), s, nil |
||||
} |
||||
return "", "", fmt.Errorf(`unknown escape \%c`, r) |
||||
} |
||||
|
||||
// Back off the parser by one token. Can only be done between calls to next().
|
||||
// It makes the next advance() a no-op.
|
||||
func (p *textParser) back() { p.backed = true } |
||||
|
||||
// Advances the parser and returns the new current token.
|
||||
func (p *textParser) next() *token { |
||||
if p.backed || p.done { |
||||
p.backed = false |
||||
return &p.cur |
||||
} |
||||
p.advance() |
||||
if p.done { |
||||
p.cur.value = "" |
||||
} else if len(p.cur.value) > 0 && isQuote(p.cur.value[0]) { |
||||
// Look for multiple quoted strings separated by whitespace,
|
||||
// and concatenate them.
|
||||
cat := p.cur |
||||
for { |
||||
p.skipWhitespace() |
||||
if p.done || !isQuote(p.s[0]) { |
||||
break |
||||
} |
||||
p.advance() |
||||
if p.cur.err != nil { |
||||
return &p.cur |
||||
} |
||||
cat.value += " " + p.cur.value |
||||
cat.unquoted += p.cur.unquoted |
||||
} |
||||
p.done = false // parser may have seen EOF, but we want to return cat
|
||||
p.cur = cat |
||||
} |
||||
return &p.cur |
||||
} |
||||
|
||||
func (p *textParser) consumeToken(s string) error { |
||||
tok := p.next() |
||||
if tok.err != nil { |
||||
return tok.err |
||||
} |
||||
if tok.value != s { |
||||
p.back() |
||||
return p.errorf("expected %q, found %q", s, tok.value) |
||||
} |
||||
return nil |
||||
} |
||||
|
||||
// Return a RequiredNotSetError indicating which required field was not set.
|
||||
func (p *textParser) missingRequiredFieldError(sv reflect.Value) *RequiredNotSetError { |
||||
st := sv.Type() |
||||
sprops := GetProperties(st) |
||||
for i := 0; i < st.NumField(); i++ { |
||||
if !isNil(sv.Field(i)) { |
||||
continue |
||||
} |
||||
|
||||
props := sprops.Prop[i] |
||||
if props.Required { |
||||
return &RequiredNotSetError{fmt.Sprintf("%v.%v", st, props.OrigName)} |
||||
} |
||||
} |
||||
return &RequiredNotSetError{fmt.Sprintf("%v.<unknown field name>", st)} // should not happen
|
||||
} |
||||
|
||||
// Returns the index in the struct for the named field, as well as the parsed tag properties.
|
||||
func structFieldByName(sprops *StructProperties, name string) (int, *Properties, bool) { |
||||
i, ok := sprops.decoderOrigNames[name] |
||||
if ok { |
||||
return i, sprops.Prop[i], true |
||||
} |
||||
return -1, nil, false |
||||
} |
||||
|
||||
// Consume a ':' from the input stream (if the next token is a colon),
|
||||
// returning an error if a colon is needed but not present.
|
||||
func (p *textParser) checkForColon(props *Properties, typ reflect.Type) *ParseError { |
||||
tok := p.next() |
||||
if tok.err != nil { |
||||
return tok.err |
||||
} |
||||
if tok.value != ":" { |
||||
// Colon is optional when the field is a group or message.
|
||||
needColon := true |
||||
switch props.Wire { |
||||
case "group": |
||||
needColon = false |
||||
case "bytes": |
||||
// A "bytes" field is either a message, a string, or a repeated field;
|
||||
// those three become *T, *string and []T respectively, so we can check for
|
||||
// this field being a pointer to a non-string.
|
||||
if typ.Kind() == reflect.Ptr { |
||||
// *T or *string
|
||||
if typ.Elem().Kind() == reflect.String { |
||||
break |
||||
} |
||||
} else if typ.Kind() == reflect.Slice { |
||||
// []T or []*T
|
||||
if typ.Elem().Kind() != reflect.Ptr { |
||||
break |
||||
} |
||||
} else if typ.Kind() == reflect.String { |
||||
// The proto3 exception is for a string field,
|
||||
// which requires a colon.
|
||||
break |
||||
} |
||||
needColon = false |
||||
} |
||||
if needColon { |
||||
return p.errorf("expected ':', found %q", tok.value) |
||||
} |
||||
p.back() |
||||
} |
||||
return nil |
||||
} |
||||
|
||||
func (p *textParser) readStruct(sv reflect.Value, terminator string) error { |
||||
st := sv.Type() |
||||
sprops := GetProperties(st) |
||||
reqCount := sprops.reqCount |
||||
var reqFieldErr error |
||||
fieldSet := make(map[string]bool) |
||||
// A struct is a sequence of "name: value", terminated by one of
|
||||
// '>' or '}', or the end of the input. A name may also be
|
||||
// "[extension]" or "[type/url]".
|
||||
//
|
||||
// The whole struct can also be an expanded Any message, like:
|
||||
// [type/url] < ... struct contents ... >
|
||||
for { |
||||
tok := p.next() |
||||
if tok.err != nil { |
||||
return tok.err |
||||
} |
||||
if tok.value == terminator { |
||||
break |
||||
} |
||||
if tok.value == "[" { |
||||
// Looks like an extension or an Any.
|
||||
//
|
||||
// TODO: Check whether we need to handle
|
||||
// namespace rooted names (e.g. ".something.Foo").
|
||||
extName, err := p.consumeExtName() |
||||
if err != nil { |
||||
return err |
||||
} |
||||
|
||||
if s := strings.LastIndex(extName, "/"); s >= 0 { |
||||
// If it contains a slash, it's an Any type URL.
|
||||
messageName := extName[s+1:] |
||||
mt := MessageType(messageName) |
||||
if mt == nil { |
||||
return p.errorf("unrecognized message %q in google.protobuf.Any", messageName) |
||||
} |
||||
tok = p.next() |
||||
if tok.err != nil { |
||||
return tok.err |
||||
} |
||||
// consume an optional colon
|
||||
if tok.value == ":" { |
||||
tok = p.next() |
||||
if tok.err != nil { |
||||
return tok.err |
||||
} |
||||
} |
||||
var terminator string |
||||
switch tok.value { |
||||
case "<": |
||||
terminator = ">" |
||||
case "{": |
||||
terminator = "}" |
||||
default: |
||||
return p.errorf("expected '{' or '<', found %q", tok.value) |
||||
} |
||||
v := reflect.New(mt.Elem()) |
||||
if pe := p.readStruct(v.Elem(), terminator); pe != nil { |
||||
return pe |
||||
} |
||||
b, err := Marshal(v.Interface().(Message)) |
||||
if err != nil { |
||||
return p.errorf("failed to marshal message of type %q: %v", messageName, err) |
||||
} |
||||
if fieldSet["type_url"] { |
||||
return p.errorf(anyRepeatedlyUnpacked, "type_url") |
||||
} |
||||
if fieldSet["value"] { |
||||
return p.errorf(anyRepeatedlyUnpacked, "value") |
||||
} |
||||
sv.FieldByName("TypeUrl").SetString(extName) |
||||
sv.FieldByName("Value").SetBytes(b) |
||||
fieldSet["type_url"] = true |
||||
fieldSet["value"] = true |
||||
continue |
||||
} |
||||
|
||||
var desc *ExtensionDesc |
||||
// This could be faster, but it's functional.
|
||||
// TODO: Do something smarter than a linear scan.
|
||||
for _, d := range RegisteredExtensions(reflect.New(st).Interface().(Message)) { |
||||
if d.Name == extName { |
||||
desc = d |
||||
break |
||||
} |
||||
} |
||||
if desc == nil { |
||||
return p.errorf("unrecognized extension %q", extName) |
||||
} |
||||
|
||||
props := &Properties{} |
||||
props.Parse(desc.Tag) |
||||
|
||||
typ := reflect.TypeOf(desc.ExtensionType) |
||||
if err := p.checkForColon(props, typ); err != nil { |
||||
return err |
||||
} |
||||
|
||||
rep := desc.repeated() |
||||
|
||||
// Read the extension structure, and set it in
|
||||
// the value we're constructing.
|
||||
var ext reflect.Value |
||||
if !rep { |
||||
ext = reflect.New(typ).Elem() |
||||
} else { |
||||
ext = reflect.New(typ.Elem()).Elem() |
||||
} |
||||
if err := p.readAny(ext, props); err != nil { |
||||
if _, ok := err.(*RequiredNotSetError); !ok { |
||||
return err |
||||
} |
||||
reqFieldErr = err |
||||
} |
||||
ep := sv.Addr().Interface().(Message) |
||||
if !rep { |
||||
SetExtension(ep, desc, ext.Interface()) |
||||
} else { |
||||
old, err := GetExtension(ep, desc) |
||||
var sl reflect.Value |
||||
if err == nil { |
||||
sl = reflect.ValueOf(old) // existing slice
|
||||
} else { |
||||
sl = reflect.MakeSlice(typ, 0, 1) |
||||
} |
||||
sl = reflect.Append(sl, ext) |
||||
SetExtension(ep, desc, sl.Interface()) |
||||
} |
||||
if err := p.consumeOptionalSeparator(); err != nil { |
||||
return err |
||||
} |
||||
continue |
||||
} |
||||
|
||||
// This is a normal, non-extension field.
|
||||
name := tok.value |
||||
var dst reflect.Value |
||||
fi, props, ok := structFieldByName(sprops, name) |
||||
if ok { |
||||
dst = sv.Field(fi) |
||||
} else if oop, ok := sprops.OneofTypes[name]; ok { |
||||
// It is a oneof.
|
||||
props = oop.Prop |
||||
nv := reflect.New(oop.Type.Elem()) |
||||
dst = nv.Elem().Field(0) |
||||
field := sv.Field(oop.Field) |
||||
if !field.IsNil() { |
||||
return p.errorf("field '%s' would overwrite already parsed oneof '%s'", name, sv.Type().Field(oop.Field).Name) |
||||
} |
||||
field.Set(nv) |
||||
} |
||||
if !dst.IsValid() { |
||||
return p.errorf("unknown field name %q in %v", name, st) |
||||
} |
||||
|
||||
if dst.Kind() == reflect.Map { |
||||
// Consume any colon.
|
||||
if err := p.checkForColon(props, dst.Type()); err != nil { |
||||
return err |
||||
} |
||||
|
||||
// Construct the map if it doesn't already exist.
|
||||
if dst.IsNil() { |
||||
dst.Set(reflect.MakeMap(dst.Type())) |
||||
} |
||||
key := reflect.New(dst.Type().Key()).Elem() |
||||
val := reflect.New(dst.Type().Elem()).Elem() |
||||
|
||||
// The map entry should be this sequence of tokens:
|
||||
// < key : KEY value : VALUE >
|
||||
// However, implementations may omit key or value, and technically
|
||||
// we should support them in any order. See b/28924776 for a time
|
||||
// this went wrong.
|
||||
|
||||
tok := p.next() |
||||
var terminator string |
||||
switch tok.value { |
||||
case "<": |
||||
terminator = ">" |
||||
case "{": |
||||
terminator = "}" |
||||
default: |
||||
return p.errorf("expected '{' or '<', found %q", tok.value) |
||||
} |
||||
for { |
||||
tok := p.next() |
||||
if tok.err != nil { |
||||
return tok.err |
||||
} |
||||
if tok.value == terminator { |
||||
break |
||||
} |
||||
switch tok.value { |
||||
case "key": |
||||
if err := p.consumeToken(":"); err != nil { |
||||
return err |
||||
} |
||||
if err := p.readAny(key, props.MapKeyProp); err != nil { |
||||
return err |
||||
} |
||||
if err := p.consumeOptionalSeparator(); err != nil { |
||||
return err |
||||
} |
||||
case "value": |
||||
if err := p.checkForColon(props.MapValProp, dst.Type().Elem()); err != nil { |
||||
return err |
||||
} |
||||
if err := p.readAny(val, props.MapValProp); err != nil { |
||||
return err |
||||
} |
||||
if err := p.consumeOptionalSeparator(); err != nil { |
||||
return err |
||||
} |
||||
default: |
||||
p.back() |
||||
return p.errorf(`expected "key", "value", or %q, found %q`, terminator, tok.value) |
||||
} |
||||
} |
||||
|
||||
dst.SetMapIndex(key, val) |
||||
continue |
||||
} |
||||
|
||||
// Check that it's not already set if it's not a repeated field.
|
||||
if !props.Repeated && fieldSet[name] { |
||||
return p.errorf("non-repeated field %q was repeated", name) |
||||
} |
||||
|
||||
if err := p.checkForColon(props, dst.Type()); err != nil { |
||||
return err |
||||
} |
||||
|
||||
// Parse into the field.
|
||||
fieldSet[name] = true |
||||
if err := p.readAny(dst, props); err != nil { |
||||
if _, ok := err.(*RequiredNotSetError); !ok { |
||||
return err |
||||
} |
||||
reqFieldErr = err |
||||
} |
||||
if props.Required { |
||||
reqCount-- |
||||
} |
||||
|
||||
if err := p.consumeOptionalSeparator(); err != nil { |
||||
return err |
||||
} |
||||
|
||||
} |
||||
|
||||
if reqCount > 0 { |
||||
return p.missingRequiredFieldError(sv) |
||||
} |
||||
return reqFieldErr |
||||
} |
||||
|
||||
// consumeExtName consumes extension name or expanded Any type URL and the
|
||||
// following ']'. It returns the name or URL consumed.
|
||||
func (p *textParser) consumeExtName() (string, error) { |
||||
tok := p.next() |
||||
if tok.err != nil { |
||||
return "", tok.err |
||||
} |
||||
|
||||
// If extension name or type url is quoted, it's a single token.
|
||||
if len(tok.value) > 2 && isQuote(tok.value[0]) && tok.value[len(tok.value)-1] == tok.value[0] { |
||||
name, err := unquoteC(tok.value[1:len(tok.value)-1], rune(tok.value[0])) |
||||
if err != nil { |
||||
return "", err |
||||
} |
||||
return name, p.consumeToken("]") |
||||
} |
||||
|
||||
// Consume everything up to "]"
|
||||
var parts []string |
||||
for tok.value != "]" { |
||||
parts = append(parts, tok.value) |
||||
tok = p.next() |
||||
if tok.err != nil { |
||||
return "", p.errorf("unrecognized type_url or extension name: %s", tok.err) |
||||
} |
||||
if p.done && tok.value != "]" { |
||||
return "", p.errorf("unclosed type_url or extension name") |
||||
} |
||||
} |
||||
return strings.Join(parts, ""), nil |
||||
} |
||||
|
||||
// consumeOptionalSeparator consumes an optional semicolon or comma.
|
||||
// It is used in readStruct to provide backward compatibility.
|
||||
func (p *textParser) consumeOptionalSeparator() error { |
||||
tok := p.next() |
||||
if tok.err != nil { |
||||
return tok.err |
||||
} |
||||
if tok.value != ";" && tok.value != "," { |
||||
p.back() |
||||
} |
||||
return nil |
||||
} |
||||
|
||||
func (p *textParser) readAny(v reflect.Value, props *Properties) error { |
||||
tok := p.next() |
||||
if tok.err != nil { |
||||
return tok.err |
||||
} |
||||
if tok.value == "" { |
||||
return p.errorf("unexpected EOF") |
||||
} |
||||
|
||||
switch fv := v; fv.Kind() { |
||||
case reflect.Slice: |
||||
at := v.Type() |
||||
if at.Elem().Kind() == reflect.Uint8 { |
||||
// Special case for []byte
|
||||
if tok.value[0] != '"' && tok.value[0] != '\'' { |
||||
// Deliberately written out here, as the error after
|
||||
// this switch statement would write "invalid []byte: ...",
|
||||
// which is not as user-friendly.
|
||||
return p.errorf("invalid string: %v", tok.value) |
||||
} |
||||
bytes := []byte(tok.unquoted) |
||||
fv.Set(reflect.ValueOf(bytes)) |
||||
return nil |
||||
} |
||||
// Repeated field.
|
||||
if tok.value == "[" { |
||||
// Repeated field with list notation, like [1,2,3].
|
||||
for { |
||||
fv.Set(reflect.Append(fv, reflect.New(at.Elem()).Elem())) |
||||
err := p.readAny(fv.Index(fv.Len()-1), props) |
||||
if err != nil { |
||||
return err |
||||
} |
||||
tok := p.next() |
||||
if tok.err != nil { |
||||
return tok.err |
||||
} |
||||
if tok.value == "]" { |
||||
break |
||||
} |
||||
if tok.value != "," { |
||||
return p.errorf("Expected ']' or ',' found %q", tok.value) |
||||
} |
||||
} |
||||
return nil |
||||
} |
||||
// One value of the repeated field.
|
||||
p.back() |
||||
fv.Set(reflect.Append(fv, reflect.New(at.Elem()).Elem())) |
||||
return p.readAny(fv.Index(fv.Len()-1), props) |
||||
case reflect.Bool: |
||||
// true/1/t/True or false/f/0/False.
|
||||
switch tok.value { |
||||
case "true", "1", "t", "True": |
||||
fv.SetBool(true) |
||||
return nil |
||||
case "false", "0", "f", "False": |
||||
fv.SetBool(false) |
||||
return nil |
||||
} |
||||
case reflect.Float32, reflect.Float64: |
||||
v := tok.value |
||||
// Ignore 'f' for compatibility with output generated by C++, but don't
|
||||
// remove 'f' when the value is "-inf" or "inf".
|
||||
if strings.HasSuffix(v, "f") && tok.value != "-inf" && tok.value != "inf" { |
||||
v = v[:len(v)-1] |
||||
} |
||||
if f, err := strconv.ParseFloat(v, fv.Type().Bits()); err == nil { |
||||
fv.SetFloat(f) |
||||
return nil |
||||
} |
||||
case reflect.Int32: |
||||
if x, err := strconv.ParseInt(tok.value, 0, 32); err == nil { |
||||
fv.SetInt(x) |
||||
return nil |
||||
} |
||||
|
||||
if len(props.Enum) == 0 { |
||||
break |
||||
} |
||||
m, ok := enumValueMaps[props.Enum] |
||||
if !ok { |
||||
break |
||||
} |
||||
x, ok := m[tok.value] |
||||
if !ok { |
||||
break |
||||
} |
||||
fv.SetInt(int64(x)) |
||||
return nil |
||||
case reflect.Int64: |
||||
if x, err := strconv.ParseInt(tok.value, 0, 64); err == nil { |
||||
fv.SetInt(x) |
||||
return nil |
||||
} |
||||
|
||||
case reflect.Ptr: |
||||
// A basic field (indirected through pointer), or a repeated message/group
|
||||
p.back() |
||||
fv.Set(reflect.New(fv.Type().Elem())) |
||||
return p.readAny(fv.Elem(), props) |
||||
case reflect.String: |
||||
if tok.value[0] == '"' || tok.value[0] == '\'' { |
||||
fv.SetString(tok.unquoted) |
||||
return nil |
||||
} |
||||
case reflect.Struct: |
||||
var terminator string |
||||
switch tok.value { |
||||
case "{": |
||||
terminator = "}" |
||||
case "<": |
||||
terminator = ">" |
||||
default: |
||||
return p.errorf("expected '{' or '<', found %q", tok.value) |
||||
} |
||||
// TODO: Handle nested messages which implement encoding.TextUnmarshaler.
|
||||
return p.readStruct(fv, terminator) |
||||
case reflect.Uint32: |
||||
if x, err := strconv.ParseUint(tok.value, 0, 32); err == nil { |
||||
fv.SetUint(uint64(x)) |
||||
return nil |
||||
} |
||||
case reflect.Uint64: |
||||
if x, err := strconv.ParseUint(tok.value, 0, 64); err == nil { |
||||
fv.SetUint(x) |
||||
return nil |
||||
} |
||||
} |
||||
return p.errorf("invalid %v: %v", v.Type(), tok.value) |
||||
} |
||||
|
||||
// UnmarshalText reads a protocol buffer in Text format. UnmarshalText resets pb
|
||||
// before starting to unmarshal, so any existing data in pb is always removed.
|
||||
// If a required field is not set and no other error occurs,
|
||||
// UnmarshalText returns *RequiredNotSetError.
|
||||
func UnmarshalText(s string, pb Message) error { |
||||
if um, ok := pb.(encoding.TextUnmarshaler); ok { |
||||
return um.UnmarshalText([]byte(s)) |
||||
} |
||||
pb.Reset() |
||||
v := reflect.ValueOf(pb) |
||||
return newTextParser(s).readStruct(v.Elem(), "") |
||||
} |
||||
@ -0,0 +1,78 @@ |
||||
// Copyright 2019 The Go Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
package proto |
||||
|
||||
import ( |
||||
protoV2 "google.golang.org/protobuf/proto" |
||||
"google.golang.org/protobuf/runtime/protoiface" |
||||
) |
||||
|
||||
// Size returns the size in bytes of the wire-format encoding of m.
|
||||
func Size(m Message) int { |
||||
if m == nil { |
||||
return 0 |
||||
} |
||||
mi := MessageV2(m) |
||||
return protoV2.Size(mi) |
||||
} |
||||
|
||||
// Marshal returns the wire-format encoding of m.
|
||||
func Marshal(m Message) ([]byte, error) { |
||||
b, err := marshalAppend(nil, m, false) |
||||
if b == nil { |
||||
b = zeroBytes |
||||
} |
||||
return b, err |
||||
} |
||||
|
||||
var zeroBytes = make([]byte, 0, 0) |
||||
|
||||
func marshalAppend(buf []byte, m Message, deterministic bool) ([]byte, error) { |
||||
if m == nil { |
||||
return nil, ErrNil |
||||
} |
||||
mi := MessageV2(m) |
||||
nbuf, err := protoV2.MarshalOptions{ |
||||
Deterministic: deterministic, |
||||
AllowPartial: true, |
||||
}.MarshalAppend(buf, mi) |
||||
if err != nil { |
||||
return buf, err |
||||
} |
||||
if len(buf) == len(nbuf) { |
||||
if !mi.ProtoReflect().IsValid() { |
||||
return buf, ErrNil |
||||
} |
||||
} |
||||
return nbuf, checkRequiredNotSet(mi) |
||||
} |
||||
|
||||
// Unmarshal parses a wire-format message in b and places the decoded results in m.
|
||||
//
|
||||
// Unmarshal resets m before starting to unmarshal, so any existing data in m is always
|
||||
// removed. Use UnmarshalMerge to preserve and append to existing data.
|
||||
func Unmarshal(b []byte, m Message) error { |
||||
m.Reset() |
||||
return UnmarshalMerge(b, m) |
||||
} |
||||
|
||||
// UnmarshalMerge parses a wire-format message in b and places the decoded results in m.
|
||||
func UnmarshalMerge(b []byte, m Message) error { |
||||
mi := MessageV2(m) |
||||
out, err := protoV2.UnmarshalOptions{ |
||||
AllowPartial: true, |
||||
Merge: true, |
||||
}.UnmarshalState(protoiface.UnmarshalInput{ |
||||
Buf: b, |
||||
Message: mi.ProtoReflect(), |
||||
}) |
||||
if err != nil { |
||||
return err |
||||
} |
||||
if out.Flags&protoiface.UnmarshalInitialized > 0 { |
||||
return nil |
||||
} |
||||
return checkRequiredNotSet(mi) |
||||
} |
||||
@ -0,0 +1,34 @@ |
||||
// Copyright 2019 The Go Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
package proto |
||||
|
||||
// Bool stores v in a new bool value and returns a pointer to it.
|
||||
func Bool(v bool) *bool { return &v } |
||||
|
||||
// Int stores v in a new int32 value and returns a pointer to it.
|
||||
//
|
||||
// Deprecated: Use Int32 instead.
|
||||
func Int(v int) *int32 { return Int32(int32(v)) } |
||||
|
||||
// Int32 stores v in a new int32 value and returns a pointer to it.
|
||||
func Int32(v int32) *int32 { return &v } |
||||
|
||||
// Int64 stores v in a new int64 value and returns a pointer to it.
|
||||
func Int64(v int64) *int64 { return &v } |
||||
|
||||
// Uint32 stores v in a new uint32 value and returns a pointer to it.
|
||||
func Uint32(v uint32) *uint32 { return &v } |
||||
|
||||
// Uint64 stores v in a new uint64 value and returns a pointer to it.
|
||||
func Uint64(v uint64) *uint64 { return &v } |
||||
|
||||
// Float32 stores v in a new float32 value and returns a pointer to it.
|
||||
func Float32(v float32) *float32 { return &v } |
||||
|
||||
// Float64 stores v in a new float64 value and returns a pointer to it.
|
||||
func Float64(v float64) *float64 { return &v } |
||||
|
||||
// String stores v in a new string value and returns a pointer to it.
|
||||
func String(v string) *string { return &v } |
||||
@ -1,141 +1,165 @@ |
||||
// Go support for Protocol Buffers - Google's data interchange format
|
||||
//
|
||||
// Copyright 2016 The Go Authors. All rights reserved.
|
||||
// https://github.com/golang/protobuf
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are
|
||||
// met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following disclaimer
|
||||
// in the documentation and/or other materials provided with the
|
||||
// distribution.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
// Copyright 2016 The Go Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
package ptypes |
||||
|
||||
// This file implements functions to marshal proto.Message to/from
|
||||
// google.protobuf.Any message.
|
||||
|
||||
import ( |
||||
"fmt" |
||||
"reflect" |
||||
"strings" |
||||
|
||||
"github.com/golang/protobuf/proto" |
||||
"github.com/golang/protobuf/ptypes/any" |
||||
"google.golang.org/protobuf/reflect/protoreflect" |
||||
"google.golang.org/protobuf/reflect/protoregistry" |
||||
|
||||
anypb "github.com/golang/protobuf/ptypes/any" |
||||
) |
||||
|
||||
const googleApis = "type.googleapis.com/" |
||||
const urlPrefix = "type.googleapis.com/" |
||||
|
||||
// AnyMessageName returns the name of the message contained in a google.protobuf.Any message.
|
||||
//
|
||||
// Note that regular type assertions should be done using the Is
|
||||
// function. AnyMessageName is provided for less common use cases like filtering a
|
||||
// sequence of Any messages based on a set of allowed message type names.
|
||||
func AnyMessageName(any *any.Any) (string, error) { |
||||
// AnyMessageName returns the message name contained in an anypb.Any message.
|
||||
// Most type assertions should use the Is function instead.
|
||||
func AnyMessageName(any *anypb.Any) (string, error) { |
||||
name, err := anyMessageName(any) |
||||
return string(name), err |
||||
} |
||||
func anyMessageName(any *anypb.Any) (protoreflect.FullName, error) { |
||||
if any == nil { |
||||
return "", fmt.Errorf("message is nil") |
||||
} |
||||
slash := strings.LastIndex(any.TypeUrl, "/") |
||||
if slash < 0 { |
||||
name := protoreflect.FullName(any.TypeUrl) |
||||
if i := strings.LastIndex(any.TypeUrl, "/"); i >= 0 { |
||||
name = name[i+len("/"):] |
||||
} |
||||
if !name.IsValid() { |
||||
return "", fmt.Errorf("message type url %q is invalid", any.TypeUrl) |
||||
} |
||||
return any.TypeUrl[slash+1:], nil |
||||
return name, nil |
||||
} |
||||
|
||||
// MarshalAny takes the protocol buffer and encodes it into google.protobuf.Any.
|
||||
func MarshalAny(pb proto.Message) (*any.Any, error) { |
||||
value, err := proto.Marshal(pb) |
||||
// MarshalAny marshals the given message m into an anypb.Any message.
|
||||
func MarshalAny(m proto.Message) (*anypb.Any, error) { |
||||
switch dm := m.(type) { |
||||
case DynamicAny: |
||||
m = dm.Message |
||||
case *DynamicAny: |
||||
if dm == nil { |
||||
return nil, proto.ErrNil |
||||
} |
||||
m = dm.Message |
||||
} |
||||
b, err := proto.Marshal(m) |
||||
if err != nil { |
||||
return nil, err |
||||
} |
||||
return &any.Any{TypeUrl: googleApis + proto.MessageName(pb), Value: value}, nil |
||||
} |
||||
|
||||
// DynamicAny is a value that can be passed to UnmarshalAny to automatically
|
||||
// allocate a proto.Message for the type specified in a google.protobuf.Any
|
||||
// message. The allocated message is stored in the embedded proto.Message.
|
||||
//
|
||||
// Example:
|
||||
//
|
||||
// var x ptypes.DynamicAny
|
||||
// if err := ptypes.UnmarshalAny(a, &x); err != nil { ... }
|
||||
// fmt.Printf("unmarshaled message: %v", x.Message)
|
||||
type DynamicAny struct { |
||||
proto.Message |
||||
return &anypb.Any{TypeUrl: urlPrefix + proto.MessageName(m), Value: b}, nil |
||||
} |
||||
|
||||
// Empty returns a new proto.Message of the type specified in a
|
||||
// google.protobuf.Any message. It returns an error if corresponding message
|
||||
// type isn't linked in.
|
||||
func Empty(any *any.Any) (proto.Message, error) { |
||||
aname, err := AnyMessageName(any) |
||||
// Empty returns a new message of the type specified in an anypb.Any message.
|
||||
// It returns protoregistry.NotFound if the corresponding message type could not
|
||||
// be resolved in the global registry.
|
||||
func Empty(any *anypb.Any) (proto.Message, error) { |
||||
name, err := anyMessageName(any) |
||||
if err != nil { |
||||
return nil, err |
||||
} |
||||
|
||||
t := proto.MessageType(aname) |
||||
if t == nil { |
||||
return nil, fmt.Errorf("any: message type %q isn't linked in", aname) |
||||
mt, err := protoregistry.GlobalTypes.FindMessageByName(name) |
||||
if err != nil { |
||||
return nil, err |
||||
} |
||||
return reflect.New(t.Elem()).Interface().(proto.Message), nil |
||||
return proto.MessageV1(mt.New().Interface()), nil |
||||
} |
||||
|
||||
// UnmarshalAny parses the protocol buffer representation in a google.protobuf.Any
|
||||
// message and places the decoded result in pb. It returns an error if type of
|
||||
// contents of Any message does not match type of pb message.
|
||||
// UnmarshalAny unmarshals the encoded value contained in the anypb.Any message
|
||||
// into the provided message m. It returns an error if the target message
|
||||
// does not match the type in the Any message or if an unmarshal error occurs.
|
||||
//
|
||||
// pb can be a proto.Message, or a *DynamicAny.
|
||||
func UnmarshalAny(any *any.Any, pb proto.Message) error { |
||||
if d, ok := pb.(*DynamicAny); ok { |
||||
if d.Message == nil { |
||||
// The target message m may be a *DynamicAny message. If the underlying message
|
||||
// type could not be resolved, then this returns protoregistry.NotFound.
|
||||
func UnmarshalAny(any *anypb.Any, m proto.Message) error { |
||||
if dm, ok := m.(*DynamicAny); ok { |
||||
if dm.Message == nil { |
||||
var err error |
||||
d.Message, err = Empty(any) |
||||
dm.Message, err = Empty(any) |
||||
if err != nil { |
||||
return err |
||||
} |
||||
} |
||||
return UnmarshalAny(any, d.Message) |
||||
m = dm.Message |
||||
} |
||||
|
||||
aname, err := AnyMessageName(any) |
||||
anyName, err := AnyMessageName(any) |
||||
if err != nil { |
||||
return err |
||||
} |
||||
|
||||
mname := proto.MessageName(pb) |
||||
if aname != mname { |
||||
return fmt.Errorf("mismatched message type: got %q want %q", aname, mname) |
||||
msgName := proto.MessageName(m) |
||||
if anyName != msgName { |
||||
return fmt.Errorf("mismatched message type: got %q want %q", anyName, msgName) |
||||
} |
||||
return proto.Unmarshal(any.Value, pb) |
||||
return proto.Unmarshal(any.Value, m) |
||||
} |
||||
|
||||
// Is returns true if any value contains a given message type.
|
||||
func Is(any *any.Any, pb proto.Message) bool { |
||||
// The following is equivalent to AnyMessageName(any) == proto.MessageName(pb),
|
||||
// but it avoids scanning TypeUrl for the slash.
|
||||
if any == nil { |
||||
// Is reports whether the Any message contains a message of the specified type.
|
||||
func Is(any *anypb.Any, m proto.Message) bool { |
||||
if any == nil || m == nil { |
||||
return false |
||||
} |
||||
name := proto.MessageName(pb) |
||||
prefix := len(any.TypeUrl) - len(name) |
||||
return prefix >= 1 && any.TypeUrl[prefix-1] == '/' && any.TypeUrl[prefix:] == name |
||||
name := proto.MessageName(m) |
||||
if !strings.HasSuffix(any.TypeUrl, name) { |
||||
return false |
||||
} |
||||
return len(any.TypeUrl) == len(name) || any.TypeUrl[len(any.TypeUrl)-len(name)-1] == '/' |
||||
} |
||||
|
||||
// DynamicAny is a value that can be passed to UnmarshalAny to automatically
|
||||
// allocate a proto.Message for the type specified in an anypb.Any message.
|
||||
// The allocated message is stored in the embedded proto.Message.
|
||||
//
|
||||
// Example:
|
||||
// var x ptypes.DynamicAny
|
||||
// if err := ptypes.UnmarshalAny(a, &x); err != nil { ... }
|
||||
// fmt.Printf("unmarshaled message: %v", x.Message)
|
||||
type DynamicAny struct{ proto.Message } |
||||
|
||||
func (m DynamicAny) String() string { |
||||
if m.Message == nil { |
||||
return "<nil>" |
||||
} |
||||
return m.Message.String() |
||||
} |
||||
func (m DynamicAny) Reset() { |
||||
if m.Message == nil { |
||||
return |
||||
} |
||||
m.Message.Reset() |
||||
} |
||||
func (m DynamicAny) ProtoMessage() { |
||||
return |
||||
} |
||||
func (m DynamicAny) ProtoReflect() protoreflect.Message { |
||||
if m.Message == nil { |
||||
return nil |
||||
} |
||||
return dynamicAny{proto.MessageReflect(m.Message)} |
||||
} |
||||
|
||||
type dynamicAny struct{ protoreflect.Message } |
||||
|
||||
func (m dynamicAny) Type() protoreflect.MessageType { |
||||
return dynamicAnyType{m.Message.Type()} |
||||
} |
||||
func (m dynamicAny) New() protoreflect.Message { |
||||
return dynamicAnyType{m.Message.Type()}.New() |
||||
} |
||||
func (m dynamicAny) Interface() protoreflect.ProtoMessage { |
||||
return DynamicAny{proto.MessageV1(m.Message.Interface())} |
||||
} |
||||
|
||||
type dynamicAnyType struct{ protoreflect.MessageType } |
||||
|
||||
func (t dynamicAnyType) New() protoreflect.Message { |
||||
return dynamicAny{t.MessageType.New()} |
||||
} |
||||
func (t dynamicAnyType) Zero() protoreflect.Message { |
||||
return dynamicAny{t.MessageType.Zero()} |
||||
} |
||||
|
||||
@ -1,200 +1,62 @@ |
||||
// Code generated by protoc-gen-go. DO NOT EDIT.
|
||||
// source: google/protobuf/any.proto
|
||||
// source: github.com/golang/protobuf/ptypes/any/any.proto
|
||||
|
||||
package any |
||||
|
||||
import ( |
||||
fmt "fmt" |
||||
proto "github.com/golang/protobuf/proto" |
||||
math "math" |
||||
protoreflect "google.golang.org/protobuf/reflect/protoreflect" |
||||
protoimpl "google.golang.org/protobuf/runtime/protoimpl" |
||||
anypb "google.golang.org/protobuf/types/known/anypb" |
||||
reflect "reflect" |
||||
) |
||||
|
||||
// Reference imports to suppress errors if they are not otherwise used.
|
||||
var _ = proto.Marshal |
||||
var _ = fmt.Errorf |
||||
var _ = math.Inf |
||||
// Symbols defined in public import of google/protobuf/any.proto.
|
||||
|
||||
// This is a compile-time assertion to ensure that this generated file
|
||||
// is compatible with the proto package it is being compiled against.
|
||||
// A compilation error at this line likely means your copy of the
|
||||
// proto package needs to be updated.
|
||||
const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
|
||||
type Any = anypb.Any |
||||
|
||||
// `Any` contains an arbitrary serialized protocol buffer message along with a
|
||||
// URL that describes the type of the serialized message.
|
||||
//
|
||||
// Protobuf library provides support to pack/unpack Any values in the form
|
||||
// of utility functions or additional generated methods of the Any type.
|
||||
//
|
||||
// Example 1: Pack and unpack a message in C++.
|
||||
//
|
||||
// Foo foo = ...;
|
||||
// Any any;
|
||||
// any.PackFrom(foo);
|
||||
// ...
|
||||
// if (any.UnpackTo(&foo)) {
|
||||
// ...
|
||||
// }
|
||||
//
|
||||
// Example 2: Pack and unpack a message in Java.
|
||||
//
|
||||
// Foo foo = ...;
|
||||
// Any any = Any.pack(foo);
|
||||
// ...
|
||||
// if (any.is(Foo.class)) {
|
||||
// foo = any.unpack(Foo.class);
|
||||
// }
|
||||
//
|
||||
// Example 3: Pack and unpack a message in Python.
|
||||
//
|
||||
// foo = Foo(...)
|
||||
// any = Any()
|
||||
// any.Pack(foo)
|
||||
// ...
|
||||
// if any.Is(Foo.DESCRIPTOR):
|
||||
// any.Unpack(foo)
|
||||
// ...
|
||||
//
|
||||
// Example 4: Pack and unpack a message in Go
|
||||
//
|
||||
// foo := &pb.Foo{...}
|
||||
// any, err := ptypes.MarshalAny(foo)
|
||||
// ...
|
||||
// foo := &pb.Foo{}
|
||||
// if err := ptypes.UnmarshalAny(any, foo); err != nil {
|
||||
// ...
|
||||
// }
|
||||
//
|
||||
// The pack methods provided by protobuf library will by default use
|
||||
// 'type.googleapis.com/full.type.name' as the type URL and the unpack
|
||||
// methods only use the fully qualified type name after the last '/'
|
||||
// in the type URL, for example "foo.bar.com/x/y.z" will yield type
|
||||
// name "y.z".
|
||||
//
|
||||
//
|
||||
// JSON
|
||||
// ====
|
||||
// The JSON representation of an `Any` value uses the regular
|
||||
// representation of the deserialized, embedded message, with an
|
||||
// additional field `@type` which contains the type URL. Example:
|
||||
//
|
||||
// package google.profile;
|
||||
// message Person {
|
||||
// string first_name = 1;
|
||||
// string last_name = 2;
|
||||
// }
|
||||
//
|
||||
// {
|
||||
// "@type": "type.googleapis.com/google.profile.Person",
|
||||
// "firstName": <string>,
|
||||
// "lastName": <string>
|
||||
// }
|
||||
//
|
||||
// If the embedded message type is well-known and has a custom JSON
|
||||
// representation, that representation will be embedded adding a field
|
||||
// `value` which holds the custom JSON in addition to the `@type`
|
||||
// field. Example (for message [google.protobuf.Duration][]):
|
||||
//
|
||||
// {
|
||||
// "@type": "type.googleapis.com/google.protobuf.Duration",
|
||||
// "value": "1.212s"
|
||||
// }
|
||||
//
|
||||
type Any struct { |
||||
// A URL/resource name that uniquely identifies the type of the serialized
|
||||
// protocol buffer message. The last segment of the URL's path must represent
|
||||
// the fully qualified name of the type (as in
|
||||
// `path/google.protobuf.Duration`). The name should be in a canonical form
|
||||
// (e.g., leading "." is not accepted).
|
||||
//
|
||||
// In practice, teams usually precompile into the binary all types that they
|
||||
// expect it to use in the context of Any. However, for URLs which use the
|
||||
// scheme `http`, `https`, or no scheme, one can optionally set up a type
|
||||
// server that maps type URLs to message definitions as follows:
|
||||
//
|
||||
// * If no scheme is provided, `https` is assumed.
|
||||
// * An HTTP GET on the URL must yield a [google.protobuf.Type][]
|
||||
// value in binary format, or produce an error.
|
||||
// * Applications are allowed to cache lookup results based on the
|
||||
// URL, or have them precompiled into a binary to avoid any
|
||||
// lookup. Therefore, binary compatibility needs to be preserved
|
||||
// on changes to types. (Use versioned type names to manage
|
||||
// breaking changes.)
|
||||
//
|
||||
// Note: this functionality is not currently available in the official
|
||||
// protobuf release, and it is not used for type URLs beginning with
|
||||
// type.googleapis.com.
|
||||
//
|
||||
// Schemes other than `http`, `https` (or the empty scheme) might be
|
||||
// used with implementation specific semantics.
|
||||
//
|
||||
TypeUrl string `protobuf:"bytes,1,opt,name=type_url,json=typeUrl,proto3" json:"type_url,omitempty"` |
||||
// Must be a valid serialized protocol buffer of the above specified type.
|
||||
Value []byte `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"` |
||||
XXX_NoUnkeyedLiteral struct{} `json:"-"` |
||||
XXX_unrecognized []byte `json:"-"` |
||||
XXX_sizecache int32 `json:"-"` |
||||
} |
||||
var File_github_com_golang_protobuf_ptypes_any_any_proto protoreflect.FileDescriptor |
||||
|
||||
func (m *Any) Reset() { *m = Any{} } |
||||
func (m *Any) String() string { return proto.CompactTextString(m) } |
||||
func (*Any) ProtoMessage() {} |
||||
func (*Any) Descriptor() ([]byte, []int) { |
||||
return fileDescriptor_b53526c13ae22eb4, []int{0} |
||||
var file_github_com_golang_protobuf_ptypes_any_any_proto_rawDesc = []byte{ |
||||
0x0a, 0x2f, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x6c, |
||||
0x61, 0x6e, 0x67, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x70, 0x74, 0x79, |
||||
0x70, 0x65, 0x73, 0x2f, 0x61, 0x6e, 0x79, 0x2f, 0x61, 0x6e, 0x79, 0x2e, 0x70, 0x72, 0x6f, 0x74, |
||||
0x6f, 0x1a, 0x19, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, |
||||
0x75, 0x66, 0x2f, 0x61, 0x6e, 0x79, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x42, 0x2b, 0x5a, 0x29, |
||||
0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x6c, 0x61, 0x6e, |
||||
0x67, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x70, 0x74, 0x79, 0x70, 0x65, |
||||
0x73, 0x2f, 0x61, 0x6e, 0x79, 0x3b, 0x61, 0x6e, 0x79, 0x50, 0x00, 0x62, 0x06, 0x70, 0x72, 0x6f, |
||||
0x74, 0x6f, 0x33, |
||||
} |
||||
|
||||
func (*Any) XXX_WellKnownType() string { return "Any" } |
||||
|
||||
func (m *Any) XXX_Unmarshal(b []byte) error { |
||||
return xxx_messageInfo_Any.Unmarshal(m, b) |
||||
} |
||||
func (m *Any) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
||||
return xxx_messageInfo_Any.Marshal(b, m, deterministic) |
||||
} |
||||
func (m *Any) XXX_Merge(src proto.Message) { |
||||
xxx_messageInfo_Any.Merge(m, src) |
||||
} |
||||
func (m *Any) XXX_Size() int { |
||||
return xxx_messageInfo_Any.Size(m) |
||||
} |
||||
func (m *Any) XXX_DiscardUnknown() { |
||||
xxx_messageInfo_Any.DiscardUnknown(m) |
||||
var file_github_com_golang_protobuf_ptypes_any_any_proto_goTypes = []interface{}{} |
||||
var file_github_com_golang_protobuf_ptypes_any_any_proto_depIdxs = []int32{ |
||||
0, // [0:0] is the sub-list for method output_type
|
||||
0, // [0:0] is the sub-list for method input_type
|
||||
0, // [0:0] is the sub-list for extension type_name
|
||||
0, // [0:0] is the sub-list for extension extendee
|
||||
0, // [0:0] is the sub-list for field type_name
|
||||
} |
||||
|
||||
var xxx_messageInfo_Any proto.InternalMessageInfo |
||||
|
||||
func (m *Any) GetTypeUrl() string { |
||||
if m != nil { |
||||
return m.TypeUrl |
||||
func init() { file_github_com_golang_protobuf_ptypes_any_any_proto_init() } |
||||
func file_github_com_golang_protobuf_ptypes_any_any_proto_init() { |
||||
if File_github_com_golang_protobuf_ptypes_any_any_proto != nil { |
||||
return |
||||
} |
||||
return "" |
||||
} |
||||
|
||||
func (m *Any) GetValue() []byte { |
||||
if m != nil { |
||||
return m.Value |
||||
} |
||||
return nil |
||||
} |
||||
|
||||
func init() { |
||||
proto.RegisterType((*Any)(nil), "google.protobuf.Any") |
||||
} |
||||
|
||||
func init() { proto.RegisterFile("google/protobuf/any.proto", fileDescriptor_b53526c13ae22eb4) } |
||||
|
||||
var fileDescriptor_b53526c13ae22eb4 = []byte{ |
||||
// 185 bytes of a gzipped FileDescriptorProto
|
||||
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x4c, 0xcf, 0xcf, 0x4f, |
||||
0xcf, 0x49, 0xd5, 0x2f, 0x28, 0xca, 0x2f, 0xc9, 0x4f, 0x2a, 0x4d, 0xd3, 0x4f, 0xcc, 0xab, 0xd4, |
||||
0x03, 0x73, 0x84, 0xf8, 0x21, 0x52, 0x7a, 0x30, 0x29, 0x25, 0x33, 0x2e, 0x66, 0xc7, 0xbc, 0x4a, |
||||
0x21, 0x49, 0x2e, 0x8e, 0x92, 0xca, 0x82, 0xd4, 0xf8, 0xd2, 0xa2, 0x1c, 0x09, 0x46, 0x05, 0x46, |
||||
0x0d, 0xce, 0x20, 0x76, 0x10, 0x3f, 0xb4, 0x28, 0x47, 0x48, 0x84, 0x8b, 0xb5, 0x2c, 0x31, 0xa7, |
||||
0x34, 0x55, 0x82, 0x49, 0x81, 0x51, 0x83, 0x27, 0x08, 0xc2, 0x71, 0xca, 0xe7, 0x12, 0x4e, 0xce, |
||||
0xcf, 0xd5, 0x43, 0x33, 0xce, 0x89, 0xc3, 0x31, 0xaf, 0x32, 0x00, 0xc4, 0x09, 0x60, 0x8c, 0x52, |
||||
0x4d, 0xcf, 0x2c, 0xc9, 0x28, 0x4d, 0xd2, 0x4b, 0xce, 0xcf, 0xd5, 0x4f, 0xcf, 0xcf, 0x49, 0xcc, |
||||
0x4b, 0x47, 0xb8, 0xa8, 0x00, 0x64, 0x7a, 0x31, 0xc8, 0x61, 0x8b, 0x98, 0x98, 0xdd, 0x03, 0x9c, |
||||
0x56, 0x31, 0xc9, 0xb9, 0x43, 0x8c, 0x0a, 0x80, 0x2a, 0xd1, 0x0b, 0x4f, 0xcd, 0xc9, 0xf1, 0xce, |
||||
0xcb, 0x2f, 0xcf, 0x0b, 0x01, 0x29, 0x4d, 0x62, 0x03, 0xeb, 0x35, 0x06, 0x04, 0x00, 0x00, 0xff, |
||||
0xff, 0x13, 0xf8, 0xe8, 0x42, 0xdd, 0x00, 0x00, 0x00, |
||||
type x struct{} |
||||
out := protoimpl.TypeBuilder{ |
||||
File: protoimpl.DescBuilder{ |
||||
GoPackagePath: reflect.TypeOf(x{}).PkgPath(), |
||||
RawDescriptor: file_github_com_golang_protobuf_ptypes_any_any_proto_rawDesc, |
||||
NumEnums: 0, |
||||
NumMessages: 0, |
||||
NumExtensions: 0, |
||||
NumServices: 0, |
||||
}, |
||||
GoTypes: file_github_com_golang_protobuf_ptypes_any_any_proto_goTypes, |
||||
DependencyIndexes: file_github_com_golang_protobuf_ptypes_any_any_proto_depIdxs, |
||||
}.Build() |
||||
File_github_com_golang_protobuf_ptypes_any_any_proto = out.File |
||||
file_github_com_golang_protobuf_ptypes_any_any_proto_rawDesc = nil |
||||
file_github_com_golang_protobuf_ptypes_any_any_proto_goTypes = nil |
||||
file_github_com_golang_protobuf_ptypes_any_any_proto_depIdxs = nil |
||||
} |
||||
|
||||
@ -1,154 +0,0 @@ |
||||
// Protocol Buffers - Google's data interchange format |
||||
// Copyright 2008 Google Inc. All rights reserved. |
||||
// https://developers.google.com/protocol-buffers/ |
||||
// |
||||
// Redistribution and use in source and binary forms, with or without |
||||
// modification, are permitted provided that the following conditions are |
||||
// met: |
||||
// |
||||
// * Redistributions of source code must retain the above copyright |
||||
// notice, this list of conditions and the following disclaimer. |
||||
// * Redistributions in binary form must reproduce the above |
||||
// copyright notice, this list of conditions and the following disclaimer |
||||
// in the documentation and/or other materials provided with the |
||||
// distribution. |
||||
// * Neither the name of Google Inc. nor the names of its |
||||
// contributors may be used to endorse or promote products derived from |
||||
// this software without specific prior written permission. |
||||
// |
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||
|
||||
syntax = "proto3"; |
||||
|
||||
package google.protobuf; |
||||
|
||||
option csharp_namespace = "Google.Protobuf.WellKnownTypes"; |
||||
option go_package = "github.com/golang/protobuf/ptypes/any"; |
||||
option java_package = "com.google.protobuf"; |
||||
option java_outer_classname = "AnyProto"; |
||||
option java_multiple_files = true; |
||||
option objc_class_prefix = "GPB"; |
||||
|
||||
// `Any` contains an arbitrary serialized protocol buffer message along with a |
||||
// URL that describes the type of the serialized message. |
||||
// |
||||
// Protobuf library provides support to pack/unpack Any values in the form |
||||
// of utility functions or additional generated methods of the Any type. |
||||
// |
||||
// Example 1: Pack and unpack a message in C++. |
||||
// |
||||
// Foo foo = ...; |
||||
// Any any; |
||||
// any.PackFrom(foo); |
||||
// ... |
||||
// if (any.UnpackTo(&foo)) { |
||||
// ... |
||||
// } |
||||
// |
||||
// Example 2: Pack and unpack a message in Java. |
||||
// |
||||
// Foo foo = ...; |
||||
// Any any = Any.pack(foo); |
||||
// ... |
||||
// if (any.is(Foo.class)) { |
||||
// foo = any.unpack(Foo.class); |
||||
// } |
||||
// |
||||
// Example 3: Pack and unpack a message in Python. |
||||
// |
||||
// foo = Foo(...) |
||||
// any = Any() |
||||
// any.Pack(foo) |
||||
// ... |
||||
// if any.Is(Foo.DESCRIPTOR): |
||||
// any.Unpack(foo) |
||||
// ... |
||||
// |
||||
// Example 4: Pack and unpack a message in Go |
||||
// |
||||
// foo := &pb.Foo{...} |
||||
// any, err := ptypes.MarshalAny(foo) |
||||
// ... |
||||
// foo := &pb.Foo{} |
||||
// if err := ptypes.UnmarshalAny(any, foo); err != nil { |
||||
// ... |
||||
// } |
||||
// |
||||
// The pack methods provided by protobuf library will by default use |
||||
// 'type.googleapis.com/full.type.name' as the type URL and the unpack |
||||
// methods only use the fully qualified type name after the last '/' |
||||
// in the type URL, for example "foo.bar.com/x/y.z" will yield type |
||||
// name "y.z". |
||||
// |
||||
// |
||||
// JSON |
||||
// ==== |
||||
// The JSON representation of an `Any` value uses the regular |
||||
// representation of the deserialized, embedded message, with an |
||||
// additional field `@type` which contains the type URL. Example: |
||||
// |
||||
// package google.profile; |
||||
// message Person { |
||||
// string first_name = 1; |
||||
// string last_name = 2; |
||||
// } |
||||
// |
||||
// { |
||||
// "@type": "type.googleapis.com/google.profile.Person", |
||||
// "firstName": <string>, |
||||
// "lastName": <string> |
||||
// } |
||||
// |
||||
// If the embedded message type is well-known and has a custom JSON |
||||
// representation, that representation will be embedded adding a field |
||||
// `value` which holds the custom JSON in addition to the `@type` |
||||
// field. Example (for message [google.protobuf.Duration][]): |
||||
// |
||||
// { |
||||
// "@type": "type.googleapis.com/google.protobuf.Duration", |
||||
// "value": "1.212s" |
||||
// } |
||||
// |
||||
message Any { |
||||
// A URL/resource name that uniquely identifies the type of the serialized |
||||
// protocol buffer message. The last segment of the URL's path must represent |
||||
// the fully qualified name of the type (as in |
||||
// `path/google.protobuf.Duration`). The name should be in a canonical form |
||||
// (e.g., leading "." is not accepted). |
||||
// |
||||
// In practice, teams usually precompile into the binary all types that they |
||||
// expect it to use in the context of Any. However, for URLs which use the |
||||
// scheme `http`, `https`, or no scheme, one can optionally set up a type |
||||
// server that maps type URLs to message definitions as follows: |
||||
// |
||||
// * If no scheme is provided, `https` is assumed. |
||||
// * An HTTP GET on the URL must yield a [google.protobuf.Type][] |
||||
// value in binary format, or produce an error. |
||||
// * Applications are allowed to cache lookup results based on the |
||||
// URL, or have them precompiled into a binary to avoid any |
||||
// lookup. Therefore, binary compatibility needs to be preserved |
||||
// on changes to types. (Use versioned type names to manage |
||||
// breaking changes.) |
||||
// |
||||
// Note: this functionality is not currently available in the official |
||||
// protobuf release, and it is not used for type URLs beginning with |
||||
// type.googleapis.com. |
||||
// |
||||
// Schemes other than `http`, `https` (or the empty scheme) might be |
||||
// used with implementation specific semantics. |
||||
// |
||||
string type_url = 1; |
||||
|
||||
// Must be a valid serialized protocol buffer of the above specified type. |
||||
bytes value = 2; |
||||
} |
||||
@ -1,35 +1,6 @@ |
||||
// Go support for Protocol Buffers - Google's data interchange format
|
||||
//
|
||||
// Copyright 2016 The Go Authors. All rights reserved.
|
||||
// https://github.com/golang/protobuf
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are
|
||||
// met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following disclaimer
|
||||
// in the documentation and/or other materials provided with the
|
||||
// distribution.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
// Copyright 2016 The Go Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
/* |
||||
Package ptypes contains code for interacting with well-known types. |
||||
*/ |
||||
// Package ptypes provides functionality for interacting with well-known types.
|
||||
package ptypes |
||||
|
||||
@ -1,102 +1,72 @@ |
||||
// Go support for Protocol Buffers - Google's data interchange format
|
||||
//
|
||||
// Copyright 2016 The Go Authors. All rights reserved.
|
||||
// https://github.com/golang/protobuf
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are
|
||||
// met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright
|
||||
// notice, this list of conditions and the following disclaimer.
|
||||
// * Redistributions in binary form must reproduce the above
|
||||
// copyright notice, this list of conditions and the following disclaimer
|
||||
// in the documentation and/or other materials provided with the
|
||||
// distribution.
|
||||
// * Neither the name of Google Inc. nor the names of its
|
||||
// contributors may be used to endorse or promote products derived from
|
||||
// this software without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
// Copyright 2016 The Go Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
package ptypes |
||||
|
||||
// This file implements conversions between google.protobuf.Duration
|
||||
// and time.Duration.
|
||||
|
||||
import ( |
||||
"errors" |
||||
"fmt" |
||||
"time" |
||||
|
||||
durpb "github.com/golang/protobuf/ptypes/duration" |
||||
durationpb "github.com/golang/protobuf/ptypes/duration" |
||||
) |
||||
|
||||
// Range of google.protobuf.Duration as specified in duration.proto.
|
||||
// This is about 10,000 years in seconds.
|
||||
const ( |
||||
// Range of a durpb.Duration in seconds, as specified in
|
||||
// google/protobuf/duration.proto. This is about 10,000 years in seconds.
|
||||
maxSeconds = int64(10000 * 365.25 * 24 * 60 * 60) |
||||
minSeconds = -maxSeconds |
||||
) |
||||
|
||||
// validateDuration determines whether the durpb.Duration is valid according to the
|
||||
// definition in google/protobuf/duration.proto. A valid durpb.Duration
|
||||
// may still be too large to fit into a time.Duration (the range of durpb.Duration
|
||||
// is about 10,000 years, and the range of time.Duration is about 290).
|
||||
func validateDuration(d *durpb.Duration) error { |
||||
if d == nil { |
||||
return errors.New("duration: nil Duration") |
||||
} |
||||
if d.Seconds < minSeconds || d.Seconds > maxSeconds { |
||||
return fmt.Errorf("duration: %v: seconds out of range", d) |
||||
} |
||||
if d.Nanos <= -1e9 || d.Nanos >= 1e9 { |
||||
return fmt.Errorf("duration: %v: nanos out of range", d) |
||||
} |
||||
// Seconds and Nanos must have the same sign, unless d.Nanos is zero.
|
||||
if (d.Seconds < 0 && d.Nanos > 0) || (d.Seconds > 0 && d.Nanos < 0) { |
||||
return fmt.Errorf("duration: %v: seconds and nanos have different signs", d) |
||||
} |
||||
return nil |
||||
} |
||||
|
||||
// Duration converts a durpb.Duration to a time.Duration. Duration
|
||||
// returns an error if the durpb.Duration is invalid or is too large to be
|
||||
// represented in a time.Duration.
|
||||
func Duration(p *durpb.Duration) (time.Duration, error) { |
||||
if err := validateDuration(p); err != nil { |
||||
// Duration converts a durationpb.Duration to a time.Duration.
|
||||
// Duration returns an error if dur is invalid or overflows a time.Duration.
|
||||
func Duration(dur *durationpb.Duration) (time.Duration, error) { |
||||
if err := validateDuration(dur); err != nil { |
||||
return 0, err |
||||
} |
||||
d := time.Duration(p.Seconds) * time.Second |
||||
if int64(d/time.Second) != p.Seconds { |
||||
return 0, fmt.Errorf("duration: %v is out of range for time.Duration", p) |
||||
d := time.Duration(dur.Seconds) * time.Second |
||||
if int64(d/time.Second) != dur.Seconds { |
||||
return 0, fmt.Errorf("duration: %v is out of range for time.Duration", dur) |
||||
} |
||||
if p.Nanos != 0 { |
||||
d += time.Duration(p.Nanos) * time.Nanosecond |
||||
if (d < 0) != (p.Nanos < 0) { |
||||
return 0, fmt.Errorf("duration: %v is out of range for time.Duration", p) |
||||
if dur.Nanos != 0 { |
||||
d += time.Duration(dur.Nanos) * time.Nanosecond |
||||
if (d < 0) != (dur.Nanos < 0) { |
||||
return 0, fmt.Errorf("duration: %v is out of range for time.Duration", dur) |
||||
} |
||||
} |
||||
return d, nil |
||||
} |
||||
|
||||
// DurationProto converts a time.Duration to a durpb.Duration.
|
||||
func DurationProto(d time.Duration) *durpb.Duration { |
||||
// DurationProto converts a time.Duration to a durationpb.Duration.
|
||||
func DurationProto(d time.Duration) *durationpb.Duration { |
||||
nanos := d.Nanoseconds() |
||||
secs := nanos / 1e9 |
||||
nanos -= secs * 1e9 |
||||
return &durpb.Duration{ |
||||
Seconds: secs, |
||||
return &durationpb.Duration{ |
||||
Seconds: int64(secs), |
||||
Nanos: int32(nanos), |
||||
} |
||||
} |
||||
|
||||
// validateDuration determines whether the durationpb.Duration is valid
|
||||
// according to the definition in google/protobuf/duration.proto.
|
||||
// A valid durpb.Duration may still be too large to fit into a time.Duration
|
||||
// Note that the range of durationpb.Duration is about 10,000 years,
|
||||
// while the range of time.Duration is about 290 years.
|
||||
func validateDuration(dur *durationpb.Duration) error { |
||||
if dur == nil { |
||||
return errors.New("duration: nil Duration") |
||||
} |
||||
if dur.Seconds < minSeconds || dur.Seconds > maxSeconds { |
||||
return fmt.Errorf("duration: %v: seconds out of range", dur) |
||||
} |
||||
if dur.Nanos <= -1e9 || dur.Nanos >= 1e9 { |
||||
return fmt.Errorf("duration: %v: nanos out of range", dur) |
||||
} |
||||
// Seconds and Nanos must have the same sign, unless d.Nanos is zero.
|
||||
if (dur.Seconds < 0 && dur.Nanos > 0) || (dur.Seconds > 0 && dur.Nanos < 0) { |
||||
return fmt.Errorf("duration: %v: seconds and nanos have different signs", dur) |
||||
} |
||||
return nil |
||||
} |
||||
|
||||
@ -1,161 +1,63 @@ |
||||
// Code generated by protoc-gen-go. DO NOT EDIT.
|
||||
// source: google/protobuf/duration.proto
|
||||
// source: github.com/golang/protobuf/ptypes/duration/duration.proto
|
||||
|
||||
package duration |
||||
|
||||
import ( |
||||
fmt "fmt" |
||||
proto "github.com/golang/protobuf/proto" |
||||
math "math" |
||||
protoreflect "google.golang.org/protobuf/reflect/protoreflect" |
||||
protoimpl "google.golang.org/protobuf/runtime/protoimpl" |
||||
durationpb "google.golang.org/protobuf/types/known/durationpb" |
||||
reflect "reflect" |
||||
) |
||||
|
||||
// Reference imports to suppress errors if they are not otherwise used.
|
||||
var _ = proto.Marshal |
||||
var _ = fmt.Errorf |
||||
var _ = math.Inf |
||||
// Symbols defined in public import of google/protobuf/duration.proto.
|
||||
|
||||
// This is a compile-time assertion to ensure that this generated file
|
||||
// is compatible with the proto package it is being compiled against.
|
||||
// A compilation error at this line likely means your copy of the
|
||||
// proto package needs to be updated.
|
||||
const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
|
||||
type Duration = durationpb.Duration |
||||
|
||||
// A Duration represents a signed, fixed-length span of time represented
|
||||
// as a count of seconds and fractions of seconds at nanosecond
|
||||
// resolution. It is independent of any calendar and concepts like "day"
|
||||
// or "month". It is related to Timestamp in that the difference between
|
||||
// two Timestamp values is a Duration and it can be added or subtracted
|
||||
// from a Timestamp. Range is approximately +-10,000 years.
|
||||
//
|
||||
// # Examples
|
||||
//
|
||||
// Example 1: Compute Duration from two Timestamps in pseudo code.
|
||||
//
|
||||
// Timestamp start = ...;
|
||||
// Timestamp end = ...;
|
||||
// Duration duration = ...;
|
||||
//
|
||||
// duration.seconds = end.seconds - start.seconds;
|
||||
// duration.nanos = end.nanos - start.nanos;
|
||||
//
|
||||
// if (duration.seconds < 0 && duration.nanos > 0) {
|
||||
// duration.seconds += 1;
|
||||
// duration.nanos -= 1000000000;
|
||||
// } else if (durations.seconds > 0 && duration.nanos < 0) {
|
||||
// duration.seconds -= 1;
|
||||
// duration.nanos += 1000000000;
|
||||
// }
|
||||
//
|
||||
// Example 2: Compute Timestamp from Timestamp + Duration in pseudo code.
|
||||
//
|
||||
// Timestamp start = ...;
|
||||
// Duration duration = ...;
|
||||
// Timestamp end = ...;
|
||||
//
|
||||
// end.seconds = start.seconds + duration.seconds;
|
||||
// end.nanos = start.nanos + duration.nanos;
|
||||
//
|
||||
// if (end.nanos < 0) {
|
||||
// end.seconds -= 1;
|
||||
// end.nanos += 1000000000;
|
||||
// } else if (end.nanos >= 1000000000) {
|
||||
// end.seconds += 1;
|
||||
// end.nanos -= 1000000000;
|
||||
// }
|
||||
//
|
||||
// Example 3: Compute Duration from datetime.timedelta in Python.
|
||||
//
|
||||
// td = datetime.timedelta(days=3, minutes=10)
|
||||
// duration = Duration()
|
||||
// duration.FromTimedelta(td)
|
||||
//
|
||||
// # JSON Mapping
|
||||
//
|
||||
// In JSON format, the Duration type is encoded as a string rather than an
|
||||
// object, where the string ends in the suffix "s" (indicating seconds) and
|
||||
// is preceded by the number of seconds, with nanoseconds expressed as
|
||||
// fractional seconds. For example, 3 seconds with 0 nanoseconds should be
|
||||
// encoded in JSON format as "3s", while 3 seconds and 1 nanosecond should
|
||||
// be expressed in JSON format as "3.000000001s", and 3 seconds and 1
|
||||
// microsecond should be expressed in JSON format as "3.000001s".
|
||||
//
|
||||
//
|
||||
type Duration struct { |
||||
// Signed seconds of the span of time. Must be from -315,576,000,000
|
||||
// to +315,576,000,000 inclusive. Note: these bounds are computed from:
|
||||
// 60 sec/min * 60 min/hr * 24 hr/day * 365.25 days/year * 10000 years
|
||||
Seconds int64 `protobuf:"varint,1,opt,name=seconds,proto3" json:"seconds,omitempty"` |
||||
// Signed fractions of a second at nanosecond resolution of the span
|
||||
// of time. Durations less than one second are represented with a 0
|
||||
// `seconds` field and a positive or negative `nanos` field. For durations
|
||||
// of one second or more, a non-zero value for the `nanos` field must be
|
||||
// of the same sign as the `seconds` field. Must be from -999,999,999
|
||||
// to +999,999,999 inclusive.
|
||||
Nanos int32 `protobuf:"varint,2,opt,name=nanos,proto3" json:"nanos,omitempty"` |
||||
XXX_NoUnkeyedLiteral struct{} `json:"-"` |
||||
XXX_unrecognized []byte `json:"-"` |
||||
XXX_sizecache int32 `json:"-"` |
||||
} |
||||
var File_github_com_golang_protobuf_ptypes_duration_duration_proto protoreflect.FileDescriptor |
||||
|
||||
func (m *Duration) Reset() { *m = Duration{} } |
||||
func (m *Duration) String() string { return proto.CompactTextString(m) } |
||||
func (*Duration) ProtoMessage() {} |
||||
func (*Duration) Descriptor() ([]byte, []int) { |
||||
return fileDescriptor_23597b2ebd7ac6c5, []int{0} |
||||
var file_github_com_golang_protobuf_ptypes_duration_duration_proto_rawDesc = []byte{ |
||||
0x0a, 0x39, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x6c, |
||||
0x61, 0x6e, 0x67, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x70, 0x74, 0x79, |
||||
0x70, 0x65, 0x73, 0x2f, 0x64, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2f, 0x64, 0x75, 0x72, |
||||
0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1e, 0x67, 0x6f, 0x6f, |
||||
0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x64, 0x75, 0x72, |
||||
0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x42, 0x35, 0x5a, 0x33, 0x67, |
||||
0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x6c, 0x61, 0x6e, 0x67, |
||||
0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x70, 0x74, 0x79, 0x70, 0x65, 0x73, |
||||
0x2f, 0x64, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x3b, 0x64, 0x75, 0x72, 0x61, 0x74, 0x69, |
||||
0x6f, 0x6e, 0x50, 0x00, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, |
||||
} |
||||
|
||||
func (*Duration) XXX_WellKnownType() string { return "Duration" } |
||||
|
||||
func (m *Duration) XXX_Unmarshal(b []byte) error { |
||||
return xxx_messageInfo_Duration.Unmarshal(m, b) |
||||
} |
||||
func (m *Duration) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
||||
return xxx_messageInfo_Duration.Marshal(b, m, deterministic) |
||||
} |
||||
func (m *Duration) XXX_Merge(src proto.Message) { |
||||
xxx_messageInfo_Duration.Merge(m, src) |
||||
} |
||||
func (m *Duration) XXX_Size() int { |
||||
return xxx_messageInfo_Duration.Size(m) |
||||
} |
||||
func (m *Duration) XXX_DiscardUnknown() { |
||||
xxx_messageInfo_Duration.DiscardUnknown(m) |
||||
var file_github_com_golang_protobuf_ptypes_duration_duration_proto_goTypes = []interface{}{} |
||||
var file_github_com_golang_protobuf_ptypes_duration_duration_proto_depIdxs = []int32{ |
||||
0, // [0:0] is the sub-list for method output_type
|
||||
0, // [0:0] is the sub-list for method input_type
|
||||
0, // [0:0] is the sub-list for extension type_name
|
||||
0, // [0:0] is the sub-list for extension extendee
|
||||
0, // [0:0] is the sub-list for field type_name
|
||||
} |
||||
|
||||
var xxx_messageInfo_Duration proto.InternalMessageInfo |
||||
|
||||
func (m *Duration) GetSeconds() int64 { |
||||
if m != nil { |
||||
return m.Seconds |
||||
func init() { file_github_com_golang_protobuf_ptypes_duration_duration_proto_init() } |
||||
func file_github_com_golang_protobuf_ptypes_duration_duration_proto_init() { |
||||
if File_github_com_golang_protobuf_ptypes_duration_duration_proto != nil { |
||||
return |
||||
} |
||||
return 0 |
||||
} |
||||
|
||||
func (m *Duration) GetNanos() int32 { |
||||
if m != nil { |
||||
return m.Nanos |
||||
} |
||||
return 0 |
||||
} |
||||
|
||||
func init() { |
||||
proto.RegisterType((*Duration)(nil), "google.protobuf.Duration") |
||||
} |
||||
|
||||
func init() { proto.RegisterFile("google/protobuf/duration.proto", fileDescriptor_23597b2ebd7ac6c5) } |
||||
|
||||
var fileDescriptor_23597b2ebd7ac6c5 = []byte{ |
||||
// 190 bytes of a gzipped FileDescriptorProto
|
||||
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x4b, 0xcf, 0xcf, 0x4f, |
||||
0xcf, 0x49, 0xd5, 0x2f, 0x28, 0xca, 0x2f, 0xc9, 0x4f, 0x2a, 0x4d, 0xd3, 0x4f, 0x29, 0x2d, 0x4a, |
||||
0x2c, 0xc9, 0xcc, 0xcf, 0xd3, 0x03, 0x8b, 0x08, 0xf1, 0x43, 0xe4, 0xf5, 0x60, 0xf2, 0x4a, 0x56, |
||||
0x5c, 0x1c, 0x2e, 0x50, 0x25, 0x42, 0x12, 0x5c, 0xec, 0xc5, 0xa9, 0xc9, 0xf9, 0x79, 0x29, 0xc5, |
||||
0x12, 0x8c, 0x0a, 0x8c, 0x1a, 0xcc, 0x41, 0x30, 0xae, 0x90, 0x08, 0x17, 0x6b, 0x5e, 0x62, 0x5e, |
||||
0x7e, 0xb1, 0x04, 0x93, 0x02, 0xa3, 0x06, 0x6b, 0x10, 0x84, 0xe3, 0x54, 0xc3, 0x25, 0x9c, 0x9c, |
||||
0x9f, 0xab, 0x87, 0x66, 0xa4, 0x13, 0x2f, 0xcc, 0xc0, 0x00, 0x90, 0x48, 0x00, 0x63, 0x94, 0x56, |
||||
0x7a, 0x66, 0x49, 0x46, 0x69, 0x92, 0x5e, 0x72, 0x7e, 0xae, 0x7e, 0x7a, 0x7e, 0x4e, 0x62, 0x5e, |
||||
0x3a, 0xc2, 0x7d, 0x05, 0x25, 0x95, 0x05, 0xa9, 0xc5, 0x70, 0x67, 0xfe, 0x60, 0x64, 0x5c, 0xc4, |
||||
0xc4, 0xec, 0x1e, 0xe0, 0xb4, 0x8a, 0x49, 0xce, 0x1d, 0x62, 0x6e, 0x00, 0x54, 0xa9, 0x5e, 0x78, |
||||
0x6a, 0x4e, 0x8e, 0x77, 0x5e, 0x7e, 0x79, 0x5e, 0x08, 0x48, 0x4b, 0x12, 0x1b, 0xd8, 0x0c, 0x63, |
||||
0x40, 0x00, 0x00, 0x00, 0xff, 0xff, 0xdc, 0x84, 0x30, 0xff, 0xf3, 0x00, 0x00, 0x00, |
||||
type x struct{} |
||||
out := protoimpl.TypeBuilder{ |
||||
File: protoimpl.DescBuilder{ |
||||
GoPackagePath: reflect.TypeOf(x{}).PkgPath(), |
||||
RawDescriptor: file_github_com_golang_protobuf_ptypes_duration_duration_proto_rawDesc, |
||||
NumEnums: 0, |
||||
NumMessages: 0, |
||||
NumExtensions: 0, |
||||
NumServices: 0, |
||||
}, |
||||
GoTypes: file_github_com_golang_protobuf_ptypes_duration_duration_proto_goTypes, |
||||
DependencyIndexes: file_github_com_golang_protobuf_ptypes_duration_duration_proto_depIdxs, |
||||
}.Build() |
||||
File_github_com_golang_protobuf_ptypes_duration_duration_proto = out.File |
||||
file_github_com_golang_protobuf_ptypes_duration_duration_proto_rawDesc = nil |
||||
file_github_com_golang_protobuf_ptypes_duration_duration_proto_goTypes = nil |
||||
file_github_com_golang_protobuf_ptypes_duration_duration_proto_depIdxs = nil |
||||
} |
||||
|
||||
@ -1,117 +0,0 @@ |
||||
// Protocol Buffers - Google's data interchange format |
||||
// Copyright 2008 Google Inc. All rights reserved. |
||||
// https://developers.google.com/protocol-buffers/ |
||||
// |
||||
// Redistribution and use in source and binary forms, with or without |
||||
// modification, are permitted provided that the following conditions are |
||||
// met: |
||||
// |
||||
// * Redistributions of source code must retain the above copyright |
||||
// notice, this list of conditions and the following disclaimer. |
||||
// * Redistributions in binary form must reproduce the above |
||||
// copyright notice, this list of conditions and the following disclaimer |
||||
// in the documentation and/or other materials provided with the |
||||
// distribution. |
||||
// * Neither the name of Google Inc. nor the names of its |
||||
// contributors may be used to endorse or promote products derived from |
||||
// this software without specific prior written permission. |
||||
// |
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||
|
||||
syntax = "proto3"; |
||||
|
||||
package google.protobuf; |
||||
|
||||
option csharp_namespace = "Google.Protobuf.WellKnownTypes"; |
||||
option cc_enable_arenas = true; |
||||
option go_package = "github.com/golang/protobuf/ptypes/duration"; |
||||
option java_package = "com.google.protobuf"; |
||||
option java_outer_classname = "DurationProto"; |
||||
option java_multiple_files = true; |
||||
option objc_class_prefix = "GPB"; |
||||
|
||||
// A Duration represents a signed, fixed-length span of time represented |
||||
// as a count of seconds and fractions of seconds at nanosecond |
||||
// resolution. It is independent of any calendar and concepts like "day" |
||||
// or "month". It is related to Timestamp in that the difference between |
||||
// two Timestamp values is a Duration and it can be added or subtracted |
||||
// from a Timestamp. Range is approximately +-10,000 years. |
||||
// |
||||
// # Examples |
||||
// |
||||
// Example 1: Compute Duration from two Timestamps in pseudo code. |
||||
// |
||||
// Timestamp start = ...; |
||||
// Timestamp end = ...; |
||||
// Duration duration = ...; |
||||
// |
||||
// duration.seconds = end.seconds - start.seconds; |
||||
// duration.nanos = end.nanos - start.nanos; |
||||
// |
||||
// if (duration.seconds < 0 && duration.nanos > 0) { |
||||
// duration.seconds += 1; |
||||
// duration.nanos -= 1000000000; |
||||
// } else if (durations.seconds > 0 && duration.nanos < 0) { |
||||
// duration.seconds -= 1; |
||||
// duration.nanos += 1000000000; |
||||
// } |
||||
// |
||||
// Example 2: Compute Timestamp from Timestamp + Duration in pseudo code. |
||||
// |
||||
// Timestamp start = ...; |
||||
// Duration duration = ...; |
||||
// Timestamp end = ...; |
||||
// |
||||
// end.seconds = start.seconds + duration.seconds; |
||||
// end.nanos = start.nanos + duration.nanos; |
||||
// |
||||
// if (end.nanos < 0) { |
||||
// end.seconds -= 1; |
||||
// end.nanos += 1000000000; |
||||
// } else if (end.nanos >= 1000000000) { |
||||
// end.seconds += 1; |
||||
// end.nanos -= 1000000000; |
||||
// } |
||||
// |
||||
// Example 3: Compute Duration from datetime.timedelta in Python. |
||||
// |
||||
// td = datetime.timedelta(days=3, minutes=10) |
||||
// duration = Duration() |
||||
// duration.FromTimedelta(td) |
||||
// |
||||
// # JSON Mapping |
||||
// |
||||
// In JSON format, the Duration type is encoded as a string rather than an |
||||
// object, where the string ends in the suffix "s" (indicating seconds) and |
||||
// is preceded by the number of seconds, with nanoseconds expressed as |
||||
// fractional seconds. For example, 3 seconds with 0 nanoseconds should be |
||||
// encoded in JSON format as "3s", while 3 seconds and 1 nanosecond should |
||||
// be expressed in JSON format as "3.000000001s", and 3 seconds and 1 |
||||
// microsecond should be expressed in JSON format as "3.000001s". |
||||
// |
||||
// |
||||
message Duration { |
||||
|
||||
// Signed seconds of the span of time. Must be from -315,576,000,000 |
||||
// to +315,576,000,000 inclusive. Note: these bounds are computed from: |
||||
// 60 sec/min * 60 min/hr * 24 hr/day * 365.25 days/year * 10000 years |
||||
int64 seconds = 1; |
||||
|
||||
// Signed fractions of a second at nanosecond resolution of the span |
||||
// of time. Durations less than one second are represented with a 0 |
||||
// `seconds` field and a positive or negative `nanos` field. For durations |
||||
// of one second or more, a non-zero value for the `nanos` field must be |
||||
// of the same sign as the `seconds` field. Must be from -999,999,999 |
||||
// to +999,999,999 inclusive. |
||||
int32 nanos = 2; |
||||
} |
||||
@ -1,179 +1,64 @@ |
||||
// Code generated by protoc-gen-go. DO NOT EDIT.
|
||||
// source: google/protobuf/timestamp.proto
|
||||
// source: github.com/golang/protobuf/ptypes/timestamp/timestamp.proto
|
||||
|
||||
package timestamp |
||||
|
||||
import ( |
||||
fmt "fmt" |
||||
proto "github.com/golang/protobuf/proto" |
||||
math "math" |
||||
protoreflect "google.golang.org/protobuf/reflect/protoreflect" |
||||
protoimpl "google.golang.org/protobuf/runtime/protoimpl" |
||||
timestamppb "google.golang.org/protobuf/types/known/timestamppb" |
||||
reflect "reflect" |
||||
) |
||||
|
||||
// Reference imports to suppress errors if they are not otherwise used.
|
||||
var _ = proto.Marshal |
||||
var _ = fmt.Errorf |
||||
var _ = math.Inf |
||||
// Symbols defined in public import of google/protobuf/timestamp.proto.
|
||||
|
||||
// This is a compile-time assertion to ensure that this generated file
|
||||
// is compatible with the proto package it is being compiled against.
|
||||
// A compilation error at this line likely means your copy of the
|
||||
// proto package needs to be updated.
|
||||
const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
|
||||
type Timestamp = timestamppb.Timestamp |
||||
|
||||
// A Timestamp represents a point in time independent of any time zone
|
||||
// or calendar, represented as seconds and fractions of seconds at
|
||||
// nanosecond resolution in UTC Epoch time. It is encoded using the
|
||||
// Proleptic Gregorian Calendar which extends the Gregorian calendar
|
||||
// backwards to year one. It is encoded assuming all minutes are 60
|
||||
// seconds long, i.e. leap seconds are "smeared" so that no leap second
|
||||
// table is needed for interpretation. Range is from
|
||||
// 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z.
|
||||
// By restricting to that range, we ensure that we can convert to
|
||||
// and from RFC 3339 date strings.
|
||||
// See [https://www.ietf.org/rfc/rfc3339.txt](https://www.ietf.org/rfc/rfc3339.txt).
|
||||
//
|
||||
// # Examples
|
||||
//
|
||||
// Example 1: Compute Timestamp from POSIX `time()`.
|
||||
//
|
||||
// Timestamp timestamp;
|
||||
// timestamp.set_seconds(time(NULL));
|
||||
// timestamp.set_nanos(0);
|
||||
//
|
||||
// Example 2: Compute Timestamp from POSIX `gettimeofday()`.
|
||||
//
|
||||
// struct timeval tv;
|
||||
// gettimeofday(&tv, NULL);
|
||||
//
|
||||
// Timestamp timestamp;
|
||||
// timestamp.set_seconds(tv.tv_sec);
|
||||
// timestamp.set_nanos(tv.tv_usec * 1000);
|
||||
//
|
||||
// Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`.
|
||||
//
|
||||
// FILETIME ft;
|
||||
// GetSystemTimeAsFileTime(&ft);
|
||||
// UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime;
|
||||
//
|
||||
// // A Windows tick is 100 nanoseconds. Windows epoch 1601-01-01T00:00:00Z
|
||||
// // is 11644473600 seconds before Unix epoch 1970-01-01T00:00:00Z.
|
||||
// Timestamp timestamp;
|
||||
// timestamp.set_seconds((INT64) ((ticks / 10000000) - 11644473600LL));
|
||||
// timestamp.set_nanos((INT32) ((ticks % 10000000) * 100));
|
||||
//
|
||||
// Example 4: Compute Timestamp from Java `System.currentTimeMillis()`.
|
||||
//
|
||||
// long millis = System.currentTimeMillis();
|
||||
//
|
||||
// Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000)
|
||||
// .setNanos((int) ((millis % 1000) * 1000000)).build();
|
||||
//
|
||||
//
|
||||
// Example 5: Compute Timestamp from current time in Python.
|
||||
//
|
||||
// timestamp = Timestamp()
|
||||
// timestamp.GetCurrentTime()
|
||||
//
|
||||
// # JSON Mapping
|
||||
//
|
||||
// In JSON format, the Timestamp type is encoded as a string in the
|
||||
// [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the
|
||||
// format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z"
|
||||
// where {year} is always expressed using four digits while {month}, {day},
|
||||
// {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional
|
||||
// seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution),
|
||||
// are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone
|
||||
// is required. A proto3 JSON serializer should always use UTC (as indicated by
|
||||
// "Z") when printing the Timestamp type and a proto3 JSON parser should be
|
||||
// able to accept both UTC and other timezones (as indicated by an offset).
|
||||
//
|
||||
// For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past
|
||||
// 01:30 UTC on January 15, 2017.
|
||||
//
|
||||
// In JavaScript, one can convert a Date object to this format using the
|
||||
// standard [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString]
|
||||
// method. In Python, a standard `datetime.datetime` object can be converted
|
||||
// to this format using [`strftime`](https://docs.python.org/2/library/time.html#time.strftime)
|
||||
// with the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one
|
||||
// can use the Joda Time's [`ISODateTimeFormat.dateTime()`](
|
||||
// http://www.joda.org/joda-time/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime--
|
||||
// ) to obtain a formatter capable of generating timestamps in this format.
|
||||
//
|
||||
//
|
||||
type Timestamp struct { |
||||
// Represents seconds of UTC time since Unix epoch
|
||||
// 1970-01-01T00:00:00Z. Must be from 0001-01-01T00:00:00Z to
|
||||
// 9999-12-31T23:59:59Z inclusive.
|
||||
Seconds int64 `protobuf:"varint,1,opt,name=seconds,proto3" json:"seconds,omitempty"` |
||||
// Non-negative fractions of a second at nanosecond resolution. Negative
|
||||
// second values with fractions must still have non-negative nanos values
|
||||
// that count forward in time. Must be from 0 to 999,999,999
|
||||
// inclusive.
|
||||
Nanos int32 `protobuf:"varint,2,opt,name=nanos,proto3" json:"nanos,omitempty"` |
||||
XXX_NoUnkeyedLiteral struct{} `json:"-"` |
||||
XXX_unrecognized []byte `json:"-"` |
||||
XXX_sizecache int32 `json:"-"` |
||||
} |
||||
var File_github_com_golang_protobuf_ptypes_timestamp_timestamp_proto protoreflect.FileDescriptor |
||||
|
||||
func (m *Timestamp) Reset() { *m = Timestamp{} } |
||||
func (m *Timestamp) String() string { return proto.CompactTextString(m) } |
||||
func (*Timestamp) ProtoMessage() {} |
||||
func (*Timestamp) Descriptor() ([]byte, []int) { |
||||
return fileDescriptor_292007bbfe81227e, []int{0} |
||||
var file_github_com_golang_protobuf_ptypes_timestamp_timestamp_proto_rawDesc = []byte{ |
||||
0x0a, 0x3b, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x6c, |
||||
0x61, 0x6e, 0x67, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x70, 0x74, 0x79, |
||||
0x70, 0x65, 0x73, 0x2f, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x2f, 0x74, 0x69, |
||||
0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1f, 0x67, |
||||
0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, |
||||
0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x42, 0x37, |
||||
0x5a, 0x35, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x6f, 0x6c, |
||||
0x61, 0x6e, 0x67, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x70, 0x74, 0x79, |
||||
0x70, 0x65, 0x73, 0x2f, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x3b, 0x74, 0x69, |
||||
0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x50, 0x00, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, |
||||
0x33, |
||||
} |
||||
|
||||
func (*Timestamp) XXX_WellKnownType() string { return "Timestamp" } |
||||
|
||||
func (m *Timestamp) XXX_Unmarshal(b []byte) error { |
||||
return xxx_messageInfo_Timestamp.Unmarshal(m, b) |
||||
} |
||||
func (m *Timestamp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
||||
return xxx_messageInfo_Timestamp.Marshal(b, m, deterministic) |
||||
} |
||||
func (m *Timestamp) XXX_Merge(src proto.Message) { |
||||
xxx_messageInfo_Timestamp.Merge(m, src) |
||||
} |
||||
func (m *Timestamp) XXX_Size() int { |
||||
return xxx_messageInfo_Timestamp.Size(m) |
||||
} |
||||
func (m *Timestamp) XXX_DiscardUnknown() { |
||||
xxx_messageInfo_Timestamp.DiscardUnknown(m) |
||||
var file_github_com_golang_protobuf_ptypes_timestamp_timestamp_proto_goTypes = []interface{}{} |
||||
var file_github_com_golang_protobuf_ptypes_timestamp_timestamp_proto_depIdxs = []int32{ |
||||
0, // [0:0] is the sub-list for method output_type
|
||||
0, // [0:0] is the sub-list for method input_type
|
||||
0, // [0:0] is the sub-list for extension type_name
|
||||
0, // [0:0] is the sub-list for extension extendee
|
||||
0, // [0:0] is the sub-list for field type_name
|
||||
} |
||||
|
||||
var xxx_messageInfo_Timestamp proto.InternalMessageInfo |
||||
|
||||
func (m *Timestamp) GetSeconds() int64 { |
||||
if m != nil { |
||||
return m.Seconds |
||||
func init() { file_github_com_golang_protobuf_ptypes_timestamp_timestamp_proto_init() } |
||||
func file_github_com_golang_protobuf_ptypes_timestamp_timestamp_proto_init() { |
||||
if File_github_com_golang_protobuf_ptypes_timestamp_timestamp_proto != nil { |
||||
return |
||||
} |
||||
return 0 |
||||
} |
||||
|
||||
func (m *Timestamp) GetNanos() int32 { |
||||
if m != nil { |
||||
return m.Nanos |
||||
} |
||||
return 0 |
||||
} |
||||
|
||||
func init() { |
||||
proto.RegisterType((*Timestamp)(nil), "google.protobuf.Timestamp") |
||||
} |
||||
|
||||
func init() { proto.RegisterFile("google/protobuf/timestamp.proto", fileDescriptor_292007bbfe81227e) } |
||||
|
||||
var fileDescriptor_292007bbfe81227e = []byte{ |
||||
// 191 bytes of a gzipped FileDescriptorProto
|
||||
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x4f, 0xcf, 0xcf, 0x4f, |
||||
0xcf, 0x49, 0xd5, 0x2f, 0x28, 0xca, 0x2f, 0xc9, 0x4f, 0x2a, 0x4d, 0xd3, 0x2f, 0xc9, 0xcc, 0x4d, |
||||
0x2d, 0x2e, 0x49, 0xcc, 0x2d, 0xd0, 0x03, 0x0b, 0x09, 0xf1, 0x43, 0x14, 0xe8, 0xc1, 0x14, 0x28, |
||||
0x59, 0x73, 0x71, 0x86, 0xc0, 0xd4, 0x08, 0x49, 0x70, 0xb1, 0x17, 0xa7, 0x26, 0xe7, 0xe7, 0xa5, |
||||
0x14, 0x4b, 0x30, 0x2a, 0x30, 0x6a, 0x30, 0x07, 0xc1, 0xb8, 0x42, 0x22, 0x5c, 0xac, 0x79, 0x89, |
||||
0x79, 0xf9, 0xc5, 0x12, 0x4c, 0x0a, 0x8c, 0x1a, 0xac, 0x41, 0x10, 0x8e, 0x53, 0x1d, 0x97, 0x70, |
||||
0x72, 0x7e, 0xae, 0x1e, 0x9a, 0x99, 0x4e, 0x7c, 0x70, 0x13, 0x03, 0x40, 0x42, 0x01, 0x8c, 0x51, |
||||
0xda, 0xe9, 0x99, 0x25, 0x19, 0xa5, 0x49, 0x7a, 0xc9, 0xf9, 0xb9, 0xfa, 0xe9, 0xf9, 0x39, 0x89, |
||||
0x79, 0xe9, 0x08, 0x27, 0x16, 0x94, 0x54, 0x16, 0xa4, 0x16, 0x23, 0x5c, 0xfa, 0x83, 0x91, 0x71, |
||||
0x11, 0x13, 0xb3, 0x7b, 0x80, 0xd3, 0x2a, 0x26, 0x39, 0x77, 0x88, 0xc9, 0x01, 0x50, 0xb5, 0x7a, |
||||
0xe1, 0xa9, 0x39, 0x39, 0xde, 0x79, 0xf9, 0xe5, 0x79, 0x21, 0x20, 0x3d, 0x49, 0x6c, 0x60, 0x43, |
||||
0x8c, 0x01, 0x01, 0x00, 0x00, 0xff, 0xff, 0xbc, 0x77, 0x4a, 0x07, 0xf7, 0x00, 0x00, 0x00, |
||||
type x struct{} |
||||
out := protoimpl.TypeBuilder{ |
||||
File: protoimpl.DescBuilder{ |
||||
GoPackagePath: reflect.TypeOf(x{}).PkgPath(), |
||||
RawDescriptor: file_github_com_golang_protobuf_ptypes_timestamp_timestamp_proto_rawDesc, |
||||
NumEnums: 0, |
||||
NumMessages: 0, |
||||
NumExtensions: 0, |
||||
NumServices: 0, |
||||
}, |
||||
GoTypes: file_github_com_golang_protobuf_ptypes_timestamp_timestamp_proto_goTypes, |
||||
DependencyIndexes: file_github_com_golang_protobuf_ptypes_timestamp_timestamp_proto_depIdxs, |
||||
}.Build() |
||||
File_github_com_golang_protobuf_ptypes_timestamp_timestamp_proto = out.File |
||||
file_github_com_golang_protobuf_ptypes_timestamp_timestamp_proto_rawDesc = nil |
||||
file_github_com_golang_protobuf_ptypes_timestamp_timestamp_proto_goTypes = nil |
||||
file_github_com_golang_protobuf_ptypes_timestamp_timestamp_proto_depIdxs = nil |
||||
} |
||||
|
||||
@ -1,135 +0,0 @@ |
||||
// Protocol Buffers - Google's data interchange format |
||||
// Copyright 2008 Google Inc. All rights reserved. |
||||
// https://developers.google.com/protocol-buffers/ |
||||
// |
||||
// Redistribution and use in source and binary forms, with or without |
||||
// modification, are permitted provided that the following conditions are |
||||
// met: |
||||
// |
||||
// * Redistributions of source code must retain the above copyright |
||||
// notice, this list of conditions and the following disclaimer. |
||||
// * Redistributions in binary form must reproduce the above |
||||
// copyright notice, this list of conditions and the following disclaimer |
||||
// in the documentation and/or other materials provided with the |
||||
// distribution. |
||||
// * Neither the name of Google Inc. nor the names of its |
||||
// contributors may be used to endorse or promote products derived from |
||||
// this software without specific prior written permission. |
||||
// |
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||
|
||||
syntax = "proto3"; |
||||
|
||||
package google.protobuf; |
||||
|
||||
option csharp_namespace = "Google.Protobuf.WellKnownTypes"; |
||||
option cc_enable_arenas = true; |
||||
option go_package = "github.com/golang/protobuf/ptypes/timestamp"; |
||||
option java_package = "com.google.protobuf"; |
||||
option java_outer_classname = "TimestampProto"; |
||||
option java_multiple_files = true; |
||||
option objc_class_prefix = "GPB"; |
||||
|
||||
// A Timestamp represents a point in time independent of any time zone |
||||
// or calendar, represented as seconds and fractions of seconds at |
||||
// nanosecond resolution in UTC Epoch time. It is encoded using the |
||||
// Proleptic Gregorian Calendar which extends the Gregorian calendar |
||||
// backwards to year one. It is encoded assuming all minutes are 60 |
||||
// seconds long, i.e. leap seconds are "smeared" so that no leap second |
||||
// table is needed for interpretation. Range is from |
||||
// 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. |
||||
// By restricting to that range, we ensure that we can convert to |
||||
// and from RFC 3339 date strings. |
||||
// See [https://www.ietf.org/rfc/rfc3339.txt](https://www.ietf.org/rfc/rfc3339.txt). |
||||
// |
||||
// # Examples |
||||
// |
||||
// Example 1: Compute Timestamp from POSIX `time()`. |
||||
// |
||||
// Timestamp timestamp; |
||||
// timestamp.set_seconds(time(NULL)); |
||||
// timestamp.set_nanos(0); |
||||
// |
||||
// Example 2: Compute Timestamp from POSIX `gettimeofday()`. |
||||
// |
||||
// struct timeval tv; |
||||
// gettimeofday(&tv, NULL); |
||||
// |
||||
// Timestamp timestamp; |
||||
// timestamp.set_seconds(tv.tv_sec); |
||||
// timestamp.set_nanos(tv.tv_usec * 1000); |
||||
// |
||||
// Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`. |
||||
// |
||||
// FILETIME ft; |
||||
// GetSystemTimeAsFileTime(&ft); |
||||
// UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime; |
||||
// |
||||
// // A Windows tick is 100 nanoseconds. Windows epoch 1601-01-01T00:00:00Z |
||||
// // is 11644473600 seconds before Unix epoch 1970-01-01T00:00:00Z. |
||||
// Timestamp timestamp; |
||||
// timestamp.set_seconds((INT64) ((ticks / 10000000) - 11644473600LL)); |
||||
// timestamp.set_nanos((INT32) ((ticks % 10000000) * 100)); |
||||
// |
||||
// Example 4: Compute Timestamp from Java `System.currentTimeMillis()`. |
||||
// |
||||
// long millis = System.currentTimeMillis(); |
||||
// |
||||
// Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000) |
||||
// .setNanos((int) ((millis % 1000) * 1000000)).build(); |
||||
// |
||||
// |
||||
// Example 5: Compute Timestamp from current time in Python. |
||||
// |
||||
// timestamp = Timestamp() |
||||
// timestamp.GetCurrentTime() |
||||
// |
||||
// # JSON Mapping |
||||
// |
||||
// In JSON format, the Timestamp type is encoded as a string in the |
||||
// [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the |
||||
// format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z" |
||||
// where {year} is always expressed using four digits while {month}, {day}, |
||||
// {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional |
||||
// seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution), |
||||
// are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone |
||||
// is required. A proto3 JSON serializer should always use UTC (as indicated by |
||||
// "Z") when printing the Timestamp type and a proto3 JSON parser should be |
||||
// able to accept both UTC and other timezones (as indicated by an offset). |
||||
// |
||||
// For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past |
||||
// 01:30 UTC on January 15, 2017. |
||||
// |
||||
// In JavaScript, one can convert a Date object to this format using the |
||||
// standard [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString] |
||||
// method. In Python, a standard `datetime.datetime` object can be converted |
||||
// to this format using [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) |
||||
// with the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one |
||||
// can use the Joda Time's [`ISODateTimeFormat.dateTime()`]( |
||||
// http://www.joda.org/joda-time/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime-- |
||||
// ) to obtain a formatter capable of generating timestamps in this format. |
||||
// |
||||
// |
||||
message Timestamp { |
||||
|
||||
// Represents seconds of UTC time since Unix epoch |
||||
// 1970-01-01T00:00:00Z. Must be from 0001-01-01T00:00:00Z to |
||||
// 9999-12-31T23:59:59Z inclusive. |
||||
int64 seconds = 1; |
||||
|
||||
// Non-negative fractions of a second at nanosecond resolution. Negative |
||||
// second values with fractions must still have non-negative nanos values |
||||
// that count forward in time. Must be from 0 to 999,999,999 |
||||
// inclusive. |
||||
int32 nanos = 2; |
||||
} |
||||
@ -0,0 +1,13 @@ |
||||
language: go |
||||
|
||||
go: |
||||
- 1.4 |
||||
- 1.3 |
||||
- 1.2 |
||||
- tip |
||||
|
||||
install: |
||||
- if ! go get code.google.com/p/go.tools/cmd/cover; then go get golang.org/x/tools/cmd/cover; fi |
||||
|
||||
script: |
||||
- go test -cover |
||||
@ -0,0 +1,67 @@ |
||||
# How to contribute # |
||||
|
||||
We'd love to accept your patches and contributions to this project. There are |
||||
a just a few small guidelines you need to follow. |
||||
|
||||
|
||||
## Contributor License Agreement ## |
||||
|
||||
Contributions to any Google project must be accompanied by a Contributor |
||||
License Agreement. This is not a copyright **assignment**, it simply gives |
||||
Google permission to use and redistribute your contributions as part of the |
||||
project. |
||||
|
||||
* If you are an individual writing original source code and you're sure you |
||||
own the intellectual property, then you'll need to sign an [individual |
||||
CLA][]. |
||||
|
||||
* If you work for a company that wants to allow you to contribute your work, |
||||
then you'll need to sign a [corporate CLA][]. |
||||
|
||||
You generally only need to submit a CLA once, so if you've already submitted |
||||
one (even if it was for a different project), you probably don't need to do it |
||||
again. |
||||
|
||||
[individual CLA]: https://developers.google.com/open-source/cla/individual |
||||
[corporate CLA]: https://developers.google.com/open-source/cla/corporate |
||||
|
||||
|
||||
## Submitting a patch ## |
||||
|
||||
1. It's generally best to start by opening a new issue describing the bug or |
||||
feature you're intending to fix. Even if you think it's relatively minor, |
||||
it's helpful to know what people are working on. Mention in the initial |
||||
issue that you are planning to work on that bug or feature so that it can |
||||
be assigned to you. |
||||
|
||||
1. Follow the normal process of [forking][] the project, and setup a new |
||||
branch to work in. It's important that each group of changes be done in |
||||
separate branches in order to ensure that a pull request only includes the |
||||
commits related to that bug or feature. |
||||
|
||||
1. Go makes it very simple to ensure properly formatted code, so always run |
||||
`go fmt` on your code before committing it. You should also run |
||||
[golint][] over your code. As noted in the [golint readme][], it's not |
||||
strictly necessary that your code be completely "lint-free", but this will |
||||
help you find common style issues. |
||||
|
||||
1. Any significant changes should almost always be accompanied by tests. The |
||||
project already has good test coverage, so look at some of the existing |
||||
tests if you're unsure how to go about it. [gocov][] and [gocov-html][] |
||||
are invaluable tools for seeing which parts of your code aren't being |
||||
exercised by your tests. |
||||
|
||||
1. Do your best to have [well-formed commit messages][] for each change. |
||||
This provides consistency throughout the project, and ensures that commit |
||||
messages are able to be formatted properly by various git tools. |
||||
|
||||
1. Finally, push the commits to your fork and submit a [pull request][]. |
||||
|
||||
[forking]: https://help.github.com/articles/fork-a-repo |
||||
[golint]: https://github.com/golang/lint |
||||
[golint readme]: https://github.com/golang/lint/blob/master/README |
||||
[gocov]: https://github.com/axw/gocov |
||||
[gocov-html]: https://github.com/matm/gocov-html |
||||
[well-formed commit messages]: http://tbaggery.com/2008/04/19/a-note-about-git-commit-messages.html |
||||
[squash]: http://git-scm.com/book/en/Git-Tools-Rewriting-History#Squashing-Commits |
||||
[pull request]: https://help.github.com/articles/creating-a-pull-request |
||||
@ -0,0 +1,202 @@ |
||||
|
||||
Apache License |
||||
Version 2.0, January 2004 |
||||
http://www.apache.org/licenses/ |
||||
|
||||
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION |
||||
|
||||
1. Definitions. |
||||
|
||||
"License" shall mean the terms and conditions for use, reproduction, |
||||
and distribution as defined by Sections 1 through 9 of this document. |
||||
|
||||
"Licensor" shall mean the copyright owner or entity authorized by |
||||
the copyright owner that is granting the License. |
||||
|
||||
"Legal Entity" shall mean the union of the acting entity and all |
||||
other entities that control, are controlled by, or are under common |
||||
control with that entity. For the purposes of this definition, |
||||
"control" means (i) the power, direct or indirect, to cause the |
||||
direction or management of such entity, whether by contract or |
||||
otherwise, or (ii) ownership of fifty percent (50%) or more of the |
||||
outstanding shares, or (iii) beneficial ownership of such entity. |
||||
|
||||
"You" (or "Your") shall mean an individual or Legal Entity |
||||
exercising permissions granted by this License. |
||||
|
||||
"Source" form shall mean the preferred form for making modifications, |
||||
including but not limited to software source code, documentation |
||||
source, and configuration files. |
||||
|
||||
"Object" form shall mean any form resulting from mechanical |
||||
transformation or translation of a Source form, including but |
||||
not limited to compiled object code, generated documentation, |
||||
and conversions to other media types. |
||||
|
||||
"Work" shall mean the work of authorship, whether in Source or |
||||
Object form, made available under the License, as indicated by a |
||||
copyright notice that is included in or attached to the work |
||||
(an example is provided in the Appendix below). |
||||
|
||||
"Derivative Works" shall mean any work, whether in Source or Object |
||||
form, that is based on (or derived from) the Work and for which the |
||||
editorial revisions, annotations, elaborations, or other modifications |
||||
represent, as a whole, an original work of authorship. For the purposes |
||||
of this License, Derivative Works shall not include works that remain |
||||
separable from, or merely link (or bind by name) to the interfaces of, |
||||
the Work and Derivative Works thereof. |
||||
|
||||
"Contribution" shall mean any work of authorship, including |
||||
the original version of the Work and any modifications or additions |
||||
to that Work or Derivative Works thereof, that is intentionally |
||||
submitted to Licensor for inclusion in the Work by the copyright owner |
||||
or by an individual or Legal Entity authorized to submit on behalf of |
||||
the copyright owner. For the purposes of this definition, "submitted" |
||||
means any form of electronic, verbal, or written communication sent |
||||
to the Licensor or its representatives, including but not limited to |
||||
communication on electronic mailing lists, source code control systems, |
||||
and issue tracking systems that are managed by, or on behalf of, the |
||||
Licensor for the purpose of discussing and improving the Work, but |
||||
excluding communication that is conspicuously marked or otherwise |
||||
designated in writing by the copyright owner as "Not a Contribution." |
||||
|
||||
"Contributor" shall mean Licensor and any individual or Legal Entity |
||||
on behalf of whom a Contribution has been received by Licensor and |
||||
subsequently incorporated within the Work. |
||||
|
||||
2. Grant of Copyright License. Subject to the terms and conditions of |
||||
this License, each Contributor hereby grants to You a perpetual, |
||||
worldwide, non-exclusive, no-charge, royalty-free, irrevocable |
||||
copyright license to reproduce, prepare Derivative Works of, |
||||
publicly display, publicly perform, sublicense, and distribute the |
||||
Work and such Derivative Works in Source or Object form. |
||||
|
||||
3. Grant of Patent License. Subject to the terms and conditions of |
||||
this License, each Contributor hereby grants to You a perpetual, |
||||
worldwide, non-exclusive, no-charge, royalty-free, irrevocable |
||||
(except as stated in this section) patent license to make, have made, |
||||
use, offer to sell, sell, import, and otherwise transfer the Work, |
||||
where such license applies only to those patent claims licensable |
||||
by such Contributor that are necessarily infringed by their |
||||
Contribution(s) alone or by combination of their Contribution(s) |
||||
with the Work to which such Contribution(s) was submitted. If You |
||||
institute patent litigation against any entity (including a |
||||
cross-claim or counterclaim in a lawsuit) alleging that the Work |
||||
or a Contribution incorporated within the Work constitutes direct |
||||
or contributory patent infringement, then any patent licenses |
||||
granted to You under this License for that Work shall terminate |
||||
as of the date such litigation is filed. |
||||
|
||||
4. Redistribution. You may reproduce and distribute copies of the |
||||
Work or Derivative Works thereof in any medium, with or without |
||||
modifications, and in Source or Object form, provided that You |
||||
meet the following conditions: |
||||
|
||||
(a) You must give any other recipients of the Work or |
||||
Derivative Works a copy of this License; and |
||||
|
||||
(b) You must cause any modified files to carry prominent notices |
||||
stating that You changed the files; and |
||||
|
||||
(c) You must retain, in the Source form of any Derivative Works |
||||
that You distribute, all copyright, patent, trademark, and |
||||
attribution notices from the Source form of the Work, |
||||
excluding those notices that do not pertain to any part of |
||||
the Derivative Works; and |
||||
|
||||
(d) If the Work includes a "NOTICE" text file as part of its |
||||
distribution, then any Derivative Works that You distribute must |
||||
include a readable copy of the attribution notices contained |
||||
within such NOTICE file, excluding those notices that do not |
||||
pertain to any part of the Derivative Works, in at least one |
||||
of the following places: within a NOTICE text file distributed |
||||
as part of the Derivative Works; within the Source form or |
||||
documentation, if provided along with the Derivative Works; or, |
||||
within a display generated by the Derivative Works, if and |
||||
wherever such third-party notices normally appear. The contents |
||||
of the NOTICE file are for informational purposes only and |
||||
do not modify the License. You may add Your own attribution |
||||
notices within Derivative Works that You distribute, alongside |
||||
or as an addendum to the NOTICE text from the Work, provided |
||||
that such additional attribution notices cannot be construed |
||||
as modifying the License. |
||||
|
||||
You may add Your own copyright statement to Your modifications and |
||||
may provide additional or different license terms and conditions |
||||
for use, reproduction, or distribution of Your modifications, or |
||||
for any such Derivative Works as a whole, provided Your use, |
||||
reproduction, and distribution of the Work otherwise complies with |
||||
the conditions stated in this License. |
||||
|
||||
5. Submission of Contributions. Unless You explicitly state otherwise, |
||||
any Contribution intentionally submitted for inclusion in the Work |
||||
by You to the Licensor shall be under the terms and conditions of |
||||
this License, without any additional terms or conditions. |
||||
Notwithstanding the above, nothing herein shall supersede or modify |
||||
the terms of any separate license agreement you may have executed |
||||
with Licensor regarding such Contributions. |
||||
|
||||
6. Trademarks. This License does not grant permission to use the trade |
||||
names, trademarks, service marks, or product names of the Licensor, |
||||
except as required for reasonable and customary use in describing the |
||||
origin of the Work and reproducing the content of the NOTICE file. |
||||
|
||||
7. Disclaimer of Warranty. Unless required by applicable law or |
||||
agreed to in writing, Licensor provides the Work (and each |
||||
Contributor provides its Contributions) on an "AS IS" BASIS, |
||||
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or |
||||
implied, including, without limitation, any warranties or conditions |
||||
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A |
||||
PARTICULAR PURPOSE. You are solely responsible for determining the |
||||
appropriateness of using or redistributing the Work and assume any |
||||
risks associated with Your exercise of permissions under this License. |
||||
|
||||
8. Limitation of Liability. In no event and under no legal theory, |
||||
whether in tort (including negligence), contract, or otherwise, |
||||
unless required by applicable law (such as deliberate and grossly |
||||
negligent acts) or agreed to in writing, shall any Contributor be |
||||
liable to You for damages, including any direct, indirect, special, |
||||
incidental, or consequential damages of any character arising as a |
||||
result of this License or out of the use or inability to use the |
||||
Work (including but not limited to damages for loss of goodwill, |
||||
work stoppage, computer failure or malfunction, or any and all |
||||
other commercial damages or losses), even if such Contributor |
||||
has been advised of the possibility of such damages. |
||||
|
||||
9. Accepting Warranty or Additional Liability. While redistributing |
||||
the Work or Derivative Works thereof, You may choose to offer, |
||||
and charge a fee for, acceptance of support, warranty, indemnity, |
||||
or other liability obligations and/or rights consistent with this |
||||
License. However, in accepting such obligations, You may act only |
||||
on Your own behalf and on Your sole responsibility, not on behalf |
||||
of any other Contributor, and only if You agree to indemnify, |
||||
defend, and hold each Contributor harmless for any liability |
||||
incurred by, or claims asserted against, such Contributor by reason |
||||
of your accepting any such warranty or additional liability. |
||||
|
||||
END OF TERMS AND CONDITIONS |
||||
|
||||
APPENDIX: How to apply the Apache License to your work. |
||||
|
||||
To apply the Apache License to your work, attach the following |
||||
boilerplate notice, with the fields enclosed by brackets "[]" |
||||
replaced with your own identifying information. (Don't include |
||||
the brackets!) The text should be enclosed in the appropriate |
||||
comment syntax for the file format. We also recommend that a |
||||
file or class name and description of purpose be included on the |
||||
same "printed page" as the copyright notice for easier |
||||
identification within third-party archives. |
||||
|
||||
Copyright [yyyy] [name of copyright owner] |
||||
|
||||
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. |
||||
@ -0,0 +1,71 @@ |
||||
gofuzz |
||||
====== |
||||
|
||||
gofuzz is a library for populating go objects with random values. |
||||
|
||||
[](https://godoc.org/github.com/google/gofuzz) |
||||
[](https://travis-ci.org/google/gofuzz) |
||||
|
||||
This is useful for testing: |
||||
|
||||
* Do your project's objects really serialize/unserialize correctly in all cases? |
||||
* Is there an incorrectly formatted object that will cause your project to panic? |
||||
|
||||
Import with ```import "github.com/google/gofuzz"``` |
||||
|
||||
You can use it on single variables: |
||||
```go |
||||
f := fuzz.New() |
||||
var myInt int |
||||
f.Fuzz(&myInt) // myInt gets a random value. |
||||
``` |
||||
|
||||
You can use it on maps: |
||||
```go |
||||
f := fuzz.New().NilChance(0).NumElements(1, 1) |
||||
var myMap map[ComplexKeyType]string |
||||
f.Fuzz(&myMap) // myMap will have exactly one element. |
||||
``` |
||||
|
||||
Customize the chance of getting a nil pointer: |
||||
```go |
||||
f := fuzz.New().NilChance(.5) |
||||
var fancyStruct struct { |
||||
A, B, C, D *string |
||||
} |
||||
f.Fuzz(&fancyStruct) // About half the pointers should be set. |
||||
``` |
||||
|
||||
You can even customize the randomization completely if needed: |
||||
```go |
||||
type MyEnum string |
||||
const ( |
||||
A MyEnum = "A" |
||||
B MyEnum = "B" |
||||
) |
||||
type MyInfo struct { |
||||
Type MyEnum |
||||
AInfo *string |
||||
BInfo *string |
||||
} |
||||
|
||||
f := fuzz.New().NilChance(0).Funcs( |
||||
func(e *MyInfo, c fuzz.Continue) { |
||||
switch c.Intn(2) { |
||||
case 0: |
||||
e.Type = A |
||||
c.Fuzz(&e.AInfo) |
||||
case 1: |
||||
e.Type = B |
||||
c.Fuzz(&e.BInfo) |
||||
} |
||||
}, |
||||
) |
||||
|
||||
var myObject MyInfo |
||||
f.Fuzz(&myObject) // Type will correspond to whether A or B info is set. |
||||
``` |
||||
|
||||
See more examples in ```example_test.go```. |
||||
|
||||
Happy testing! |
||||
@ -0,0 +1,18 @@ |
||||
/* |
||||
Copyright 2014 Google Inc. All rights reserved. |
||||
|
||||
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 fuzz is a library for populating go objects with random values.
|
||||
package fuzz |
||||
@ -0,0 +1,487 @@ |
||||
/* |
||||
Copyright 2014 Google Inc. All rights reserved. |
||||
|
||||
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 fuzz |
||||
|
||||
import ( |
||||
"fmt" |
||||
"math/rand" |
||||
"reflect" |
||||
"time" |
||||
) |
||||
|
||||
// fuzzFuncMap is a map from a type to a fuzzFunc that handles that type.
|
||||
type fuzzFuncMap map[reflect.Type]reflect.Value |
||||
|
||||
// Fuzzer knows how to fill any object with random fields.
|
||||
type Fuzzer struct { |
||||
fuzzFuncs fuzzFuncMap |
||||
defaultFuzzFuncs fuzzFuncMap |
||||
r *rand.Rand |
||||
nilChance float64 |
||||
minElements int |
||||
maxElements int |
||||
maxDepth int |
||||
} |
||||
|
||||
// New returns a new Fuzzer. Customize your Fuzzer further by calling Funcs,
|
||||
// RandSource, NilChance, or NumElements in any order.
|
||||
func New() *Fuzzer { |
||||
return NewWithSeed(time.Now().UnixNano()) |
||||
} |
||||
|
||||
func NewWithSeed(seed int64) *Fuzzer { |
||||
f := &Fuzzer{ |
||||
defaultFuzzFuncs: fuzzFuncMap{ |
||||
reflect.TypeOf(&time.Time{}): reflect.ValueOf(fuzzTime), |
||||
}, |
||||
|
||||
fuzzFuncs: fuzzFuncMap{}, |
||||
r: rand.New(rand.NewSource(seed)), |
||||
nilChance: .2, |
||||
minElements: 1, |
||||
maxElements: 10, |
||||
maxDepth: 100, |
||||
} |
||||
return f |
||||
} |
||||
|
||||
// Funcs adds each entry in fuzzFuncs as a custom fuzzing function.
|
||||
//
|
||||
// Each entry in fuzzFuncs must be a function taking two parameters.
|
||||
// The first parameter must be a pointer or map. It is the variable that
|
||||
// function will fill with random data. The second parameter must be a
|
||||
// fuzz.Continue, which will provide a source of randomness and a way
|
||||
// to automatically continue fuzzing smaller pieces of the first parameter.
|
||||
//
|
||||
// These functions are called sensibly, e.g., if you wanted custom string
|
||||
// fuzzing, the function `func(s *string, c fuzz.Continue)` would get
|
||||
// called and passed the address of strings. Maps and pointers will always
|
||||
// be made/new'd for you, ignoring the NilChange option. For slices, it
|
||||
// doesn't make much sense to pre-create them--Fuzzer doesn't know how
|
||||
// long you want your slice--so take a pointer to a slice, and make it
|
||||
// yourself. (If you don't want your map/pointer type pre-made, take a
|
||||
// pointer to it, and make it yourself.) See the examples for a range of
|
||||
// custom functions.
|
||||
func (f *Fuzzer) Funcs(fuzzFuncs ...interface{}) *Fuzzer { |
||||
for i := range fuzzFuncs { |
||||
v := reflect.ValueOf(fuzzFuncs[i]) |
||||
if v.Kind() != reflect.Func { |
||||
panic("Need only funcs!") |
||||
} |
||||
t := v.Type() |
||||
if t.NumIn() != 2 || t.NumOut() != 0 { |
||||
panic("Need 2 in and 0 out params!") |
||||
} |
||||
argT := t.In(0) |
||||
switch argT.Kind() { |
||||
case reflect.Ptr, reflect.Map: |
||||
default: |
||||
panic("fuzzFunc must take pointer or map type") |
||||
} |
||||
if t.In(1) != reflect.TypeOf(Continue{}) { |
||||
panic("fuzzFunc's second parameter must be type fuzz.Continue") |
||||
} |
||||
f.fuzzFuncs[argT] = v |
||||
} |
||||
return f |
||||
} |
||||
|
||||
// RandSource causes f to get values from the given source of randomness.
|
||||
// Use if you want deterministic fuzzing.
|
||||
func (f *Fuzzer) RandSource(s rand.Source) *Fuzzer { |
||||
f.r = rand.New(s) |
||||
return f |
||||
} |
||||
|
||||
// NilChance sets the probability of creating a nil pointer, map, or slice to
|
||||
// 'p'. 'p' should be between 0 (no nils) and 1 (all nils), inclusive.
|
||||
func (f *Fuzzer) NilChance(p float64) *Fuzzer { |
||||
if p < 0 || p > 1 { |
||||
panic("p should be between 0 and 1, inclusive.") |
||||
} |
||||
f.nilChance = p |
||||
return f |
||||
} |
||||
|
||||
// NumElements sets the minimum and maximum number of elements that will be
|
||||
// added to a non-nil map or slice.
|
||||
func (f *Fuzzer) NumElements(atLeast, atMost int) *Fuzzer { |
||||
if atLeast > atMost { |
||||
panic("atLeast must be <= atMost") |
||||
} |
||||
if atLeast < 0 { |
||||
panic("atLeast must be >= 0") |
||||
} |
||||
f.minElements = atLeast |
||||
f.maxElements = atMost |
||||
return f |
||||
} |
||||
|
||||
func (f *Fuzzer) genElementCount() int { |
||||
if f.minElements == f.maxElements { |
||||
return f.minElements |
||||
} |
||||
return f.minElements + f.r.Intn(f.maxElements-f.minElements+1) |
||||
} |
||||
|
||||
func (f *Fuzzer) genShouldFill() bool { |
||||
return f.r.Float64() > f.nilChance |
||||
} |
||||
|
||||
// MaxDepth sets the maximum number of recursive fuzz calls that will be made
|
||||
// before stopping. This includes struct members, pointers, and map and slice
|
||||
// elements.
|
||||
func (f *Fuzzer) MaxDepth(d int) *Fuzzer { |
||||
f.maxDepth = d |
||||
return f |
||||
} |
||||
|
||||
// Fuzz recursively fills all of obj's fields with something random. First
|
||||
// this tries to find a custom fuzz function (see Funcs). If there is no
|
||||
// custom function this tests whether the object implements fuzz.Interface and,
|
||||
// if so, calls Fuzz on it to fuzz itself. If that fails, this will see if
|
||||
// there is a default fuzz function provided by this package. If all of that
|
||||
// fails, this will generate random values for all primitive fields and then
|
||||
// recurse for all non-primitives.
|
||||
//
|
||||
// This is safe for cyclic or tree-like structs, up to a limit. Use the
|
||||
// MaxDepth method to adjust how deep you need it to recurse.
|
||||
//
|
||||
// obj must be a pointer. Only exported (public) fields can be set (thanks,
|
||||
// golang :/ ) Intended for tests, so will panic on bad input or unimplemented
|
||||
// fields.
|
||||
func (f *Fuzzer) Fuzz(obj interface{}) { |
||||
v := reflect.ValueOf(obj) |
||||
if v.Kind() != reflect.Ptr { |
||||
panic("needed ptr!") |
||||
} |
||||
v = v.Elem() |
||||
f.fuzzWithContext(v, 0) |
||||
} |
||||
|
||||
// FuzzNoCustom is just like Fuzz, except that any custom fuzz function for
|
||||
// obj's type will not be called and obj will not be tested for fuzz.Interface
|
||||
// conformance. This applies only to obj and not other instances of obj's
|
||||
// type.
|
||||
// Not safe for cyclic or tree-like structs!
|
||||
// obj must be a pointer. Only exported (public) fields can be set (thanks, golang :/ )
|
||||
// Intended for tests, so will panic on bad input or unimplemented fields.
|
||||
func (f *Fuzzer) FuzzNoCustom(obj interface{}) { |
||||
v := reflect.ValueOf(obj) |
||||
if v.Kind() != reflect.Ptr { |
||||
panic("needed ptr!") |
||||
} |
||||
v = v.Elem() |
||||
f.fuzzWithContext(v, flagNoCustomFuzz) |
||||
} |
||||
|
||||
const ( |
||||
// Do not try to find a custom fuzz function. Does not apply recursively.
|
||||
flagNoCustomFuzz uint64 = 1 << iota |
||||
) |
||||
|
||||
func (f *Fuzzer) fuzzWithContext(v reflect.Value, flags uint64) { |
||||
fc := &fuzzerContext{fuzzer: f} |
||||
fc.doFuzz(v, flags) |
||||
} |
||||
|
||||
// fuzzerContext carries context about a single fuzzing run, which lets Fuzzer
|
||||
// be thread-safe.
|
||||
type fuzzerContext struct { |
||||
fuzzer *Fuzzer |
||||
curDepth int |
||||
} |
||||
|
||||
func (fc *fuzzerContext) doFuzz(v reflect.Value, flags uint64) { |
||||
if fc.curDepth >= fc.fuzzer.maxDepth { |
||||
return |
||||
} |
||||
fc.curDepth++ |
||||
defer func() { fc.curDepth-- }() |
||||
|
||||
if !v.CanSet() { |
||||
return |
||||
} |
||||
|
||||
if flags&flagNoCustomFuzz == 0 { |
||||
// Check for both pointer and non-pointer custom functions.
|
||||
if v.CanAddr() && fc.tryCustom(v.Addr()) { |
||||
return |
||||
} |
||||
if fc.tryCustom(v) { |
||||
return |
||||
} |
||||
} |
||||
|
||||
if fn, ok := fillFuncMap[v.Kind()]; ok { |
||||
fn(v, fc.fuzzer.r) |
||||
return |
||||
} |
||||
switch v.Kind() { |
||||
case reflect.Map: |
||||
if fc.fuzzer.genShouldFill() { |
||||
v.Set(reflect.MakeMap(v.Type())) |
||||
n := fc.fuzzer.genElementCount() |
||||
for i := 0; i < n; i++ { |
||||
key := reflect.New(v.Type().Key()).Elem() |
||||
fc.doFuzz(key, 0) |
||||
val := reflect.New(v.Type().Elem()).Elem() |
||||
fc.doFuzz(val, 0) |
||||
v.SetMapIndex(key, val) |
||||
} |
||||
return |
||||
} |
||||
v.Set(reflect.Zero(v.Type())) |
||||
case reflect.Ptr: |
||||
if fc.fuzzer.genShouldFill() { |
||||
v.Set(reflect.New(v.Type().Elem())) |
||||
fc.doFuzz(v.Elem(), 0) |
||||
return |
||||
} |
||||
v.Set(reflect.Zero(v.Type())) |
||||
case reflect.Slice: |
||||
if fc.fuzzer.genShouldFill() { |
||||
n := fc.fuzzer.genElementCount() |
||||
v.Set(reflect.MakeSlice(v.Type(), n, n)) |
||||
for i := 0; i < n; i++ { |
||||
fc.doFuzz(v.Index(i), 0) |
||||
} |
||||
return |
||||
} |
||||
v.Set(reflect.Zero(v.Type())) |
||||
case reflect.Array: |
||||
if fc.fuzzer.genShouldFill() { |
||||
n := v.Len() |
||||
for i := 0; i < n; i++ { |
||||
fc.doFuzz(v.Index(i), 0) |
||||
} |
||||
return |
||||
} |
||||
v.Set(reflect.Zero(v.Type())) |
||||
case reflect.Struct: |
||||
for i := 0; i < v.NumField(); i++ { |
||||
fc.doFuzz(v.Field(i), 0) |
||||
} |
||||
case reflect.Chan: |
||||
fallthrough |
||||
case reflect.Func: |
||||
fallthrough |
||||
case reflect.Interface: |
||||
fallthrough |
||||
default: |
||||
panic(fmt.Sprintf("Can't handle %#v", v.Interface())) |
||||
} |
||||
} |
||||
|
||||
// tryCustom searches for custom handlers, and returns true iff it finds a match
|
||||
// and successfully randomizes v.
|
||||
func (fc *fuzzerContext) tryCustom(v reflect.Value) bool { |
||||
// First: see if we have a fuzz function for it.
|
||||
doCustom, ok := fc.fuzzer.fuzzFuncs[v.Type()] |
||||
if !ok { |
||||
// Second: see if it can fuzz itself.
|
||||
if v.CanInterface() { |
||||
intf := v.Interface() |
||||
if fuzzable, ok := intf.(Interface); ok { |
||||
fuzzable.Fuzz(Continue{fc: fc, Rand: fc.fuzzer.r}) |
||||
return true |
||||
} |
||||
} |
||||
// Finally: see if there is a default fuzz function.
|
||||
doCustom, ok = fc.fuzzer.defaultFuzzFuncs[v.Type()] |
||||
if !ok { |
||||
return false |
||||
} |
||||
} |
||||
|
||||
switch v.Kind() { |
||||
case reflect.Ptr: |
||||
if v.IsNil() { |
||||
if !v.CanSet() { |
||||
return false |
||||
} |
||||
v.Set(reflect.New(v.Type().Elem())) |
||||
} |
||||
case reflect.Map: |
||||
if v.IsNil() { |
||||
if !v.CanSet() { |
||||
return false |
||||
} |
||||
v.Set(reflect.MakeMap(v.Type())) |
||||
} |
||||
default: |
||||
return false |
||||
} |
||||
|
||||
doCustom.Call([]reflect.Value{v, reflect.ValueOf(Continue{ |
||||
fc: fc, |
||||
Rand: fc.fuzzer.r, |
||||
})}) |
||||
return true |
||||
} |
||||
|
||||
// Interface represents an object that knows how to fuzz itself. Any time we
|
||||
// find a type that implements this interface we will delegate the act of
|
||||
// fuzzing itself.
|
||||
type Interface interface { |
||||
Fuzz(c Continue) |
||||
} |
||||
|
||||
// Continue can be passed to custom fuzzing functions to allow them to use
|
||||
// the correct source of randomness and to continue fuzzing their members.
|
||||
type Continue struct { |
||||
fc *fuzzerContext |
||||
|
||||
// For convenience, Continue implements rand.Rand via embedding.
|
||||
// Use this for generating any randomness if you want your fuzzing
|
||||
// to be repeatable for a given seed.
|
||||
*rand.Rand |
||||
} |
||||
|
||||
// Fuzz continues fuzzing obj. obj must be a pointer.
|
||||
func (c Continue) Fuzz(obj interface{}) { |
||||
v := reflect.ValueOf(obj) |
||||
if v.Kind() != reflect.Ptr { |
||||
panic("needed ptr!") |
||||
} |
||||
v = v.Elem() |
||||
c.fc.doFuzz(v, 0) |
||||
} |
||||
|
||||
// FuzzNoCustom continues fuzzing obj, except that any custom fuzz function for
|
||||
// obj's type will not be called and obj will not be tested for fuzz.Interface
|
||||
// conformance. This applies only to obj and not other instances of obj's
|
||||
// type.
|
||||
func (c Continue) FuzzNoCustom(obj interface{}) { |
||||
v := reflect.ValueOf(obj) |
||||
if v.Kind() != reflect.Ptr { |
||||
panic("needed ptr!") |
||||
} |
||||
v = v.Elem() |
||||
c.fc.doFuzz(v, flagNoCustomFuzz) |
||||
} |
||||
|
||||
// RandString makes a random string up to 20 characters long. The returned string
|
||||
// may include a variety of (valid) UTF-8 encodings.
|
||||
func (c Continue) RandString() string { |
||||
return randString(c.Rand) |
||||
} |
||||
|
||||
// RandUint64 makes random 64 bit numbers.
|
||||
// Weirdly, rand doesn't have a function that gives you 64 random bits.
|
||||
func (c Continue) RandUint64() uint64 { |
||||
return randUint64(c.Rand) |
||||
} |
||||
|
||||
// RandBool returns true or false randomly.
|
||||
func (c Continue) RandBool() bool { |
||||
return randBool(c.Rand) |
||||
} |
||||
|
||||
func fuzzInt(v reflect.Value, r *rand.Rand) { |
||||
v.SetInt(int64(randUint64(r))) |
||||
} |
||||
|
||||
func fuzzUint(v reflect.Value, r *rand.Rand) { |
||||
v.SetUint(randUint64(r)) |
||||
} |
||||
|
||||
func fuzzTime(t *time.Time, c Continue) { |
||||
var sec, nsec int64 |
||||
// Allow for about 1000 years of random time values, which keeps things
|
||||
// like JSON parsing reasonably happy.
|
||||
sec = c.Rand.Int63n(1000 * 365 * 24 * 60 * 60) |
||||
c.Fuzz(&nsec) |
||||
*t = time.Unix(sec, nsec) |
||||
} |
||||
|
||||
var fillFuncMap = map[reflect.Kind]func(reflect.Value, *rand.Rand){ |
||||
reflect.Bool: func(v reflect.Value, r *rand.Rand) { |
||||
v.SetBool(randBool(r)) |
||||
}, |
||||
reflect.Int: fuzzInt, |
||||
reflect.Int8: fuzzInt, |
||||
reflect.Int16: fuzzInt, |
||||
reflect.Int32: fuzzInt, |
||||
reflect.Int64: fuzzInt, |
||||
reflect.Uint: fuzzUint, |
||||
reflect.Uint8: fuzzUint, |
||||
reflect.Uint16: fuzzUint, |
||||
reflect.Uint32: fuzzUint, |
||||
reflect.Uint64: fuzzUint, |
||||
reflect.Uintptr: fuzzUint, |
||||
reflect.Float32: func(v reflect.Value, r *rand.Rand) { |
||||
v.SetFloat(float64(r.Float32())) |
||||
}, |
||||
reflect.Float64: func(v reflect.Value, r *rand.Rand) { |
||||
v.SetFloat(r.Float64()) |
||||
}, |
||||
reflect.Complex64: func(v reflect.Value, r *rand.Rand) { |
||||
panic("unimplemented") |
||||
}, |
||||
reflect.Complex128: func(v reflect.Value, r *rand.Rand) { |
||||
panic("unimplemented") |
||||
}, |
||||
reflect.String: func(v reflect.Value, r *rand.Rand) { |
||||
v.SetString(randString(r)) |
||||
}, |
||||
reflect.UnsafePointer: func(v reflect.Value, r *rand.Rand) { |
||||
panic("unimplemented") |
||||
}, |
||||
} |
||||
|
||||
// randBool returns true or false randomly.
|
||||
func randBool(r *rand.Rand) bool { |
||||
if r.Int()&1 == 1 { |
||||
return true |
||||
} |
||||
return false |
||||
} |
||||
|
||||
type charRange struct { |
||||
first, last rune |
||||
} |
||||
|
||||
// choose returns a random unicode character from the given range, using the
|
||||
// given randomness source.
|
||||
func (r *charRange) choose(rand *rand.Rand) rune { |
||||
count := int64(r.last - r.first) |
||||
return r.first + rune(rand.Int63n(count)) |
||||
} |
||||
|
||||
var unicodeRanges = []charRange{ |
||||
{' ', '~'}, // ASCII characters
|
||||
{'\u00a0', '\u02af'}, // Multi-byte encoded characters
|
||||
{'\u4e00', '\u9fff'}, // Common CJK (even longer encodings)
|
||||
} |
||||
|
||||
// randString makes a random string up to 20 characters long. The returned string
|
||||
// may include a variety of (valid) UTF-8 encodings.
|
||||
func randString(r *rand.Rand) string { |
||||
n := r.Intn(20) |
||||
runes := make([]rune, n) |
||||
for i := range runes { |
||||
runes[i] = unicodeRanges[r.Intn(len(unicodeRanges))].choose(r) |
||||
} |
||||
return string(runes) |
||||
} |
||||
|
||||
// randUint64 makes random 64 bit numbers.
|
||||
// Weirdly, rand doesn't have a function that gives you 64 random bits.
|
||||
func randUint64(r *rand.Rand) uint64 { |
||||
return uint64(r.Uint32())<<32 | uint64(r.Uint32()) |
||||
} |
||||
@ -0,0 +1,3 @@ |
||||
module github.com/google/gofuzz |
||||
|
||||
go 1.12 |
||||
@ -0,0 +1,12 @@ |
||||
version = 1 |
||||
|
||||
test_patterns = [ |
||||
"*_test.go" |
||||
] |
||||
|
||||
[[analyzers]] |
||||
name = "go" |
||||
enabled = true |
||||
|
||||
[analyzers.meta] |
||||
import_path = "github.com/imdario/mergo" |
||||
@ -0,0 +1,33 @@ |
||||
#### joe made this: http://goel.io/joe |
||||
|
||||
#### go #### |
||||
# Binaries for programs and plugins |
||||
*.exe |
||||
*.dll |
||||
*.so |
||||
*.dylib |
||||
|
||||
# Test binary, build with `go test -c` |
||||
*.test |
||||
|
||||
# Output of the go coverage tool, specifically when used with LiteIDE |
||||
*.out |
||||
|
||||
# Project-local glide cache, RE: https://github.com/Masterminds/glide/issues/736 |
||||
.glide/ |
||||
|
||||
#### vim #### |
||||
# Swap |
||||
[._]*.s[a-v][a-z] |
||||
[._]*.sw[a-p] |
||||
[._]s[a-v][a-z] |
||||
[._]sw[a-p] |
||||
|
||||
# Session |
||||
Session.vim |
||||
|
||||
# Temporary |
||||
.netrwhist |
||||
*~ |
||||
# Auto-generated tag files |
||||
tags |
||||
@ -0,0 +1,9 @@ |
||||
language: go |
||||
install: |
||||
- go get -t |
||||
- go get golang.org/x/tools/cmd/cover |
||||
- go get github.com/mattn/goveralls |
||||
script: |
||||
- go test -race -v ./... |
||||
after_script: |
||||
- $HOME/gopath/bin/goveralls -service=travis-ci -repotoken $COVERALLS_TOKEN |
||||
@ -0,0 +1,46 @@ |
||||
# Contributor Covenant Code of Conduct |
||||
|
||||
## Our Pledge |
||||
|
||||
In the interest of fostering an open and welcoming environment, we as contributors and maintainers pledge to making participation in our project and our community a harassment-free experience for everyone, regardless of age, body size, disability, ethnicity, gender identity and expression, level of experience, nationality, personal appearance, race, religion, or sexual identity and orientation. |
||||
|
||||
## Our Standards |
||||
|
||||
Examples of behavior that contributes to creating a positive environment include: |
||||
|
||||
* Using welcoming and inclusive language |
||||
* Being respectful of differing viewpoints and experiences |
||||
* Gracefully accepting constructive criticism |
||||
* Focusing on what is best for the community |
||||
* Showing empathy towards other community members |
||||
|
||||
Examples of unacceptable behavior by participants include: |
||||
|
||||
* The use of sexualized language or imagery and unwelcome sexual attention or advances |
||||
* Trolling, insulting/derogatory comments, and personal or political attacks |
||||
* Public or private harassment |
||||
* Publishing others' private information, such as a physical or electronic address, without explicit permission |
||||
* Other conduct which could reasonably be considered inappropriate in a professional setting |
||||
|
||||
## Our Responsibilities |
||||
|
||||
Project maintainers are responsible for clarifying the standards of acceptable behavior and are expected to take appropriate and fair corrective action in response to any instances of unacceptable behavior. |
||||
|
||||
Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct, or to ban temporarily or permanently any contributor for other behaviors that they deem inappropriate, threatening, offensive, or harmful. |
||||
|
||||
## Scope |
||||
|
||||
This Code of Conduct applies both within project spaces and in public spaces when an individual is representing the project or its community. Examples of representing a project or community include using an official project e-mail address, posting via an official social media account, or acting as an appointed representative at an online or offline event. Representation of a project may be further defined and clarified by project maintainers. |
||||
|
||||
## Enforcement |
||||
|
||||
Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by contacting the project team at i@dario.im. The project team will review and investigate all complaints, and will respond in a way that it deems appropriate to the circumstances. The project team is obligated to maintain confidentiality with regard to the reporter of an incident. Further details of specific enforcement policies may be posted separately. |
||||
|
||||
Project maintainers who do not follow or enforce the Code of Conduct in good faith may face temporary or permanent repercussions as determined by other members of the project's leadership. |
||||
|
||||
## Attribution |
||||
|
||||
This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4, available at [http://contributor-covenant.org/version/1/4][version] |
||||
|
||||
[homepage]: http://contributor-covenant.org |
||||
[version]: http://contributor-covenant.org/version/1/4/ |
||||
@ -0,0 +1,28 @@ |
||||
Copyright (c) 2013 Dario Castañé. All rights reserved. |
||||
Copyright (c) 2012 The Go Authors. All rights reserved. |
||||
|
||||
Redistribution and use in source and binary forms, with or without |
||||
modification, are permitted provided that the following conditions are |
||||
met: |
||||
|
||||
* Redistributions of source code must retain the above copyright |
||||
notice, this list of conditions and the following disclaimer. |
||||
* Redistributions in binary form must reproduce the above |
||||
copyright notice, this list of conditions and the following disclaimer |
||||
in the documentation and/or other materials provided with the |
||||
distribution. |
||||
* Neither the name of Google Inc. nor the names of its |
||||
contributors may be used to endorse or promote products derived from |
||||
this software without specific prior written permission. |
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||
@ -0,0 +1,238 @@ |
||||
# Mergo |
||||
|
||||
A helper to merge structs and maps in Golang. Useful for configuration default values, avoiding messy if-statements. |
||||
|
||||
Also a lovely [comune](http://en.wikipedia.org/wiki/Mergo) (municipality) in the Province of Ancona in the Italian region of Marche. |
||||
|
||||
## Status |
||||
|
||||
It is ready for production use. [It is used in several projects by Docker, Google, The Linux Foundation, VMWare, Shopify, etc](https://github.com/imdario/mergo#mergo-in-the-wild). |
||||
|
||||
[![GoDoc][3]][4] |
||||
[![GoCard][5]][6] |
||||
[![Build Status][1]][2] |
||||
[![Coverage Status][7]][8] |
||||
[![Sourcegraph][9]][10] |
||||
[](https://app.fossa.io/projects/git%2Bgithub.com%2Fimdario%2Fmergo?ref=badge_shield) |
||||
|
||||
[1]: https://travis-ci.org/imdario/mergo.png |
||||
[2]: https://travis-ci.org/imdario/mergo |
||||
[3]: https://godoc.org/github.com/imdario/mergo?status.svg |
||||
[4]: https://godoc.org/github.com/imdario/mergo |
||||
[5]: https://goreportcard.com/badge/imdario/mergo |
||||
[6]: https://goreportcard.com/report/github.com/imdario/mergo |
||||
[7]: https://coveralls.io/repos/github/imdario/mergo/badge.svg?branch=master |
||||
[8]: https://coveralls.io/github/imdario/mergo?branch=master |
||||
[9]: https://sourcegraph.com/github.com/imdario/mergo/-/badge.svg |
||||
[10]: https://sourcegraph.com/github.com/imdario/mergo?badge |
||||
|
||||
### Latest release |
||||
|
||||
[Release v0.3.7](https://github.com/imdario/mergo/releases/tag/v0.3.7). |
||||
|
||||
### Important note |
||||
|
||||
Please keep in mind that in [0.3.2](//github.com/imdario/mergo/releases/tag/0.3.2) Mergo changed `Merge()`and `Map()` signatures to support [transformers](#transformers). An optional/variadic argument has been added, so it won't break existing code. |
||||
|
||||
If you were using Mergo **before** April 6th 2015, please check your project works as intended after updating your local copy with ```go get -u github.com/imdario/mergo```. I apologize for any issue caused by its previous behavior and any future bug that Mergo could cause (I hope it won't!) in existing projects after the change (release 0.2.0). |
||||
|
||||
### Donations |
||||
|
||||
If Mergo is useful to you, consider buying me a coffee, a beer or making a monthly donation so I can keep building great free software. :heart_eyes: |
||||
|
||||
<a href='https://ko-fi.com/B0B58839' target='_blank'><img height='36' style='border:0px;height:36px;' src='https://az743702.vo.msecnd.net/cdn/kofi1.png?v=0' border='0' alt='Buy Me a Coffee at ko-fi.com' /></a> |
||||
[](https://beerpay.io/imdario/mergo) |
||||
[](https://beerpay.io/imdario/mergo) |
||||
<a href="https://liberapay.com/dario/donate"><img alt="Donate using Liberapay" src="https://liberapay.com/assets/widgets/donate.svg"></a> |
||||
|
||||
### Mergo in the wild |
||||
|
||||
- [moby/moby](https://github.com/moby/moby) |
||||
- [kubernetes/kubernetes](https://github.com/kubernetes/kubernetes) |
||||
- [vmware/dispatch](https://github.com/vmware/dispatch) |
||||
- [Shopify/themekit](https://github.com/Shopify/themekit) |
||||
- [imdario/zas](https://github.com/imdario/zas) |
||||
- [matcornic/hermes](https://github.com/matcornic/hermes) |
||||
- [OpenBazaar/openbazaar-go](https://github.com/OpenBazaar/openbazaar-go) |
||||
- [kataras/iris](https://github.com/kataras/iris) |
||||
- [michaelsauter/crane](https://github.com/michaelsauter/crane) |
||||
- [go-task/task](https://github.com/go-task/task) |
||||
- [sensu/uchiwa](https://github.com/sensu/uchiwa) |
||||
- [ory/hydra](https://github.com/ory/hydra) |
||||
- [sisatech/vcli](https://github.com/sisatech/vcli) |
||||
- [dairycart/dairycart](https://github.com/dairycart/dairycart) |
||||
- [projectcalico/felix](https://github.com/projectcalico/felix) |
||||
- [resin-os/balena](https://github.com/resin-os/balena) |
||||
- [go-kivik/kivik](https://github.com/go-kivik/kivik) |
||||
- [Telefonica/govice](https://github.com/Telefonica/govice) |
||||
- [supergiant/supergiant](supergiant/supergiant) |
||||
- [SergeyTsalkov/brooce](https://github.com/SergeyTsalkov/brooce) |
||||
- [soniah/dnsmadeeasy](https://github.com/soniah/dnsmadeeasy) |
||||
- [ohsu-comp-bio/funnel](https://github.com/ohsu-comp-bio/funnel) |
||||
- [EagerIO/Stout](https://github.com/EagerIO/Stout) |
||||
- [lynndylanhurley/defsynth-api](https://github.com/lynndylanhurley/defsynth-api) |
||||
- [russross/canvasassignments](https://github.com/russross/canvasassignments) |
||||
- [rdegges/cryptly-api](https://github.com/rdegges/cryptly-api) |
||||
- [casualjim/exeggutor](https://github.com/casualjim/exeggutor) |
||||
- [divshot/gitling](https://github.com/divshot/gitling) |
||||
- [RWJMurphy/gorl](https://github.com/RWJMurphy/gorl) |
||||
- [andrerocker/deploy42](https://github.com/andrerocker/deploy42) |
||||
- [elwinar/rambler](https://github.com/elwinar/rambler) |
||||
- [tmaiaroto/gopartman](https://github.com/tmaiaroto/gopartman) |
||||
- [jfbus/impressionist](https://github.com/jfbus/impressionist) |
||||
- [Jmeyering/zealot](https://github.com/Jmeyering/zealot) |
||||
- [godep-migrator/rigger-host](https://github.com/godep-migrator/rigger-host) |
||||
- [Dronevery/MultiwaySwitch-Go](https://github.com/Dronevery/MultiwaySwitch-Go) |
||||
- [thoas/picfit](https://github.com/thoas/picfit) |
||||
- [mantasmatelis/whooplist-server](https://github.com/mantasmatelis/whooplist-server) |
||||
- [jnuthong/item_search](https://github.com/jnuthong/item_search) |
||||
- [bukalapak/snowboard](https://github.com/bukalapak/snowboard) |
||||
|
||||
## Installation |
||||
|
||||
go get github.com/imdario/mergo |
||||
|
||||
// use in your .go code |
||||
import ( |
||||
"github.com/imdario/mergo" |
||||
) |
||||
|
||||
## Usage |
||||
|
||||
You can only merge same-type structs with exported fields initialized as zero value of their type and same-types maps. Mergo won't merge unexported (private) fields but will do recursively any exported one. It won't merge empty structs value as [they are not considered zero values](https://golang.org/ref/spec#The_zero_value) either. Also maps will be merged recursively except for structs inside maps (because they are not addressable using Go reflection). |
||||
|
||||
```go |
||||
if err := mergo.Merge(&dst, src); err != nil { |
||||
// ... |
||||
} |
||||
``` |
||||
|
||||
Also, you can merge overwriting values using the transformer `WithOverride`. |
||||
|
||||
```go |
||||
if err := mergo.Merge(&dst, src, mergo.WithOverride); err != nil { |
||||
// ... |
||||
} |
||||
``` |
||||
|
||||
Additionally, you can map a `map[string]interface{}` to a struct (and otherwise, from struct to map), following the same restrictions as in `Merge()`. Keys are capitalized to find each corresponding exported field. |
||||
|
||||
```go |
||||
if err := mergo.Map(&dst, srcMap); err != nil { |
||||
// ... |
||||
} |
||||
``` |
||||
|
||||
Warning: if you map a struct to map, it won't do it recursively. Don't expect Mergo to map struct members of your struct as `map[string]interface{}`. They will be just assigned as values. |
||||
|
||||
More information and examples in [godoc documentation](http://godoc.org/github.com/imdario/mergo). |
||||
|
||||
### Nice example |
||||
|
||||
```go |
||||
package main |
||||
|
||||
import ( |
||||
"fmt" |
||||
"github.com/imdario/mergo" |
||||
) |
||||
|
||||
type Foo struct { |
||||
A string |
||||
B int64 |
||||
} |
||||
|
||||
func main() { |
||||
src := Foo{ |
||||
A: "one", |
||||
B: 2, |
||||
} |
||||
dest := Foo{ |
||||
A: "two", |
||||
} |
||||
mergo.Merge(&dest, src) |
||||
fmt.Println(dest) |
||||
// Will print |
||||
// {two 2} |
||||
} |
||||
``` |
||||
|
||||
Note: if test are failing due missing package, please execute: |
||||
|
||||
go get gopkg.in/yaml.v2 |
||||
|
||||
### Transformers |
||||
|
||||
Transformers allow to merge specific types differently than in the default behavior. In other words, now you can customize how some types are merged. For example, `time.Time` is a struct; it doesn't have zero value but IsZero can return true because it has fields with zero value. How can we merge a non-zero `time.Time`? |
||||
|
||||
```go |
||||
package main |
||||
|
||||
import ( |
||||
"fmt" |
||||
"github.com/imdario/mergo" |
||||
"reflect" |
||||
"time" |
||||
) |
||||
|
||||
type timeTransfomer struct { |
||||
} |
||||
|
||||
func (t timeTransfomer) Transformer(typ reflect.Type) func(dst, src reflect.Value) error { |
||||
if typ == reflect.TypeOf(time.Time{}) { |
||||
return func(dst, src reflect.Value) error { |
||||
if dst.CanSet() { |
||||
isZero := dst.MethodByName("IsZero") |
||||
result := isZero.Call([]reflect.Value{}) |
||||
if result[0].Bool() { |
||||
dst.Set(src) |
||||
} |
||||
} |
||||
return nil |
||||
} |
||||
} |
||||
return nil |
||||
} |
||||
|
||||
type Snapshot struct { |
||||
Time time.Time |
||||
// ... |
||||
} |
||||
|
||||
func main() { |
||||
src := Snapshot{time.Now()} |
||||
dest := Snapshot{} |
||||
mergo.Merge(&dest, src, mergo.WithTransformers(timeTransfomer{})) |
||||
fmt.Println(dest) |
||||
// Will print |
||||
// { 2018-01-12 01:15:00 +0000 UTC m=+0.000000001 } |
||||
} |
||||
``` |
||||
|
||||
|
||||
## Contact me |
||||
|
||||
If I can help you, you have an idea or you are using Mergo in your projects, don't hesitate to drop me a line (or a pull request): [@im_dario](https://twitter.com/im_dario) |
||||
|
||||
## About |
||||
|
||||
Written by [Dario Castañé](http://dario.im). |
||||
|
||||
## Top Contributors |
||||
|
||||
[](https://sourcerer.io/fame/imdario/imdario/mergo/links/0) |
||||
[](https://sourcerer.io/fame/imdario/imdario/mergo/links/1) |
||||
[](https://sourcerer.io/fame/imdario/imdario/mergo/links/2) |
||||
[](https://sourcerer.io/fame/imdario/imdario/mergo/links/3) |
||||
[](https://sourcerer.io/fame/imdario/imdario/mergo/links/4) |
||||
[](https://sourcerer.io/fame/imdario/imdario/mergo/links/5) |
||||
[](https://sourcerer.io/fame/imdario/imdario/mergo/links/6) |
||||
[](https://sourcerer.io/fame/imdario/imdario/mergo/links/7) |
||||
|
||||
|
||||
## License |
||||
|
||||
[BSD 3-Clause](http://opensource.org/licenses/BSD-3-Clause) license, as [Go language](http://golang.org/LICENSE). |
||||
|
||||
|
||||
[](https://app.fossa.io/projects/git%2Bgithub.com%2Fimdario%2Fmergo?ref=badge_large) |
||||
@ -0,0 +1,44 @@ |
||||
// Copyright 2013 Dario Castañé. All rights reserved.
|
||||
// Copyright 2009 The Go Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
/* |
||||
Package mergo merges same-type structs and maps by setting default values in zero-value fields. |
||||
|
||||
Mergo won't merge unexported (private) fields but will do recursively any exported one. It also won't merge structs inside maps (because they are not addressable using Go reflection). |
||||
|
||||
Usage |
||||
|
||||
From my own work-in-progress project: |
||||
|
||||
type networkConfig struct { |
||||
Protocol string |
||||
Address string |
||||
ServerType string `json: "server_type"` |
||||
Port uint16 |
||||
} |
||||
|
||||
type FssnConfig struct { |
||||
Network networkConfig |
||||
} |
||||
|
||||
var fssnDefault = FssnConfig { |
||||
networkConfig { |
||||
"tcp", |
||||
"127.0.0.1", |
||||
"http", |
||||
31560, |
||||
}, |
||||
} |
||||
|
||||
// Inside a function [...]
|
||||
|
||||
if err := mergo.Merge(&config, fssnDefault); err != nil { |
||||
log.Fatal(err) |
||||
} |
||||
|
||||
// More code [...]
|
||||
|
||||
*/ |
||||
package mergo |
||||
@ -0,0 +1,176 @@ |
||||
// Copyright 2014 Dario Castañé. All rights reserved.
|
||||
// Copyright 2009 The Go Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
// Based on src/pkg/reflect/deepequal.go from official
|
||||
// golang's stdlib.
|
||||
|
||||
package mergo |
||||
|
||||
import ( |
||||
"fmt" |
||||
"reflect" |
||||
"unicode" |
||||
"unicode/utf8" |
||||
) |
||||
|
||||
func changeInitialCase(s string, mapper func(rune) rune) string { |
||||
if s == "" { |
||||
return s |
||||
} |
||||
r, n := utf8.DecodeRuneInString(s) |
||||
return string(mapper(r)) + s[n:] |
||||
} |
||||
|
||||
func isExported(field reflect.StructField) bool { |
||||
r, _ := utf8.DecodeRuneInString(field.Name) |
||||
return r >= 'A' && r <= 'Z' |
||||
} |
||||
|
||||
// Traverses recursively both values, assigning src's fields values to dst.
|
||||
// The map argument tracks comparisons that have already been seen, which allows
|
||||
// short circuiting on recursive types.
|
||||
func deepMap(dst, src reflect.Value, visited map[uintptr]*visit, depth int, config *Config) (err error) { |
||||
overwrite := config.Overwrite |
||||
if dst.CanAddr() { |
||||
addr := dst.UnsafeAddr() |
||||
h := 17 * addr |
||||
seen := visited[h] |
||||
typ := dst.Type() |
||||
for p := seen; p != nil; p = p.next { |
||||
if p.ptr == addr && p.typ == typ { |
||||
return nil |
||||
} |
||||
} |
||||
// Remember, remember...
|
||||
visited[h] = &visit{addr, typ, seen} |
||||
} |
||||
zeroValue := reflect.Value{} |
||||
switch dst.Kind() { |
||||
case reflect.Map: |
||||
dstMap := dst.Interface().(map[string]interface{}) |
||||
for i, n := 0, src.NumField(); i < n; i++ { |
||||
srcType := src.Type() |
||||
field := srcType.Field(i) |
||||
if !isExported(field) { |
||||
continue |
||||
} |
||||
fieldName := field.Name |
||||
fieldName = changeInitialCase(fieldName, unicode.ToLower) |
||||
if v, ok := dstMap[fieldName]; !ok || (isEmptyValue(reflect.ValueOf(v)) || overwrite) { |
||||
dstMap[fieldName] = src.Field(i).Interface() |
||||
} |
||||
} |
||||
case reflect.Ptr: |
||||
if dst.IsNil() { |
||||
v := reflect.New(dst.Type().Elem()) |
||||
dst.Set(v) |
||||
} |
||||
dst = dst.Elem() |
||||
fallthrough |
||||
case reflect.Struct: |
||||
srcMap := src.Interface().(map[string]interface{}) |
||||
for key := range srcMap { |
||||
config.overwriteWithEmptyValue = true |
||||
srcValue := srcMap[key] |
||||
fieldName := changeInitialCase(key, unicode.ToUpper) |
||||
dstElement := dst.FieldByName(fieldName) |
||||
if dstElement == zeroValue { |
||||
// We discard it because the field doesn't exist.
|
||||
continue |
||||
} |
||||
srcElement := reflect.ValueOf(srcValue) |
||||
dstKind := dstElement.Kind() |
||||
srcKind := srcElement.Kind() |
||||
if srcKind == reflect.Ptr && dstKind != reflect.Ptr { |
||||
srcElement = srcElement.Elem() |
||||
srcKind = reflect.TypeOf(srcElement.Interface()).Kind() |
||||
} else if dstKind == reflect.Ptr { |
||||
// Can this work? I guess it can't.
|
||||
if srcKind != reflect.Ptr && srcElement.CanAddr() { |
||||
srcPtr := srcElement.Addr() |
||||
srcElement = reflect.ValueOf(srcPtr) |
||||
srcKind = reflect.Ptr |
||||
} |
||||
} |
||||
|
||||
if !srcElement.IsValid() { |
||||
continue |
||||
} |
||||
if srcKind == dstKind { |
||||
if _, err = deepMerge(dstElement, srcElement, visited, depth+1, config); err != nil { |
||||
return |
||||
} |
||||
} else if dstKind == reflect.Interface && dstElement.Kind() == reflect.Interface { |
||||
if _, err = deepMerge(dstElement, srcElement, visited, depth+1, config); err != nil { |
||||
return |
||||
} |
||||
} else if srcKind == reflect.Map { |
||||
if err = deepMap(dstElement, srcElement, visited, depth+1, config); err != nil { |
||||
return |
||||
} |
||||
} else { |
||||
return fmt.Errorf("type mismatch on %s field: found %v, expected %v", fieldName, srcKind, dstKind) |
||||
} |
||||
} |
||||
} |
||||
return |
||||
} |
||||
|
||||
// Map sets fields' values in dst from src.
|
||||
// src can be a map with string keys or a struct. dst must be the opposite:
|
||||
// if src is a map, dst must be a valid pointer to struct. If src is a struct,
|
||||
// dst must be map[string]interface{}.
|
||||
// It won't merge unexported (private) fields and will do recursively
|
||||
// any exported field.
|
||||
// If dst is a map, keys will be src fields' names in lower camel case.
|
||||
// Missing key in src that doesn't match a field in dst will be skipped. This
|
||||
// doesn't apply if dst is a map.
|
||||
// This is separated method from Merge because it is cleaner and it keeps sane
|
||||
// semantics: merging equal types, mapping different (restricted) types.
|
||||
func Map(dst, src interface{}, opts ...func(*Config)) error { |
||||
return _map(dst, src, opts...) |
||||
} |
||||
|
||||
// MapWithOverwrite will do the same as Map except that non-empty dst attributes will be overridden by
|
||||
// non-empty src attribute values.
|
||||
// Deprecated: Use Map(…) with WithOverride
|
||||
func MapWithOverwrite(dst, src interface{}, opts ...func(*Config)) error { |
||||
return _map(dst, src, append(opts, WithOverride)...) |
||||
} |
||||
|
||||
func _map(dst, src interface{}, opts ...func(*Config)) error { |
||||
var ( |
||||
vDst, vSrc reflect.Value |
||||
err error |
||||
) |
||||
config := &Config{} |
||||
|
||||
for _, opt := range opts { |
||||
opt(config) |
||||
} |
||||
|
||||
if vDst, vSrc, err = resolveValues(dst, src); err != nil { |
||||
return err |
||||
} |
||||
// To be friction-less, we redirect equal-type arguments
|
||||
// to deepMerge. Only because arguments can be anything.
|
||||
if vSrc.Kind() == vDst.Kind() { |
||||
_, err := deepMerge(vDst, vSrc, make(map[uintptr]*visit), 0, config) |
||||
return err |
||||
} |
||||
switch vSrc.Kind() { |
||||
case reflect.Struct: |
||||
if vDst.Kind() != reflect.Map { |
||||
return ErrExpectedMapAsDestination |
||||
} |
||||
case reflect.Map: |
||||
if vDst.Kind() != reflect.Struct { |
||||
return ErrExpectedStructAsDestination |
||||
} |
||||
default: |
||||
return ErrNotSupported |
||||
} |
||||
return deepMap(vDst, vSrc, make(map[uintptr]*visit), 0, config) |
||||
} |
||||
@ -0,0 +1,338 @@ |
||||
// Copyright 2013 Dario Castañé. All rights reserved.
|
||||
// Copyright 2009 The Go Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
// Based on src/pkg/reflect/deepequal.go from official
|
||||
// golang's stdlib.
|
||||
|
||||
package mergo |
||||
|
||||
import ( |
||||
"fmt" |
||||
"reflect" |
||||
"unsafe" |
||||
) |
||||
|
||||
func hasExportedField(dst reflect.Value) (exported bool) { |
||||
for i, n := 0, dst.NumField(); i < n; i++ { |
||||
field := dst.Type().Field(i) |
||||
if isExportedComponent(&field) { |
||||
return true |
||||
} |
||||
} |
||||
return |
||||
} |
||||
|
||||
func isExportedComponent(field *reflect.StructField) bool { |
||||
name := field.Name |
||||
pkgPath := field.PkgPath |
||||
if len(pkgPath) > 0 { |
||||
return false |
||||
} |
||||
c := name[0] |
||||
if 'a' <= c && c <= 'z' || c == '_' { |
||||
return false |
||||
} |
||||
return true |
||||
} |
||||
|
||||
type Config struct { |
||||
Overwrite bool |
||||
AppendSlice bool |
||||
TypeCheck bool |
||||
Transformers Transformers |
||||
overwriteWithEmptyValue bool |
||||
overwriteSliceWithEmptyValue bool |
||||
} |
||||
|
||||
type Transformers interface { |
||||
Transformer(reflect.Type) func(dst, src reflect.Value) error |
||||
} |
||||
|
||||
// Traverses recursively both values, assigning src's fields values to dst.
|
||||
// The map argument tracks comparisons that have already been seen, which allows
|
||||
// short circuiting on recursive types.
|
||||
func deepMerge(dstIn, src reflect.Value, visited map[uintptr]*visit, depth int, config *Config) (dst reflect.Value, err error) { |
||||
dst = dstIn |
||||
overwrite := config.Overwrite |
||||
typeCheck := config.TypeCheck |
||||
overwriteWithEmptySrc := config.overwriteWithEmptyValue |
||||
overwriteSliceWithEmptySrc := config.overwriteSliceWithEmptyValue |
||||
|
||||
if !src.IsValid() { |
||||
return |
||||
} |
||||
|
||||
if dst.CanAddr() { |
||||
addr := dst.UnsafeAddr() |
||||
h := 17 * addr |
||||
seen := visited[h] |
||||
typ := dst.Type() |
||||
for p := seen; p != nil; p = p.next { |
||||
if p.ptr == addr && p.typ == typ { |
||||
return dst, nil |
||||
} |
||||
} |
||||
// Remember, remember...
|
||||
visited[h] = &visit{addr, typ, seen} |
||||
} |
||||
|
||||
if config.Transformers != nil && !isEmptyValue(dst) { |
||||
if fn := config.Transformers.Transformer(dst.Type()); fn != nil { |
||||
err = fn(dst, src) |
||||
return |
||||
} |
||||
} |
||||
|
||||
if dst.IsValid() && src.IsValid() && src.Type() != dst.Type() { |
||||
err = fmt.Errorf("cannot append two different types (%s, %s)", src.Kind(), dst.Kind()) |
||||
return |
||||
} |
||||
|
||||
switch dst.Kind() { |
||||
case reflect.Struct: |
||||
if hasExportedField(dst) { |
||||
dstCp := reflect.New(dst.Type()).Elem() |
||||
for i, n := 0, dst.NumField(); i < n; i++ { |
||||
dstField := dst.Field(i) |
||||
structField := dst.Type().Field(i) |
||||
// copy un-exported struct fields
|
||||
if !isExportedComponent(&structField) { |
||||
rf := dstCp.Field(i) |
||||
rf = reflect.NewAt(rf.Type(), unsafe.Pointer(rf.UnsafeAddr())).Elem() //nolint:gosec
|
||||
dstRF := dst.Field(i) |
||||
if !dst.Field(i).CanAddr() { |
||||
continue |
||||
} |
||||
|
||||
dstRF = reflect.NewAt(dstRF.Type(), unsafe.Pointer(dstRF.UnsafeAddr())).Elem() //nolint:gosec
|
||||
rf.Set(dstRF) |
||||
continue |
||||
} |
||||
dstField, err = deepMerge(dstField, src.Field(i), visited, depth+1, config) |
||||
if err != nil { |
||||
return |
||||
} |
||||
dstCp.Field(i).Set(dstField) |
||||
} |
||||
|
||||
if dst.CanSet() { |
||||
dst.Set(dstCp) |
||||
} else { |
||||
dst = dstCp |
||||
} |
||||
return |
||||
} else { |
||||
if (isReflectNil(dst) || overwrite) && (!isEmptyValue(src) || overwriteWithEmptySrc) { |
||||
dst = src |
||||
} |
||||
} |
||||
|
||||
case reflect.Map: |
||||
if dst.IsNil() && !src.IsNil() { |
||||
if dst.CanSet() { |
||||
dst.Set(reflect.MakeMap(dst.Type())) |
||||
} else { |
||||
dst = src |
||||
return |
||||
} |
||||
} |
||||
for _, key := range src.MapKeys() { |
||||
srcElement := src.MapIndex(key) |
||||
dstElement := dst.MapIndex(key) |
||||
if !srcElement.IsValid() { |
||||
continue |
||||
} |
||||
if dst.MapIndex(key).IsValid() { |
||||
k := dstElement.Interface() |
||||
dstElement = reflect.ValueOf(k) |
||||
} |
||||
if isReflectNil(srcElement) { |
||||
if overwrite || isReflectNil(dstElement) { |
||||
dst.SetMapIndex(key, srcElement) |
||||
} |
||||
continue |
||||
} |
||||
if !srcElement.CanInterface() { |
||||
continue |
||||
} |
||||
|
||||
if srcElement.CanInterface() { |
||||
srcElement = reflect.ValueOf(srcElement.Interface()) |
||||
if dstElement.IsValid() { |
||||
dstElement = reflect.ValueOf(dstElement.Interface()) |
||||
} |
||||
} |
||||
dstElement, err = deepMerge(dstElement, srcElement, visited, depth+1, config) |
||||
if err != nil { |
||||
return |
||||
} |
||||
dst.SetMapIndex(key, dstElement) |
||||
|
||||
} |
||||
case reflect.Slice: |
||||
newSlice := dst |
||||
if (!isEmptyValue(src) || overwriteWithEmptySrc || overwriteSliceWithEmptySrc) && (overwrite || isEmptyValue(dst)) && !config.AppendSlice { |
||||
if typeCheck && src.Type() != dst.Type() { |
||||
return dst, fmt.Errorf("cannot override two slices with different type (%s, %s)", src.Type(), dst.Type()) |
||||
} |
||||
newSlice = src |
||||
} else if config.AppendSlice { |
||||
if typeCheck && src.Type() != dst.Type() { |
||||
err = fmt.Errorf("cannot append two slice with different type (%s, %s)", src.Type(), dst.Type()) |
||||
return |
||||
} |
||||
newSlice = reflect.AppendSlice(dst, src) |
||||
} |
||||
if dst.CanSet() { |
||||
dst.Set(newSlice) |
||||
} else { |
||||
dst = newSlice |
||||
} |
||||
case reflect.Ptr, reflect.Interface: |
||||
if isReflectNil(src) { |
||||
break |
||||
} |
||||
|
||||
if dst.Kind() != reflect.Ptr && src.Type().AssignableTo(dst.Type()) { |
||||
if dst.IsNil() || overwrite { |
||||
if overwrite || isEmptyValue(dst) { |
||||
if dst.CanSet() { |
||||
dst.Set(src) |
||||
} else { |
||||
dst = src |
||||
} |
||||
} |
||||
} |
||||
break |
||||
} |
||||
|
||||
if src.Kind() != reflect.Interface { |
||||
if dst.IsNil() || (src.Kind() != reflect.Ptr && overwrite) { |
||||
if dst.CanSet() && (overwrite || isEmptyValue(dst)) { |
||||
dst.Set(src) |
||||
} |
||||
} else if src.Kind() == reflect.Ptr { |
||||
if dst, err = deepMerge(dst.Elem(), src.Elem(), visited, depth+1, config); err != nil { |
||||
return |
||||
} |
||||
dst = dst.Addr() |
||||
} else if dst.Elem().Type() == src.Type() { |
||||
if dst, err = deepMerge(dst.Elem(), src, visited, depth+1, config); err != nil { |
||||
return |
||||
} |
||||
} else { |
||||
return dst, ErrDifferentArgumentsTypes |
||||
} |
||||
break |
||||
} |
||||
if dst.IsNil() || overwrite { |
||||
if (overwrite || isEmptyValue(dst)) && (overwriteWithEmptySrc || !isEmptyValue(src)) { |
||||
if dst.CanSet() { |
||||
dst.Set(src) |
||||
} else { |
||||
dst = src |
||||
} |
||||
} |
||||
} else if _, err = deepMerge(dst.Elem(), src.Elem(), visited, depth+1, config); err != nil { |
||||
return |
||||
} |
||||
default: |
||||
overwriteFull := (!isEmptyValue(src) || overwriteWithEmptySrc) && (overwrite || isEmptyValue(dst)) |
||||
if overwriteFull { |
||||
if dst.CanSet() { |
||||
dst.Set(src) |
||||
} else { |
||||
dst = src |
||||
} |
||||
} |
||||
} |
||||
|
||||
return |
||||
} |
||||
|
||||
// Merge will fill any empty for value type attributes on the dst struct using corresponding
|
||||
// src attributes if they themselves are not empty. dst and src must be valid same-type structs
|
||||
// and dst must be a pointer to struct.
|
||||
// It won't merge unexported (private) fields and will do recursively any exported field.
|
||||
func Merge(dst, src interface{}, opts ...func(*Config)) error { |
||||
return merge(dst, src, opts...) |
||||
} |
||||
|
||||
// MergeWithOverwrite will do the same as Merge except that non-empty dst attributes will be overridden by
|
||||
// non-empty src attribute values.
|
||||
// Deprecated: use Merge(…) with WithOverride
|
||||
func MergeWithOverwrite(dst, src interface{}, opts ...func(*Config)) error { |
||||
return merge(dst, src, append(opts, WithOverride)...) |
||||
} |
||||
|
||||
// WithTransformers adds transformers to merge, allowing to customize the merging of some types.
|
||||
func WithTransformers(transformers Transformers) func(*Config) { |
||||
return func(config *Config) { |
||||
config.Transformers = transformers |
||||
} |
||||
} |
||||
|
||||
// WithOverride will make merge override non-empty dst attributes with non-empty src attributes values.
|
||||
func WithOverride(config *Config) { |
||||
config.Overwrite = true |
||||
} |
||||
|
||||
// WithOverwriteWithEmptyValue will make merge override non empty dst attributes with empty src attributes values.
|
||||
func WithOverwriteWithEmptyValue(config *Config) { |
||||
config.overwriteWithEmptyValue = true |
||||
} |
||||
|
||||
// WithOverrideEmptySlice will make merge override empty dst slice with empty src slice.
|
||||
func WithOverrideEmptySlice(config *Config) { |
||||
config.overwriteSliceWithEmptyValue = true |
||||
} |
||||
|
||||
// WithAppendSlice will make merge append slices instead of overwriting it.
|
||||
func WithAppendSlice(config *Config) { |
||||
config.AppendSlice = true |
||||
} |
||||
|
||||
// WithTypeCheck will make merge check types while overwriting it (must be used with WithOverride).
|
||||
func WithTypeCheck(config *Config) { |
||||
config.TypeCheck = true |
||||
} |
||||
|
||||
func merge(dst, src interface{}, opts ...func(*Config)) error { |
||||
var ( |
||||
vDst, vSrc reflect.Value |
||||
err error |
||||
) |
||||
|
||||
config := &Config{} |
||||
|
||||
for _, opt := range opts { |
||||
opt(config) |
||||
} |
||||
|
||||
if vDst, vSrc, err = resolveValues(dst, src); err != nil { |
||||
return err |
||||
} |
||||
if !vDst.CanSet() { |
||||
return fmt.Errorf("cannot set dst, needs reference") |
||||
} |
||||
if vDst.Type() != vSrc.Type() { |
||||
return ErrDifferentArgumentsTypes |
||||
} |
||||
_, err = deepMerge(vDst, vSrc, make(map[uintptr]*visit), 0, config) |
||||
return err |
||||
} |
||||
|
||||
// IsReflectNil is the reflect value provided nil
|
||||
func isReflectNil(v reflect.Value) bool { |
||||
k := v.Kind() |
||||
switch k { |
||||
case reflect.Interface, reflect.Slice, reflect.Chan, reflect.Func, reflect.Map, reflect.Ptr: |
||||
// Both interface and slice are nil if first word is 0.
|
||||
// Both are always bigger than a word; assume flagIndir.
|
||||
return v.IsNil() |
||||
default: |
||||
return false |
||||
} |
||||
} |
||||
@ -0,0 +1,97 @@ |
||||
// Copyright 2013 Dario Castañé. All rights reserved.
|
||||
// Copyright 2009 The Go Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
// Based on src/pkg/reflect/deepequal.go from official
|
||||
// golang's stdlib.
|
||||
|
||||
package mergo |
||||
|
||||
import ( |
||||
"errors" |
||||
"reflect" |
||||
) |
||||
|
||||
// Errors reported by Mergo when it finds invalid arguments.
|
||||
var ( |
||||
ErrNilArguments = errors.New("src and dst must not be nil") |
||||
ErrDifferentArgumentsTypes = errors.New("src and dst must be of same type") |
||||
ErrNotSupported = errors.New("only structs and maps are supported") |
||||
ErrExpectedMapAsDestination = errors.New("dst was expected to be a map") |
||||
ErrExpectedStructAsDestination = errors.New("dst was expected to be a struct") |
||||
) |
||||
|
||||
// During deepMerge, must keep track of checks that are
|
||||
// in progress. The comparison algorithm assumes that all
|
||||
// checks in progress are true when it reencounters them.
|
||||
// Visited are stored in a map indexed by 17 * a1 + a2;
|
||||
type visit struct { |
||||
ptr uintptr |
||||
typ reflect.Type |
||||
next *visit |
||||
} |
||||
|
||||
// From src/pkg/encoding/json/encode.go.
|
||||
func isEmptyValue(v reflect.Value) bool { |
||||
switch v.Kind() { |
||||
case reflect.Array, reflect.Map, reflect.Slice, reflect.String: |
||||
return v.Len() == 0 |
||||
case reflect.Bool: |
||||
return !v.Bool() |
||||
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: |
||||
return v.Int() == 0 |
||||
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr: |
||||
return v.Uint() == 0 |
||||
case reflect.Float32, reflect.Float64: |
||||
return v.Float() == 0 |
||||
case reflect.Interface, reflect.Ptr: |
||||
if v.IsNil() { |
||||
return true |
||||
} |
||||
return isEmptyValue(v.Elem()) |
||||
case reflect.Func: |
||||
return v.IsNil() |
||||
case reflect.Invalid: |
||||
return true |
||||
} |
||||
return false |
||||
} |
||||
|
||||
func resolveValues(dst, src interface{}) (vDst, vSrc reflect.Value, err error) { |
||||
if dst == nil || src == nil { |
||||
err = ErrNilArguments |
||||
return |
||||
} |
||||
vDst = reflect.ValueOf(dst).Elem() |
||||
if vDst.Kind() != reflect.Struct && vDst.Kind() != reflect.Map { |
||||
err = ErrNotSupported |
||||
return |
||||
} |
||||
vSrc = reflect.ValueOf(src) |
||||
// We check if vSrc is a pointer to dereference it.
|
||||
if vSrc.Kind() == reflect.Ptr { |
||||
vSrc = vSrc.Elem() |
||||
} |
||||
return |
||||
} |
||||
|
||||
// Traverses recursively both values, assigning src's fields values to dst.
|
||||
// The map argument tracks comparisons that have already been seen, which allows
|
||||
// short circuiting on recursive types.
|
||||
func deeper(dst, src reflect.Value, visited map[uintptr]*visit, depth int) (err error) { |
||||
if dst.CanAddr() { |
||||
addr := dst.UnsafeAddr() |
||||
h := 17 * addr |
||||
seen := visited[h] |
||||
typ := dst.Type() |
||||
for p := seen; p != nil; p = p.next { |
||||
if p.ptr == addr && p.typ == typ { |
||||
return nil |
||||
} |
||||
} |
||||
// Remember, remember...
|
||||
visited[h] = &visit{addr, typ, seen} |
||||
} |
||||
return // TODO refactor
|
||||
} |
||||
@ -0,0 +1,3 @@ |
||||
ignore: |
||||
- "output_tests/.*" |
||||
|
||||
@ -0,0 +1,4 @@ |
||||
/vendor |
||||
/bug_test.go |
||||
/coverage.txt |
||||
/.idea |
||||
@ -0,0 +1,14 @@ |
||||
language: go |
||||
|
||||
go: |
||||
- 1.8.x |
||||
- 1.x |
||||
|
||||
before_install: |
||||
- go get -t -v ./... |
||||
|
||||
script: |
||||
- ./test.sh |
||||
|
||||
after_success: |
||||
- bash <(curl -s https://codecov.io/bash) |
||||
@ -0,0 +1,21 @@ |
||||
# This file is autogenerated, do not edit; changes may be undone by the next 'dep ensure'. |
||||
|
||||
|
||||
[[projects]] |
||||
name = "github.com/modern-go/concurrent" |
||||
packages = ["."] |
||||
revision = "e0a39a4cb4216ea8db28e22a69f4ec25610d513a" |
||||
version = "1.0.0" |
||||
|
||||
[[projects]] |
||||
name = "github.com/modern-go/reflect2" |
||||
packages = ["."] |
||||
revision = "4b7aa43c6742a2c18fdef89dd197aaae7dac7ccd" |
||||
version = "1.0.1" |
||||
|
||||
[solve-meta] |
||||
analyzer-name = "dep" |
||||
analyzer-version = 1 |
||||
inputs-digest = "ea54a775e5a354cb015502d2e7aa4b74230fc77e894f34a838b268c25ec8eeb8" |
||||
solver-name = "gps-cdcl" |
||||
solver-version = 1 |
||||
@ -0,0 +1,26 @@ |
||||
# Gopkg.toml example |
||||
# |
||||
# Refer to https://github.com/golang/dep/blob/master/docs/Gopkg.toml.md |
||||
# for detailed Gopkg.toml documentation. |
||||
# |
||||
# required = ["github.com/user/thing/cmd/thing"] |
||||
# ignored = ["github.com/user/project/pkgX", "bitbucket.org/user/project/pkgA/pkgY"] |
||||
# |
||||
# [[constraint]] |
||||
# name = "github.com/user/project" |
||||
# version = "1.0.0" |
||||
# |
||||
# [[constraint]] |
||||
# name = "github.com/user/project2" |
||||
# branch = "dev" |
||||
# source = "github.com/myfork/project2" |
||||
# |
||||
# [[override]] |
||||
# name = "github.com/x/y" |
||||
# version = "2.4.0" |
||||
|
||||
ignored = ["github.com/davecgh/go-spew*","github.com/google/gofuzz*","github.com/stretchr/testify*"] |
||||
|
||||
[[constraint]] |
||||
name = "github.com/modern-go/reflect2" |
||||
version = "1.0.1" |
||||
@ -0,0 +1,21 @@ |
||||
MIT License |
||||
|
||||
Copyright (c) 2016 json-iterator |
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy |
||||
of this software and associated documentation files (the "Software"), to deal |
||||
in the Software without restriction, including without limitation the rights |
||||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell |
||||
copies of the Software, and to permit persons to whom the Software is |
||||
furnished to do so, subject to the following conditions: |
||||
|
||||
The above copyright notice and this permission notice shall be included in all |
||||
copies or substantial portions of the Software. |
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE |
||||
SOFTWARE. |
||||
@ -0,0 +1,87 @@ |
||||
[](https://sourcegraph.com/github.com/json-iterator/go?badge) |
||||
[](http://godoc.org/github.com/json-iterator/go) |
||||
[](https://travis-ci.org/json-iterator/go) |
||||
[](https://codecov.io/gh/json-iterator/go) |
||||
[](https://goreportcard.com/report/github.com/json-iterator/go) |
||||
[](https://raw.githubusercontent.com/json-iterator/go/master/LICENSE) |
||||
[](https://gitter.im/json-iterator/Lobby) |
||||
|
||||
A high-performance 100% compatible drop-in replacement of "encoding/json" |
||||
|
||||
You can also use thrift like JSON using [thrift-iterator](https://github.com/thrift-iterator/go) |
||||
|
||||
# Benchmark |
||||
|
||||
 |
||||
|
||||
Source code: https://github.com/json-iterator/go-benchmark/blob/master/src/github.com/json-iterator/go-benchmark/benchmark_medium_payload_test.go |
||||
|
||||
Raw Result (easyjson requires static code generation) |
||||
|
||||
| | ns/op | allocation bytes | allocation times | |
||||
| --- | --- | --- | --- | |
||||
| std decode | 35510 ns/op | 1960 B/op | 99 allocs/op | |
||||
| easyjson decode | 8499 ns/op | 160 B/op | 4 allocs/op | |
||||
| jsoniter decode | 5623 ns/op | 160 B/op | 3 allocs/op | |
||||
| std encode | 2213 ns/op | 712 B/op | 5 allocs/op | |
||||
| easyjson encode | 883 ns/op | 576 B/op | 3 allocs/op | |
||||
| jsoniter encode | 837 ns/op | 384 B/op | 4 allocs/op | |
||||
|
||||
Always benchmark with your own workload. |
||||
The result depends heavily on the data input. |
||||
|
||||
# Usage |
||||
|
||||
100% compatibility with standard lib |
||||
|
||||
Replace |
||||
|
||||
```go |
||||
import "encoding/json" |
||||
json.Marshal(&data) |
||||
``` |
||||
|
||||
with |
||||
|
||||
```go |
||||
import "github.com/json-iterator/go" |
||||
|
||||
var json = jsoniter.ConfigCompatibleWithStandardLibrary |
||||
json.Marshal(&data) |
||||
``` |
||||
|
||||
Replace |
||||
|
||||
```go |
||||
import "encoding/json" |
||||
json.Unmarshal(input, &data) |
||||
``` |
||||
|
||||
with |
||||
|
||||
```go |
||||
import "github.com/json-iterator/go" |
||||
|
||||
var json = jsoniter.ConfigCompatibleWithStandardLibrary |
||||
json.Unmarshal(input, &data) |
||||
``` |
||||
|
||||
[More documentation](http://jsoniter.com/migrate-from-go-std.html) |
||||
|
||||
# How to get |
||||
|
||||
``` |
||||
go get github.com/json-iterator/go |
||||
``` |
||||
|
||||
# Contribution Welcomed ! |
||||
|
||||
Contributors |
||||
|
||||
* [thockin](https://github.com/thockin) |
||||
* [mattn](https://github.com/mattn) |
||||
* [cch123](https://github.com/cch123) |
||||
* [Oleg Shaldybin](https://github.com/olegshaldybin) |
||||
* [Jason Toffaletti](https://github.com/toffaletti) |
||||
|
||||
Report issue or pull request, or email taowen@gmail.com, or [](https://gitter.im/json-iterator/Lobby) |
||||
@ -0,0 +1,150 @@ |
||||
package jsoniter |
||||
|
||||
import ( |
||||
"bytes" |
||||
"io" |
||||
) |
||||
|
||||
// RawMessage to make replace json with jsoniter
|
||||
type RawMessage []byte |
||||
|
||||
// Unmarshal adapts to json/encoding Unmarshal API
|
||||
//
|
||||
// Unmarshal parses the JSON-encoded data and stores the result in the value pointed to by v.
|
||||
// Refer to https://godoc.org/encoding/json#Unmarshal for more information
|
||||
func Unmarshal(data []byte, v interface{}) error { |
||||
return ConfigDefault.Unmarshal(data, v) |
||||
} |
||||
|
||||
// UnmarshalFromString is a convenient method to read from string instead of []byte
|
||||
func UnmarshalFromString(str string, v interface{}) error { |
||||
return ConfigDefault.UnmarshalFromString(str, v) |
||||
} |
||||
|
||||
// Get quick method to get value from deeply nested JSON structure
|
||||
func Get(data []byte, path ...interface{}) Any { |
||||
return ConfigDefault.Get(data, path...) |
||||
} |
||||
|
||||
// Marshal adapts to json/encoding Marshal API
|
||||
//
|
||||
// Marshal returns the JSON encoding of v, adapts to json/encoding Marshal API
|
||||
// Refer to https://godoc.org/encoding/json#Marshal for more information
|
||||
func Marshal(v interface{}) ([]byte, error) { |
||||
return ConfigDefault.Marshal(v) |
||||
} |
||||
|
||||
// MarshalIndent same as json.MarshalIndent. Prefix is not supported.
|
||||
func MarshalIndent(v interface{}, prefix, indent string) ([]byte, error) { |
||||
return ConfigDefault.MarshalIndent(v, prefix, indent) |
||||
} |
||||
|
||||
// MarshalToString convenient method to write as string instead of []byte
|
||||
func MarshalToString(v interface{}) (string, error) { |
||||
return ConfigDefault.MarshalToString(v) |
||||
} |
||||
|
||||
// NewDecoder adapts to json/stream NewDecoder API.
|
||||
//
|
||||
// NewDecoder returns a new decoder that reads from r.
|
||||
//
|
||||
// Instead of a json/encoding Decoder, an Decoder is returned
|
||||
// Refer to https://godoc.org/encoding/json#NewDecoder for more information
|
||||
func NewDecoder(reader io.Reader) *Decoder { |
||||
return ConfigDefault.NewDecoder(reader) |
||||
} |
||||
|
||||
// Decoder reads and decodes JSON values from an input stream.
|
||||
// Decoder provides identical APIs with json/stream Decoder (Token() and UseNumber() are in progress)
|
||||
type Decoder struct { |
||||
iter *Iterator |
||||
} |
||||
|
||||
// Decode decode JSON into interface{}
|
||||
func (adapter *Decoder) Decode(obj interface{}) error { |
||||
if adapter.iter.head == adapter.iter.tail && adapter.iter.reader != nil { |
||||
if !adapter.iter.loadMore() { |
||||
return io.EOF |
||||
} |
||||
} |
||||
adapter.iter.ReadVal(obj) |
||||
err := adapter.iter.Error |
||||
if err == io.EOF { |
||||
return nil |
||||
} |
||||
return adapter.iter.Error |
||||
} |
||||
|
||||
// More is there more?
|
||||
func (adapter *Decoder) More() bool { |
||||
iter := adapter.iter |
||||
if iter.Error != nil { |
||||
return false |
||||
} |
||||
c := iter.nextToken() |
||||
if c == 0 { |
||||
return false |
||||
} |
||||
iter.unreadByte() |
||||
return c != ']' && c != '}' |
||||
} |
||||
|
||||
// Buffered remaining buffer
|
||||
func (adapter *Decoder) Buffered() io.Reader { |
||||
remaining := adapter.iter.buf[adapter.iter.head:adapter.iter.tail] |
||||
return bytes.NewReader(remaining) |
||||
} |
||||
|
||||
// UseNumber causes the Decoder to unmarshal a number into an interface{} as a
|
||||
// Number instead of as a float64.
|
||||
func (adapter *Decoder) UseNumber() { |
||||
cfg := adapter.iter.cfg.configBeforeFrozen |
||||
cfg.UseNumber = true |
||||
adapter.iter.cfg = cfg.frozeWithCacheReuse(adapter.iter.cfg.extraExtensions) |
||||
} |
||||
|
||||
// DisallowUnknownFields causes the Decoder to return an error when the destination
|
||||
// is a struct and the input contains object keys which do not match any
|
||||
// non-ignored, exported fields in the destination.
|
||||
func (adapter *Decoder) DisallowUnknownFields() { |
||||
cfg := adapter.iter.cfg.configBeforeFrozen |
||||
cfg.DisallowUnknownFields = true |
||||
adapter.iter.cfg = cfg.frozeWithCacheReuse(adapter.iter.cfg.extraExtensions) |
||||
} |
||||
|
||||
// NewEncoder same as json.NewEncoder
|
||||
func NewEncoder(writer io.Writer) *Encoder { |
||||
return ConfigDefault.NewEncoder(writer) |
||||
} |
||||
|
||||
// Encoder same as json.Encoder
|
||||
type Encoder struct { |
||||
stream *Stream |
||||
} |
||||
|
||||
// Encode encode interface{} as JSON to io.Writer
|
||||
func (adapter *Encoder) Encode(val interface{}) error { |
||||
adapter.stream.WriteVal(val) |
||||
adapter.stream.WriteRaw("\n") |
||||
adapter.stream.Flush() |
||||
return adapter.stream.Error |
||||
} |
||||
|
||||
// SetIndent set the indention. Prefix is not supported
|
||||
func (adapter *Encoder) SetIndent(prefix, indent string) { |
||||
config := adapter.stream.cfg.configBeforeFrozen |
||||
config.IndentionStep = len(indent) |
||||
adapter.stream.cfg = config.frozeWithCacheReuse(adapter.stream.cfg.extraExtensions) |
||||
} |
||||
|
||||
// SetEscapeHTML escape html by default, set to false to disable
|
||||
func (adapter *Encoder) SetEscapeHTML(escapeHTML bool) { |
||||
config := adapter.stream.cfg.configBeforeFrozen |
||||
config.EscapeHTML = escapeHTML |
||||
adapter.stream.cfg = config.frozeWithCacheReuse(adapter.stream.cfg.extraExtensions) |
||||
} |
||||
|
||||
// Valid reports whether data is a valid JSON encoding.
|
||||
func Valid(data []byte) bool { |
||||
return ConfigDefault.Valid(data) |
||||
} |
||||
@ -0,0 +1,325 @@ |
||||
package jsoniter |
||||
|
||||
import ( |
||||
"errors" |
||||
"fmt" |
||||
"github.com/modern-go/reflect2" |
||||
"io" |
||||
"reflect" |
||||
"strconv" |
||||
"unsafe" |
||||
) |
||||
|
||||
// Any generic object representation.
|
||||
// The lazy json implementation holds []byte and parse lazily.
|
||||
type Any interface { |
||||
LastError() error |
||||
ValueType() ValueType |
||||
MustBeValid() Any |
||||
ToBool() bool |
||||
ToInt() int |
||||
ToInt32() int32 |
||||
ToInt64() int64 |
||||
ToUint() uint |
||||
ToUint32() uint32 |
||||
ToUint64() uint64 |
||||
ToFloat32() float32 |
||||
ToFloat64() float64 |
||||
ToString() string |
||||
ToVal(val interface{}) |
||||
Get(path ...interface{}) Any |
||||
Size() int |
||||
Keys() []string |
||||
GetInterface() interface{} |
||||
WriteTo(stream *Stream) |
||||
} |
||||
|
||||
type baseAny struct{} |
||||
|
||||
func (any *baseAny) Get(path ...interface{}) Any { |
||||
return &invalidAny{baseAny{}, fmt.Errorf("GetIndex %v from simple value", path)} |
||||
} |
||||
|
||||
func (any *baseAny) Size() int { |
||||
return 0 |
||||
} |
||||
|
||||
func (any *baseAny) Keys() []string { |
||||
return []string{} |
||||
} |
||||
|
||||
func (any *baseAny) ToVal(obj interface{}) { |
||||
panic("not implemented") |
||||
} |
||||
|
||||
// WrapInt32 turn int32 into Any interface
|
||||
func WrapInt32(val int32) Any { |
||||
return &int32Any{baseAny{}, val} |
||||
} |
||||
|
||||
// WrapInt64 turn int64 into Any interface
|
||||
func WrapInt64(val int64) Any { |
||||
return &int64Any{baseAny{}, val} |
||||
} |
||||
|
||||
// WrapUint32 turn uint32 into Any interface
|
||||
func WrapUint32(val uint32) Any { |
||||
return &uint32Any{baseAny{}, val} |
||||
} |
||||
|
||||
// WrapUint64 turn uint64 into Any interface
|
||||
func WrapUint64(val uint64) Any { |
||||
return &uint64Any{baseAny{}, val} |
||||
} |
||||
|
||||
// WrapFloat64 turn float64 into Any interface
|
||||
func WrapFloat64(val float64) Any { |
||||
return &floatAny{baseAny{}, val} |
||||
} |
||||
|
||||
// WrapString turn string into Any interface
|
||||
func WrapString(val string) Any { |
||||
return &stringAny{baseAny{}, val} |
||||
} |
||||
|
||||
// Wrap turn a go object into Any interface
|
||||
func Wrap(val interface{}) Any { |
||||
if val == nil { |
||||
return &nilAny{} |
||||
} |
||||
asAny, isAny := val.(Any) |
||||
if isAny { |
||||
return asAny |
||||
} |
||||
typ := reflect2.TypeOf(val) |
||||
switch typ.Kind() { |
||||
case reflect.Slice: |
||||
return wrapArray(val) |
||||
case reflect.Struct: |
||||
return wrapStruct(val) |
||||
case reflect.Map: |
||||
return wrapMap(val) |
||||
case reflect.String: |
||||
return WrapString(val.(string)) |
||||
case reflect.Int: |
||||
if strconv.IntSize == 32 { |
||||
return WrapInt32(int32(val.(int))) |
||||
} |
||||
return WrapInt64(int64(val.(int))) |
||||
case reflect.Int8: |
||||
return WrapInt32(int32(val.(int8))) |
||||
case reflect.Int16: |
||||
return WrapInt32(int32(val.(int16))) |
||||
case reflect.Int32: |
||||
return WrapInt32(val.(int32)) |
||||
case reflect.Int64: |
||||
return WrapInt64(val.(int64)) |
||||
case reflect.Uint: |
||||
if strconv.IntSize == 32 { |
||||
return WrapUint32(uint32(val.(uint))) |
||||
} |
||||
return WrapUint64(uint64(val.(uint))) |
||||
case reflect.Uintptr: |
||||
if ptrSize == 32 { |
||||
return WrapUint32(uint32(val.(uintptr))) |
||||
} |
||||
return WrapUint64(uint64(val.(uintptr))) |
||||
case reflect.Uint8: |
||||
return WrapUint32(uint32(val.(uint8))) |
||||
case reflect.Uint16: |
||||
return WrapUint32(uint32(val.(uint16))) |
||||
case reflect.Uint32: |
||||
return WrapUint32(uint32(val.(uint32))) |
||||
case reflect.Uint64: |
||||
return WrapUint64(val.(uint64)) |
||||
case reflect.Float32: |
||||
return WrapFloat64(float64(val.(float32))) |
||||
case reflect.Float64: |
||||
return WrapFloat64(val.(float64)) |
||||
case reflect.Bool: |
||||
if val.(bool) == true { |
||||
return &trueAny{} |
||||
} |
||||
return &falseAny{} |
||||
} |
||||
return &invalidAny{baseAny{}, fmt.Errorf("unsupported type: %v", typ)} |
||||
} |
||||
|
||||
// ReadAny read next JSON element as an Any object. It is a better json.RawMessage.
|
||||
func (iter *Iterator) ReadAny() Any { |
||||
return iter.readAny() |
||||
} |
||||
|
||||
func (iter *Iterator) readAny() Any { |
||||
c := iter.nextToken() |
||||
switch c { |
||||
case '"': |
||||
iter.unreadByte() |
||||
return &stringAny{baseAny{}, iter.ReadString()} |
||||
case 'n': |
||||
iter.skipThreeBytes('u', 'l', 'l') // null
|
||||
return &nilAny{} |
||||
case 't': |
||||
iter.skipThreeBytes('r', 'u', 'e') // true
|
||||
return &trueAny{} |
||||
case 'f': |
||||
iter.skipFourBytes('a', 'l', 's', 'e') // false
|
||||
return &falseAny{} |
||||
case '{': |
||||
return iter.readObjectAny() |
||||
case '[': |
||||
return iter.readArrayAny() |
||||
case '-': |
||||
return iter.readNumberAny(false) |
||||
case 0: |
||||
return &invalidAny{baseAny{}, errors.New("input is empty")} |
||||
default: |
||||
return iter.readNumberAny(true) |
||||
} |
||||
} |
||||
|
||||
func (iter *Iterator) readNumberAny(positive bool) Any { |
||||
iter.startCapture(iter.head - 1) |
||||
iter.skipNumber() |
||||
lazyBuf := iter.stopCapture() |
||||
return &numberLazyAny{baseAny{}, iter.cfg, lazyBuf, nil} |
||||
} |
||||
|
||||
func (iter *Iterator) readObjectAny() Any { |
||||
iter.startCapture(iter.head - 1) |
||||
iter.skipObject() |
||||
lazyBuf := iter.stopCapture() |
||||
return &objectLazyAny{baseAny{}, iter.cfg, lazyBuf, nil} |
||||
} |
||||
|
||||
func (iter *Iterator) readArrayAny() Any { |
||||
iter.startCapture(iter.head - 1) |
||||
iter.skipArray() |
||||
lazyBuf := iter.stopCapture() |
||||
return &arrayLazyAny{baseAny{}, iter.cfg, lazyBuf, nil} |
||||
} |
||||
|
||||
func locateObjectField(iter *Iterator, target string) []byte { |
||||
var found []byte |
||||
iter.ReadObjectCB(func(iter *Iterator, field string) bool { |
||||
if field == target { |
||||
found = iter.SkipAndReturnBytes() |
||||
return false |
||||
} |
||||
iter.Skip() |
||||
return true |
||||
}) |
||||
return found |
||||
} |
||||
|
||||
func locateArrayElement(iter *Iterator, target int) []byte { |
||||
var found []byte |
||||
n := 0 |
||||
iter.ReadArrayCB(func(iter *Iterator) bool { |
||||
if n == target { |
||||
found = iter.SkipAndReturnBytes() |
||||
return false |
||||
} |
||||
iter.Skip() |
||||
n++ |
||||
return true |
||||
}) |
||||
return found |
||||
} |
||||
|
||||
func locatePath(iter *Iterator, path []interface{}) Any { |
||||
for i, pathKeyObj := range path { |
||||
switch pathKey := pathKeyObj.(type) { |
||||
case string: |
||||
valueBytes := locateObjectField(iter, pathKey) |
||||
if valueBytes == nil { |
||||
return newInvalidAny(path[i:]) |
||||
} |
||||
iter.ResetBytes(valueBytes) |
||||
case int: |
||||
valueBytes := locateArrayElement(iter, pathKey) |
||||
if valueBytes == nil { |
||||
return newInvalidAny(path[i:]) |
||||
} |
||||
iter.ResetBytes(valueBytes) |
||||
case int32: |
||||
if '*' == pathKey { |
||||
return iter.readAny().Get(path[i:]...) |
||||
} |
||||
return newInvalidAny(path[i:]) |
||||
default: |
||||
return newInvalidAny(path[i:]) |
||||
} |
||||
} |
||||
if iter.Error != nil && iter.Error != io.EOF { |
||||
return &invalidAny{baseAny{}, iter.Error} |
||||
} |
||||
return iter.readAny() |
||||
} |
||||
|
||||
var anyType = reflect2.TypeOfPtr((*Any)(nil)).Elem() |
||||
|
||||
func createDecoderOfAny(ctx *ctx, typ reflect2.Type) ValDecoder { |
||||
if typ == anyType { |
||||
return &directAnyCodec{} |
||||
} |
||||
if typ.Implements(anyType) { |
||||
return &anyCodec{ |
||||
valType: typ, |
||||
} |
||||
} |
||||
return nil |
||||
} |
||||
|
||||
func createEncoderOfAny(ctx *ctx, typ reflect2.Type) ValEncoder { |
||||
if typ == anyType { |
||||
return &directAnyCodec{} |
||||
} |
||||
if typ.Implements(anyType) { |
||||
return &anyCodec{ |
||||
valType: typ, |
||||
} |
||||
} |
||||
return nil |
||||
} |
||||
|
||||
type anyCodec struct { |
||||
valType reflect2.Type |
||||
} |
||||
|
||||
func (codec *anyCodec) Decode(ptr unsafe.Pointer, iter *Iterator) { |
||||
panic("not implemented") |
||||
} |
||||
|
||||
func (codec *anyCodec) Encode(ptr unsafe.Pointer, stream *Stream) { |
||||
obj := codec.valType.UnsafeIndirect(ptr) |
||||
any := obj.(Any) |
||||
any.WriteTo(stream) |
||||
} |
||||
|
||||
func (codec *anyCodec) IsEmpty(ptr unsafe.Pointer) bool { |
||||
obj := codec.valType.UnsafeIndirect(ptr) |
||||
any := obj.(Any) |
||||
return any.Size() == 0 |
||||
} |
||||
|
||||
type directAnyCodec struct { |
||||
} |
||||
|
||||
func (codec *directAnyCodec) Decode(ptr unsafe.Pointer, iter *Iterator) { |
||||
*(*Any)(ptr) = iter.readAny() |
||||
} |
||||
|
||||
func (codec *directAnyCodec) Encode(ptr unsafe.Pointer, stream *Stream) { |
||||
any := *(*Any)(ptr) |
||||
if any == nil { |
||||
stream.WriteNil() |
||||
return |
||||
} |
||||
any.WriteTo(stream) |
||||
} |
||||
|
||||
func (codec *directAnyCodec) IsEmpty(ptr unsafe.Pointer) bool { |
||||
any := *(*Any)(ptr) |
||||
return any.Size() == 0 |
||||
} |
||||
@ -0,0 +1,278 @@ |
||||
package jsoniter |
||||
|
||||
import ( |
||||
"reflect" |
||||
"unsafe" |
||||
) |
||||
|
||||
type arrayLazyAny struct { |
||||
baseAny |
||||
cfg *frozenConfig |
||||
buf []byte |
||||
err error |
||||
} |
||||
|
||||
func (any *arrayLazyAny) ValueType() ValueType { |
||||
return ArrayValue |
||||
} |
||||
|
||||
func (any *arrayLazyAny) MustBeValid() Any { |
||||
return any |
||||
} |
||||
|
||||
func (any *arrayLazyAny) LastError() error { |
||||
return any.err |
||||
} |
||||
|
||||
func (any *arrayLazyAny) ToBool() bool { |
||||
iter := any.cfg.BorrowIterator(any.buf) |
||||
defer any.cfg.ReturnIterator(iter) |
||||
return iter.ReadArray() |
||||
} |
||||
|
||||
func (any *arrayLazyAny) ToInt() int { |
||||
if any.ToBool() { |
||||
return 1 |
||||
} |
||||
return 0 |
||||
} |
||||
|
||||
func (any *arrayLazyAny) ToInt32() int32 { |
||||
if any.ToBool() { |
||||
return 1 |
||||
} |
||||
return 0 |
||||
} |
||||
|
||||
func (any *arrayLazyAny) ToInt64() int64 { |
||||
if any.ToBool() { |
||||
return 1 |
||||
} |
||||
return 0 |
||||
} |
||||
|
||||
func (any *arrayLazyAny) ToUint() uint { |
||||
if any.ToBool() { |
||||
return 1 |
||||
} |
||||
return 0 |
||||
} |
||||
|
||||
func (any *arrayLazyAny) ToUint32() uint32 { |
||||
if any.ToBool() { |
||||
return 1 |
||||
} |
||||
return 0 |
||||
} |
||||
|
||||
func (any *arrayLazyAny) ToUint64() uint64 { |
||||
if any.ToBool() { |
||||
return 1 |
||||
} |
||||
return 0 |
||||
} |
||||
|
||||
func (any *arrayLazyAny) ToFloat32() float32 { |
||||
if any.ToBool() { |
||||
return 1 |
||||
} |
||||
return 0 |
||||
} |
||||
|
||||
func (any *arrayLazyAny) ToFloat64() float64 { |
||||
if any.ToBool() { |
||||
return 1 |
||||
} |
||||
return 0 |
||||
} |
||||
|
||||
func (any *arrayLazyAny) ToString() string { |
||||
return *(*string)(unsafe.Pointer(&any.buf)) |
||||
} |
||||
|
||||
func (any *arrayLazyAny) ToVal(val interface{}) { |
||||
iter := any.cfg.BorrowIterator(any.buf) |
||||
defer any.cfg.ReturnIterator(iter) |
||||
iter.ReadVal(val) |
||||
} |
||||
|
||||
func (any *arrayLazyAny) Get(path ...interface{}) Any { |
||||
if len(path) == 0 { |
||||
return any |
||||
} |
||||
switch firstPath := path[0].(type) { |
||||
case int: |
||||
iter := any.cfg.BorrowIterator(any.buf) |
||||
defer any.cfg.ReturnIterator(iter) |
||||
valueBytes := locateArrayElement(iter, firstPath) |
||||
if valueBytes == nil { |
||||
return newInvalidAny(path) |
||||
} |
||||
iter.ResetBytes(valueBytes) |
||||
return locatePath(iter, path[1:]) |
||||
case int32: |
||||
if '*' == firstPath { |
||||
iter := any.cfg.BorrowIterator(any.buf) |
||||
defer any.cfg.ReturnIterator(iter) |
||||
arr := make([]Any, 0) |
||||
iter.ReadArrayCB(func(iter *Iterator) bool { |
||||
found := iter.readAny().Get(path[1:]...) |
||||
if found.ValueType() != InvalidValue { |
||||
arr = append(arr, found) |
||||
} |
||||
return true |
||||
}) |
||||
return wrapArray(arr) |
||||
} |
||||
return newInvalidAny(path) |
||||
default: |
||||
return newInvalidAny(path) |
||||
} |
||||
} |
||||
|
||||
func (any *arrayLazyAny) Size() int { |
||||
size := 0 |
||||
iter := any.cfg.BorrowIterator(any.buf) |
||||
defer any.cfg.ReturnIterator(iter) |
||||
iter.ReadArrayCB(func(iter *Iterator) bool { |
||||
size++ |
||||
iter.Skip() |
||||
return true |
||||
}) |
||||
return size |
||||
} |
||||
|
||||
func (any *arrayLazyAny) WriteTo(stream *Stream) { |
||||
stream.Write(any.buf) |
||||
} |
||||
|
||||
func (any *arrayLazyAny) GetInterface() interface{} { |
||||
iter := any.cfg.BorrowIterator(any.buf) |
||||
defer any.cfg.ReturnIterator(iter) |
||||
return iter.Read() |
||||
} |
||||
|
||||
type arrayAny struct { |
||||
baseAny |
||||
val reflect.Value |
||||
} |
||||
|
||||
func wrapArray(val interface{}) *arrayAny { |
||||
return &arrayAny{baseAny{}, reflect.ValueOf(val)} |
||||
} |
||||
|
||||
func (any *arrayAny) ValueType() ValueType { |
||||
return ArrayValue |
||||
} |
||||
|
||||
func (any *arrayAny) MustBeValid() Any { |
||||
return any |
||||
} |
||||
|
||||
func (any *arrayAny) LastError() error { |
||||
return nil |
||||
} |
||||
|
||||
func (any *arrayAny) ToBool() bool { |
||||
return any.val.Len() != 0 |
||||
} |
||||
|
||||
func (any *arrayAny) ToInt() int { |
||||
if any.val.Len() == 0 { |
||||
return 0 |
||||
} |
||||
return 1 |
||||
} |
||||
|
||||
func (any *arrayAny) ToInt32() int32 { |
||||
if any.val.Len() == 0 { |
||||
return 0 |
||||
} |
||||
return 1 |
||||
} |
||||
|
||||
func (any *arrayAny) ToInt64() int64 { |
||||
if any.val.Len() == 0 { |
||||
return 0 |
||||
} |
||||
return 1 |
||||
} |
||||
|
||||
func (any *arrayAny) ToUint() uint { |
||||
if any.val.Len() == 0 { |
||||
return 0 |
||||
} |
||||
return 1 |
||||
} |
||||
|
||||
func (any *arrayAny) ToUint32() uint32 { |
||||
if any.val.Len() == 0 { |
||||
return 0 |
||||
} |
||||
return 1 |
||||
} |
||||
|
||||
func (any *arrayAny) ToUint64() uint64 { |
||||
if any.val.Len() == 0 { |
||||
return 0 |
||||
} |
||||
return 1 |
||||
} |
||||
|
||||
func (any *arrayAny) ToFloat32() float32 { |
||||
if any.val.Len() == 0 { |
||||
return 0 |
||||
} |
||||
return 1 |
||||
} |
||||
|
||||
func (any *arrayAny) ToFloat64() float64 { |
||||
if any.val.Len() == 0 { |
||||
return 0 |
||||
} |
||||
return 1 |
||||
} |
||||
|
||||
func (any *arrayAny) ToString() string { |
||||
str, _ := MarshalToString(any.val.Interface()) |
||||
return str |
||||
} |
||||
|
||||
func (any *arrayAny) Get(path ...interface{}) Any { |
||||
if len(path) == 0 { |
||||
return any |
||||
} |
||||
switch firstPath := path[0].(type) { |
||||
case int: |
||||
if firstPath < 0 || firstPath >= any.val.Len() { |
||||
return newInvalidAny(path) |
||||
} |
||||
return Wrap(any.val.Index(firstPath).Interface()) |
||||
case int32: |
||||
if '*' == firstPath { |
||||
mappedAll := make([]Any, 0) |
||||
for i := 0; i < any.val.Len(); i++ { |
||||
mapped := Wrap(any.val.Index(i).Interface()).Get(path[1:]...) |
||||
if mapped.ValueType() != InvalidValue { |
||||
mappedAll = append(mappedAll, mapped) |
||||
} |
||||
} |
||||
return wrapArray(mappedAll) |
||||
} |
||||
return newInvalidAny(path) |
||||
default: |
||||
return newInvalidAny(path) |
||||
} |
||||
} |
||||
|
||||
func (any *arrayAny) Size() int { |
||||
return any.val.Len() |
||||
} |
||||
|
||||
func (any *arrayAny) WriteTo(stream *Stream) { |
||||
stream.WriteVal(any.val) |
||||
} |
||||
|
||||
func (any *arrayAny) GetInterface() interface{} { |
||||
return any.val.Interface() |
||||
} |
||||
@ -0,0 +1,137 @@ |
||||
package jsoniter |
||||
|
||||
type trueAny struct { |
||||
baseAny |
||||
} |
||||
|
||||
func (any *trueAny) LastError() error { |
||||
return nil |
||||
} |
||||
|
||||
func (any *trueAny) ToBool() bool { |
||||
return true |
||||
} |
||||
|
||||
func (any *trueAny) ToInt() int { |
||||
return 1 |
||||
} |
||||
|
||||
func (any *trueAny) ToInt32() int32 { |
||||
return 1 |
||||
} |
||||
|
||||
func (any *trueAny) ToInt64() int64 { |
||||
return 1 |
||||
} |
||||
|
||||
func (any *trueAny) ToUint() uint { |
||||
return 1 |
||||
} |
||||
|
||||
func (any *trueAny) ToUint32() uint32 { |
||||
return 1 |
||||
} |
||||
|
||||
func (any *trueAny) ToUint64() uint64 { |
||||
return 1 |
||||
} |
||||
|
||||
func (any *trueAny) ToFloat32() float32 { |
||||
return 1 |
||||
} |
||||
|
||||
func (any *trueAny) ToFloat64() float64 { |
||||
return 1 |
||||
} |
||||
|
||||
func (any *trueAny) ToString() string { |
||||
return "true" |
||||
} |
||||
|
||||
func (any *trueAny) WriteTo(stream *Stream) { |
||||
stream.WriteTrue() |
||||
} |
||||
|
||||
func (any *trueAny) Parse() *Iterator { |
||||
return nil |
||||
} |
||||
|
||||
func (any *trueAny) GetInterface() interface{} { |
||||
return true |
||||
} |
||||
|
||||
func (any *trueAny) ValueType() ValueType { |
||||
return BoolValue |
||||
} |
||||
|
||||
func (any *trueAny) MustBeValid() Any { |
||||
return any |
||||
} |
||||
|
||||
type falseAny struct { |
||||
baseAny |
||||
} |
||||
|
||||
func (any *falseAny) LastError() error { |
||||
return nil |
||||
} |
||||
|
||||
func (any *falseAny) ToBool() bool { |
||||
return false |
||||
} |
||||
|
||||
func (any *falseAny) ToInt() int { |
||||
return 0 |
||||
} |
||||
|
||||
func (any *falseAny) ToInt32() int32 { |
||||
return 0 |
||||
} |
||||
|
||||
func (any *falseAny) ToInt64() int64 { |
||||
return 0 |
||||
} |
||||
|
||||
func (any *falseAny) ToUint() uint { |
||||
return 0 |
||||
} |
||||
|
||||
func (any *falseAny) ToUint32() uint32 { |
||||
return 0 |
||||
} |
||||
|
||||
func (any *falseAny) ToUint64() uint64 { |
||||
return 0 |
||||
} |
||||
|
||||
func (any *falseAny) ToFloat32() float32 { |
||||
return 0 |
||||
} |
||||
|
||||
func (any *falseAny) ToFloat64() float64 { |
||||
return 0 |
||||
} |
||||
|
||||
func (any *falseAny) ToString() string { |
||||
return "false" |
||||
} |
||||
|
||||
func (any *falseAny) WriteTo(stream *Stream) { |
||||
stream.WriteFalse() |
||||
} |
||||
|
||||
func (any *falseAny) Parse() *Iterator { |
||||
return nil |
||||
} |
||||
|
||||
func (any *falseAny) GetInterface() interface{} { |
||||
return false |
||||
} |
||||
|
||||
func (any *falseAny) ValueType() ValueType { |
||||
return BoolValue |
||||
} |
||||
|
||||
func (any *falseAny) MustBeValid() Any { |
||||
return any |
||||
} |
||||
@ -0,0 +1,83 @@ |
||||
package jsoniter |
||||
|
||||
import ( |
||||
"strconv" |
||||
) |
||||
|
||||
type floatAny struct { |
||||
baseAny |
||||
val float64 |
||||
} |
||||
|
||||
func (any *floatAny) Parse() *Iterator { |
||||
return nil |
||||
} |
||||
|
||||
func (any *floatAny) ValueType() ValueType { |
||||
return NumberValue |
||||
} |
||||
|
||||
func (any *floatAny) MustBeValid() Any { |
||||
return any |
||||
} |
||||
|
||||
func (any *floatAny) LastError() error { |
||||
return nil |
||||
} |
||||
|
||||
func (any *floatAny) ToBool() bool { |
||||
return any.ToFloat64() != 0 |
||||
} |
||||
|
||||
func (any *floatAny) ToInt() int { |
||||
return int(any.val) |
||||
} |
||||
|
||||
func (any *floatAny) ToInt32() int32 { |
||||
return int32(any.val) |
||||
} |
||||
|
||||
func (any *floatAny) ToInt64() int64 { |
||||
return int64(any.val) |
||||
} |
||||
|
||||
func (any *floatAny) ToUint() uint { |
||||
if any.val > 0 { |
||||
return uint(any.val) |
||||
} |
||||
return 0 |
||||
} |
||||
|
||||
func (any *floatAny) ToUint32() uint32 { |
||||
if any.val > 0 { |
||||
return uint32(any.val) |
||||
} |
||||
return 0 |
||||
} |
||||
|
||||
func (any *floatAny) ToUint64() uint64 { |
||||
if any.val > 0 { |
||||
return uint64(any.val) |
||||
} |
||||
return 0 |
||||
} |
||||
|
||||
func (any *floatAny) ToFloat32() float32 { |
||||
return float32(any.val) |
||||
} |
||||
|
||||
func (any *floatAny) ToFloat64() float64 { |
||||
return any.val |
||||
} |
||||
|
||||
func (any *floatAny) ToString() string { |
||||
return strconv.FormatFloat(any.val, 'E', -1, 64) |
||||
} |
||||
|
||||
func (any *floatAny) WriteTo(stream *Stream) { |
||||
stream.WriteFloat64(any.val) |
||||
} |
||||
|
||||
func (any *floatAny) GetInterface() interface{} { |
||||
return any.val |
||||
} |
||||
@ -0,0 +1,74 @@ |
||||
package jsoniter |
||||
|
||||
import ( |
||||
"strconv" |
||||
) |
||||
|
||||
type int32Any struct { |
||||
baseAny |
||||
val int32 |
||||
} |
||||
|
||||
func (any *int32Any) LastError() error { |
||||
return nil |
||||
} |
||||
|
||||
func (any *int32Any) ValueType() ValueType { |
||||
return NumberValue |
||||
} |
||||
|
||||
func (any *int32Any) MustBeValid() Any { |
||||
return any |
||||
} |
||||
|
||||
func (any *int32Any) ToBool() bool { |
||||
return any.val != 0 |
||||
} |
||||
|
||||
func (any *int32Any) ToInt() int { |
||||
return int(any.val) |
||||
} |
||||
|
||||
func (any *int32Any) ToInt32() int32 { |
||||
return any.val |
||||
} |
||||
|
||||
func (any *int32Any) ToInt64() int64 { |
||||
return int64(any.val) |
||||
} |
||||
|
||||
func (any *int32Any) ToUint() uint { |
||||
return uint(any.val) |
||||
} |
||||
|
||||
func (any *int32Any) ToUint32() uint32 { |
||||
return uint32(any.val) |
||||
} |
||||
|
||||
func (any *int32Any) ToUint64() uint64 { |
||||
return uint64(any.val) |
||||
} |
||||
|
||||
func (any *int32Any) ToFloat32() float32 { |
||||
return float32(any.val) |
||||
} |
||||
|
||||
func (any *int32Any) ToFloat64() float64 { |
||||
return float64(any.val) |
||||
} |
||||
|
||||
func (any *int32Any) ToString() string { |
||||
return strconv.FormatInt(int64(any.val), 10) |
||||
} |
||||
|
||||
func (any *int32Any) WriteTo(stream *Stream) { |
||||
stream.WriteInt32(any.val) |
||||
} |
||||
|
||||
func (any *int32Any) Parse() *Iterator { |
||||
return nil |
||||
} |
||||
|
||||
func (any *int32Any) GetInterface() interface{} { |
||||
return any.val |
||||
} |
||||
@ -0,0 +1,74 @@ |
||||
package jsoniter |
||||
|
||||
import ( |
||||
"strconv" |
||||
) |
||||
|
||||
type int64Any struct { |
||||
baseAny |
||||
val int64 |
||||
} |
||||
|
||||
func (any *int64Any) LastError() error { |
||||
return nil |
||||
} |
||||
|
||||
func (any *int64Any) ValueType() ValueType { |
||||
return NumberValue |
||||
} |
||||
|
||||
func (any *int64Any) MustBeValid() Any { |
||||
return any |
||||
} |
||||
|
||||
func (any *int64Any) ToBool() bool { |
||||
return any.val != 0 |
||||
} |
||||
|
||||
func (any *int64Any) ToInt() int { |
||||
return int(any.val) |
||||
} |
||||
|
||||
func (any *int64Any) ToInt32() int32 { |
||||
return int32(any.val) |
||||
} |
||||
|
||||
func (any *int64Any) ToInt64() int64 { |
||||
return any.val |
||||
} |
||||
|
||||
func (any *int64Any) ToUint() uint { |
||||
return uint(any.val) |
||||
} |
||||
|
||||
func (any *int64Any) ToUint32() uint32 { |
||||
return uint32(any.val) |
||||
} |
||||
|
||||
func (any *int64Any) ToUint64() uint64 { |
||||
return uint64(any.val) |
||||
} |
||||
|
||||
func (any *int64Any) ToFloat32() float32 { |
||||
return float32(any.val) |
||||
} |
||||
|
||||
func (any *int64Any) ToFloat64() float64 { |
||||
return float64(any.val) |
||||
} |
||||
|
||||
func (any *int64Any) ToString() string { |
||||
return strconv.FormatInt(any.val, 10) |
||||
} |
||||
|
||||
func (any *int64Any) WriteTo(stream *Stream) { |
||||
stream.WriteInt64(any.val) |
||||
} |
||||
|
||||
func (any *int64Any) Parse() *Iterator { |
||||
return nil |
||||
} |
||||
|
||||
func (any *int64Any) GetInterface() interface{} { |
||||
return any.val |
||||
} |
||||
@ -0,0 +1,82 @@ |
||||
package jsoniter |
||||
|
||||
import "fmt" |
||||
|
||||
type invalidAny struct { |
||||
baseAny |
||||
err error |
||||
} |
||||
|
||||
func newInvalidAny(path []interface{}) *invalidAny { |
||||
return &invalidAny{baseAny{}, fmt.Errorf("%v not found", path)} |
||||
} |
||||
|
||||
func (any *invalidAny) LastError() error { |
||||
return any.err |
||||
} |
||||
|
||||
func (any *invalidAny) ValueType() ValueType { |
||||
return InvalidValue |
||||
} |
||||
|
||||
func (any *invalidAny) MustBeValid() Any { |
||||
panic(any.err) |
||||
} |
||||
|
||||
func (any *invalidAny) ToBool() bool { |
||||
return false |
||||
} |
||||
|
||||
func (any *invalidAny) ToInt() int { |
||||
return 0 |
||||
} |
||||
|
||||
func (any *invalidAny) ToInt32() int32 { |
||||
return 0 |
||||
} |
||||
|
||||
func (any *invalidAny) ToInt64() int64 { |
||||
return 0 |
||||
} |
||||
|
||||
func (any *invalidAny) ToUint() uint { |
||||
return 0 |
||||
} |
||||
|
||||
func (any *invalidAny) ToUint32() uint32 { |
||||
return 0 |
||||
} |
||||
|
||||
func (any *invalidAny) ToUint64() uint64 { |
||||
return 0 |
||||
} |
||||
|
||||
func (any *invalidAny) ToFloat32() float32 { |
||||
return 0 |
||||
} |
||||
|
||||
func (any *invalidAny) ToFloat64() float64 { |
||||
return 0 |
||||
} |
||||
|
||||
func (any *invalidAny) ToString() string { |
||||
return "" |
||||
} |
||||
|
||||
func (any *invalidAny) WriteTo(stream *Stream) { |
||||
} |
||||
|
||||
func (any *invalidAny) Get(path ...interface{}) Any { |
||||
if any.err == nil { |
||||
return &invalidAny{baseAny{}, fmt.Errorf("get %v from invalid", path)} |
||||
} |
||||
return &invalidAny{baseAny{}, fmt.Errorf("%v, get %v from invalid", any.err, path)} |
||||
} |
||||
|
||||
func (any *invalidAny) Parse() *Iterator { |
||||
return nil |
||||
} |
||||
|
||||
func (any *invalidAny) GetInterface() interface{} { |
||||
return nil |
||||
} |
||||
@ -0,0 +1,69 @@ |
||||
package jsoniter |
||||
|
||||
type nilAny struct { |
||||
baseAny |
||||
} |
||||
|
||||
func (any *nilAny) LastError() error { |
||||
return nil |
||||
} |
||||
|
||||
func (any *nilAny) ValueType() ValueType { |
||||
return NilValue |
||||
} |
||||
|
||||
func (any *nilAny) MustBeValid() Any { |
||||
return any |
||||
} |
||||
|
||||
func (any *nilAny) ToBool() bool { |
||||
return false |
||||
} |
||||
|
||||
func (any *nilAny) ToInt() int { |
||||
return 0 |
||||
} |
||||
|
||||
func (any *nilAny) ToInt32() int32 { |
||||
return 0 |
||||
} |
||||
|
||||
func (any *nilAny) ToInt64() int64 { |
||||
return 0 |
||||
} |
||||
|
||||
func (any *nilAny) ToUint() uint { |
||||
return 0 |
||||
} |
||||
|
||||
func (any *nilAny) ToUint32() uint32 { |
||||
return 0 |
||||
} |
||||
|
||||
func (any *nilAny) ToUint64() uint64 { |
||||
return 0 |
||||
} |
||||
|
||||
func (any *nilAny) ToFloat32() float32 { |
||||
return 0 |
||||
} |
||||
|
||||
func (any *nilAny) ToFloat64() float64 { |
||||
return 0 |
||||
} |
||||
|
||||
func (any *nilAny) ToString() string { |
||||
return "" |
||||
} |
||||
|
||||
func (any *nilAny) WriteTo(stream *Stream) { |
||||
stream.WriteNil() |
||||
} |
||||
|
||||
func (any *nilAny) Parse() *Iterator { |
||||
return nil |
||||
} |
||||
|
||||
func (any *nilAny) GetInterface() interface{} { |
||||
return nil |
||||
} |
||||
@ -0,0 +1,123 @@ |
||||
package jsoniter |
||||
|
||||
import ( |
||||
"io" |
||||
"unsafe" |
||||
) |
||||
|
||||
type numberLazyAny struct { |
||||
baseAny |
||||
cfg *frozenConfig |
||||
buf []byte |
||||
err error |
||||
} |
||||
|
||||
func (any *numberLazyAny) ValueType() ValueType { |
||||
return NumberValue |
||||
} |
||||
|
||||
func (any *numberLazyAny) MustBeValid() Any { |
||||
return any |
||||
} |
||||
|
||||
func (any *numberLazyAny) LastError() error { |
||||
return any.err |
||||
} |
||||
|
||||
func (any *numberLazyAny) ToBool() bool { |
||||
return any.ToFloat64() != 0 |
||||
} |
||||
|
||||
func (any *numberLazyAny) ToInt() int { |
||||
iter := any.cfg.BorrowIterator(any.buf) |
||||
defer any.cfg.ReturnIterator(iter) |
||||
val := iter.ReadInt() |
||||
if iter.Error != nil && iter.Error != io.EOF { |
||||
any.err = iter.Error |
||||
} |
||||
return val |
||||
} |
||||
|
||||
func (any *numberLazyAny) ToInt32() int32 { |
||||
iter := any.cfg.BorrowIterator(any.buf) |
||||
defer any.cfg.ReturnIterator(iter) |
||||
val := iter.ReadInt32() |
||||
if iter.Error != nil && iter.Error != io.EOF { |
||||
any.err = iter.Error |
||||
} |
||||
return val |
||||
} |
||||
|
||||
func (any *numberLazyAny) ToInt64() int64 { |
||||
iter := any.cfg.BorrowIterator(any.buf) |
||||
defer any.cfg.ReturnIterator(iter) |
||||
val := iter.ReadInt64() |
||||
if iter.Error != nil && iter.Error != io.EOF { |
||||
any.err = iter.Error |
||||
} |
||||
return val |
||||
} |
||||
|
||||
func (any *numberLazyAny) ToUint() uint { |
||||
iter := any.cfg.BorrowIterator(any.buf) |
||||
defer any.cfg.ReturnIterator(iter) |
||||
val := iter.ReadUint() |
||||
if iter.Error != nil && iter.Error != io.EOF { |
||||
any.err = iter.Error |
||||
} |
||||
return val |
||||
} |
||||
|
||||
func (any *numberLazyAny) ToUint32() uint32 { |
||||
iter := any.cfg.BorrowIterator(any.buf) |
||||
defer any.cfg.ReturnIterator(iter) |
||||
val := iter.ReadUint32() |
||||
if iter.Error != nil && iter.Error != io.EOF { |
||||
any.err = iter.Error |
||||
} |
||||
return val |
||||
} |
||||
|
||||
func (any *numberLazyAny) ToUint64() uint64 { |
||||
iter := any.cfg.BorrowIterator(any.buf) |
||||
defer any.cfg.ReturnIterator(iter) |
||||
val := iter.ReadUint64() |
||||
if iter.Error != nil && iter.Error != io.EOF { |
||||
any.err = iter.Error |
||||
} |
||||
return val |
||||
} |
||||
|
||||
func (any *numberLazyAny) ToFloat32() float32 { |
||||
iter := any.cfg.BorrowIterator(any.buf) |
||||
defer any.cfg.ReturnIterator(iter) |
||||
val := iter.ReadFloat32() |
||||
if iter.Error != nil && iter.Error != io.EOF { |
||||
any.err = iter.Error |
||||
} |
||||
return val |
||||
} |
||||
|
||||
func (any *numberLazyAny) ToFloat64() float64 { |
||||
iter := any.cfg.BorrowIterator(any.buf) |
||||
defer any.cfg.ReturnIterator(iter) |
||||
val := iter.ReadFloat64() |
||||
if iter.Error != nil && iter.Error != io.EOF { |
||||
any.err = iter.Error |
||||
} |
||||
return val |
||||
} |
||||
|
||||
func (any *numberLazyAny) ToString() string { |
||||
return *(*string)(unsafe.Pointer(&any.buf)) |
||||
} |
||||
|
||||
func (any *numberLazyAny) WriteTo(stream *Stream) { |
||||
stream.Write(any.buf) |
||||
} |
||||
|
||||
func (any *numberLazyAny) GetInterface() interface{} { |
||||
iter := any.cfg.BorrowIterator(any.buf) |
||||
defer any.cfg.ReturnIterator(iter) |
||||
return iter.Read() |
||||
} |
||||
@ -0,0 +1,374 @@ |
||||
package jsoniter |
||||
|
||||
import ( |
||||
"reflect" |
||||
"unsafe" |
||||
) |
||||
|
||||
type objectLazyAny struct { |
||||
baseAny |
||||
cfg *frozenConfig |
||||
buf []byte |
||||
err error |
||||
} |
||||
|
||||
func (any *objectLazyAny) ValueType() ValueType { |
||||
return ObjectValue |
||||
} |
||||
|
||||
func (any *objectLazyAny) MustBeValid() Any { |
||||
return any |
||||
} |
||||
|
||||
func (any *objectLazyAny) LastError() error { |
||||
return any.err |
||||
} |
||||
|
||||
func (any *objectLazyAny) ToBool() bool { |
||||
return true |
||||
} |
||||
|
||||
func (any *objectLazyAny) ToInt() int { |
||||
return 0 |
||||
} |
||||
|
||||
func (any *objectLazyAny) ToInt32() int32 { |
||||
return 0 |
||||
} |
||||
|
||||
func (any *objectLazyAny) ToInt64() int64 { |
||||
return 0 |
||||
} |
||||
|
||||
func (any *objectLazyAny) ToUint() uint { |
||||
return 0 |
||||
} |
||||
|
||||
func (any *objectLazyAny) ToUint32() uint32 { |
||||
return 0 |
||||
} |
||||
|
||||
func (any *objectLazyAny) ToUint64() uint64 { |
||||
return 0 |
||||
} |
||||
|
||||
func (any *objectLazyAny) ToFloat32() float32 { |
||||
return 0 |
||||
} |
||||
|
||||
func (any *objectLazyAny) ToFloat64() float64 { |
||||
return 0 |
||||
} |
||||
|
||||
func (any *objectLazyAny) ToString() string { |
||||
return *(*string)(unsafe.Pointer(&any.buf)) |
||||
} |
||||
|
||||
func (any *objectLazyAny) ToVal(obj interface{}) { |
||||
iter := any.cfg.BorrowIterator(any.buf) |
||||
defer any.cfg.ReturnIterator(iter) |
||||
iter.ReadVal(obj) |
||||
} |
||||
|
||||
func (any *objectLazyAny) Get(path ...interface{}) Any { |
||||
if len(path) == 0 { |
||||
return any |
||||
} |
||||
switch firstPath := path[0].(type) { |
||||
case string: |
||||
iter := any.cfg.BorrowIterator(any.buf) |
||||
defer any.cfg.ReturnIterator(iter) |
||||
valueBytes := locateObjectField(iter, firstPath) |
||||
if valueBytes == nil { |
||||
return newInvalidAny(path) |
||||
} |
||||
iter.ResetBytes(valueBytes) |
||||
return locatePath(iter, path[1:]) |
||||
case int32: |
||||
if '*' == firstPath { |
||||
mappedAll := map[string]Any{} |
||||
iter := any.cfg.BorrowIterator(any.buf) |
||||
defer any.cfg.ReturnIterator(iter) |
||||
iter.ReadMapCB(func(iter *Iterator, field string) bool { |
||||
mapped := locatePath(iter, path[1:]) |
||||
if mapped.ValueType() != InvalidValue { |
||||
mappedAll[field] = mapped |
||||
} |
||||
return true |
||||
}) |
||||
return wrapMap(mappedAll) |
||||
} |
||||
return newInvalidAny(path) |
||||
default: |
||||
return newInvalidAny(path) |
||||
} |
||||
} |
||||
|
||||
func (any *objectLazyAny) Keys() []string { |
||||
keys := []string{} |
||||
iter := any.cfg.BorrowIterator(any.buf) |
||||
defer any.cfg.ReturnIterator(iter) |
||||
iter.ReadMapCB(func(iter *Iterator, field string) bool { |
||||
iter.Skip() |
||||
keys = append(keys, field) |
||||
return true |
||||
}) |
||||
return keys |
||||
} |
||||
|
||||
func (any *objectLazyAny) Size() int { |
||||
size := 0 |
||||
iter := any.cfg.BorrowIterator(any.buf) |
||||
defer any.cfg.ReturnIterator(iter) |
||||
iter.ReadObjectCB(func(iter *Iterator, field string) bool { |
||||
iter.Skip() |
||||
size++ |
||||
return true |
||||
}) |
||||
return size |
||||
} |
||||
|
||||
func (any *objectLazyAny) WriteTo(stream *Stream) { |
||||
stream.Write(any.buf) |
||||
} |
||||
|
||||
func (any *objectLazyAny) GetInterface() interface{} { |
||||
iter := any.cfg.BorrowIterator(any.buf) |
||||
defer any.cfg.ReturnIterator(iter) |
||||
return iter.Read() |
||||
} |
||||
|
||||
type objectAny struct { |
||||
baseAny |
||||
err error |
||||
val reflect.Value |
||||
} |
||||
|
||||
func wrapStruct(val interface{}) *objectAny { |
||||
return &objectAny{baseAny{}, nil, reflect.ValueOf(val)} |
||||
} |
||||
|
||||
func (any *objectAny) ValueType() ValueType { |
||||
return ObjectValue |
||||
} |
||||
|
||||
func (any *objectAny) MustBeValid() Any { |
||||
return any |
||||
} |
||||
|
||||
func (any *objectAny) Parse() *Iterator { |
||||
return nil |
||||
} |
||||
|
||||
func (any *objectAny) LastError() error { |
||||
return any.err |
||||
} |
||||
|
||||
func (any *objectAny) ToBool() bool { |
||||
return any.val.NumField() != 0 |
||||
} |
||||
|
||||
func (any *objectAny) ToInt() int { |
||||
return 0 |
||||
} |
||||
|
||||
func (any *objectAny) ToInt32() int32 { |
||||
return 0 |
||||
} |
||||
|
||||
func (any *objectAny) ToInt64() int64 { |
||||
return 0 |
||||
} |
||||
|
||||
func (any *objectAny) ToUint() uint { |
||||
return 0 |
||||
} |
||||
|
||||
func (any *objectAny) ToUint32() uint32 { |
||||
return 0 |
||||
} |
||||
|
||||
func (any *objectAny) ToUint64() uint64 { |
||||
return 0 |
||||
} |
||||
|
||||
func (any *objectAny) ToFloat32() float32 { |
||||
return 0 |
||||
} |
||||
|
||||
func (any *objectAny) ToFloat64() float64 { |
||||
return 0 |
||||
} |
||||
|
||||
func (any *objectAny) ToString() string { |
||||
str, err := MarshalToString(any.val.Interface()) |
||||
any.err = err |
||||
return str |
||||
} |
||||
|
||||
func (any *objectAny) Get(path ...interface{}) Any { |
||||
if len(path) == 0 { |
||||
return any |
||||
} |
||||
switch firstPath := path[0].(type) { |
||||
case string: |
||||
field := any.val.FieldByName(firstPath) |
||||
if !field.IsValid() { |
||||
return newInvalidAny(path) |
||||
} |
||||
return Wrap(field.Interface()) |
||||
case int32: |
||||
if '*' == firstPath { |
||||
mappedAll := map[string]Any{} |
||||
for i := 0; i < any.val.NumField(); i++ { |
||||
field := any.val.Field(i) |
||||
if field.CanInterface() { |
||||
mapped := Wrap(field.Interface()).Get(path[1:]...) |
||||
if mapped.ValueType() != InvalidValue { |
||||
mappedAll[any.val.Type().Field(i).Name] = mapped |
||||
} |
||||
} |
||||
} |
||||
return wrapMap(mappedAll) |
||||
} |
||||
return newInvalidAny(path) |
||||
default: |
||||
return newInvalidAny(path) |
||||
} |
||||
} |
||||
|
||||
func (any *objectAny) Keys() []string { |
||||
keys := make([]string, 0, any.val.NumField()) |
||||
for i := 0; i < any.val.NumField(); i++ { |
||||
keys = append(keys, any.val.Type().Field(i).Name) |
||||
} |
||||
return keys |
||||
} |
||||
|
||||
func (any *objectAny) Size() int { |
||||
return any.val.NumField() |
||||
} |
||||
|
||||
func (any *objectAny) WriteTo(stream *Stream) { |
||||
stream.WriteVal(any.val) |
||||
} |
||||
|
||||
func (any *objectAny) GetInterface() interface{} { |
||||
return any.val.Interface() |
||||
} |
||||
|
||||
type mapAny struct { |
||||
baseAny |
||||
err error |
||||
val reflect.Value |
||||
} |
||||
|
||||
func wrapMap(val interface{}) *mapAny { |
||||
return &mapAny{baseAny{}, nil, reflect.ValueOf(val)} |
||||
} |
||||
|
||||
func (any *mapAny) ValueType() ValueType { |
||||
return ObjectValue |
||||
} |
||||
|
||||
func (any *mapAny) MustBeValid() Any { |
||||
return any |
||||
} |
||||
|
||||
func (any *mapAny) Parse() *Iterator { |
||||
return nil |
||||
} |
||||
|
||||
func (any *mapAny) LastError() error { |
||||
return any.err |
||||
} |
||||
|
||||
func (any *mapAny) ToBool() bool { |
||||
return true |
||||
} |
||||
|
||||
func (any *mapAny) ToInt() int { |
||||
return 0 |
||||
} |
||||
|
||||
func (any *mapAny) ToInt32() int32 { |
||||
return 0 |
||||
} |
||||
|
||||
func (any *mapAny) ToInt64() int64 { |
||||
return 0 |
||||
} |
||||
|
||||
func (any *mapAny) ToUint() uint { |
||||
return 0 |
||||
} |
||||
|
||||
func (any *mapAny) ToUint32() uint32 { |
||||
return 0 |
||||
} |
||||
|
||||
func (any *mapAny) ToUint64() uint64 { |
||||
return 0 |
||||
} |
||||
|
||||
func (any *mapAny) ToFloat32() float32 { |
||||
return 0 |
||||
} |
||||
|
||||
func (any *mapAny) ToFloat64() float64 { |
||||
return 0 |
||||
} |
||||
|
||||
func (any *mapAny) ToString() string { |
||||
str, err := MarshalToString(any.val.Interface()) |
||||
any.err = err |
||||
return str |
||||
} |
||||
|
||||
func (any *mapAny) Get(path ...interface{}) Any { |
||||
if len(path) == 0 { |
||||
return any |
||||
} |
||||
switch firstPath := path[0].(type) { |
||||
case int32: |
||||
if '*' == firstPath { |
||||
mappedAll := map[string]Any{} |
||||
for _, key := range any.val.MapKeys() { |
||||
keyAsStr := key.String() |
||||
element := Wrap(any.val.MapIndex(key).Interface()) |
||||
mapped := element.Get(path[1:]...) |
||||
if mapped.ValueType() != InvalidValue { |
||||
mappedAll[keyAsStr] = mapped |
||||
} |
||||
} |
||||
return wrapMap(mappedAll) |
||||
} |
||||
return newInvalidAny(path) |
||||
default: |
||||
value := any.val.MapIndex(reflect.ValueOf(firstPath)) |
||||
if !value.IsValid() { |
||||
return newInvalidAny(path) |
||||
} |
||||
return Wrap(value.Interface()) |
||||
} |
||||
} |
||||
|
||||
func (any *mapAny) Keys() []string { |
||||
keys := make([]string, 0, any.val.Len()) |
||||
for _, key := range any.val.MapKeys() { |
||||
keys = append(keys, key.String()) |
||||
} |
||||
return keys |
||||
} |
||||
|
||||
func (any *mapAny) Size() int { |
||||
return any.val.Len() |
||||
} |
||||
|
||||
func (any *mapAny) WriteTo(stream *Stream) { |
||||
stream.WriteVal(any.val) |
||||
} |
||||
|
||||
func (any *mapAny) GetInterface() interface{} { |
||||
return any.val.Interface() |
||||
} |
||||
@ -0,0 +1,166 @@ |
||||
package jsoniter |
||||
|
||||
import ( |
||||
"fmt" |
||||
"strconv" |
||||
) |
||||
|
||||
type stringAny struct { |
||||
baseAny |
||||
val string |
||||
} |
||||
|
||||
func (any *stringAny) Get(path ...interface{}) Any { |
||||
if len(path) == 0 { |
||||
return any |
||||
} |
||||
return &invalidAny{baseAny{}, fmt.Errorf("GetIndex %v from simple value", path)} |
||||
} |
||||
|
||||
func (any *stringAny) Parse() *Iterator { |
||||
return nil |
||||
} |
||||
|
||||
func (any *stringAny) ValueType() ValueType { |
||||
return StringValue |
||||
} |
||||
|
||||
func (any *stringAny) MustBeValid() Any { |
||||
return any |
||||
} |
||||
|
||||
func (any *stringAny) LastError() error { |
||||
return nil |
||||
} |
||||
|
||||
func (any *stringAny) ToBool() bool { |
||||
str := any.ToString() |
||||
if str == "0" { |
||||
return false |
||||
} |
||||
for _, c := range str { |
||||
switch c { |
||||
case ' ', '\n', '\r', '\t': |
||||
default: |
||||
return true |
||||
} |
||||
} |
||||
return false |
||||
} |
||||
|
||||
func (any *stringAny) ToInt() int { |
||||
return int(any.ToInt64()) |
||||
|
||||
} |
||||
|
||||
func (any *stringAny) ToInt32() int32 { |
||||
return int32(any.ToInt64()) |
||||
} |
||||
|
||||
func (any *stringAny) ToInt64() int64 { |
||||
if any.val == "" { |
||||
return 0 |
||||
} |
||||
|
||||
flag := 1 |
||||
startPos := 0 |
||||
endPos := 0 |
||||
if any.val[0] == '+' || any.val[0] == '-' { |
||||
startPos = 1 |
||||
} |
||||
|
||||
if any.val[0] == '-' { |
||||
flag = -1 |
||||
} |
||||
|
||||
for i := startPos; i < len(any.val); i++ { |
||||
if any.val[i] >= '0' && any.val[i] <= '9' { |
||||
endPos = i + 1 |
||||
} else { |
||||
break |
||||
} |
||||
} |
||||
parsed, _ := strconv.ParseInt(any.val[startPos:endPos], 10, 64) |
||||
return int64(flag) * parsed |
||||
} |
||||
|
||||
func (any *stringAny) ToUint() uint { |
||||
return uint(any.ToUint64()) |
||||
} |
||||
|
||||
func (any *stringAny) ToUint32() uint32 { |
||||
return uint32(any.ToUint64()) |
||||
} |
||||
|
||||
func (any *stringAny) ToUint64() uint64 { |
||||
if any.val == "" { |
||||
return 0 |
||||
} |
||||
|
||||
startPos := 0 |
||||
endPos := 0 |
||||
|
||||
if any.val[0] == '-' { |
||||
return 0 |
||||
} |
||||
if any.val[0] == '+' { |
||||
startPos = 1 |
||||
} |
||||
|
||||
for i := startPos; i < len(any.val); i++ { |
||||
if any.val[i] >= '0' && any.val[i] <= '9' { |
||||
endPos = i + 1 |
||||
} else { |
||||
break |
||||
} |
||||
} |
||||
parsed, _ := strconv.ParseUint(any.val[startPos:endPos], 10, 64) |
||||
return parsed |
||||
} |
||||
|
||||
func (any *stringAny) ToFloat32() float32 { |
||||
return float32(any.ToFloat64()) |
||||
} |
||||
|
||||
func (any *stringAny) ToFloat64() float64 { |
||||
if len(any.val) == 0 { |
||||
return 0 |
||||
} |
||||
|
||||
// first char invalid
|
||||
if any.val[0] != '+' && any.val[0] != '-' && (any.val[0] > '9' || any.val[0] < '0') { |
||||
return 0 |
||||
} |
||||
|
||||
// extract valid num expression from string
|
||||
// eg 123true => 123, -12.12xxa => -12.12
|
||||
endPos := 1 |
||||
for i := 1; i < len(any.val); i++ { |
||||
if any.val[i] == '.' || any.val[i] == 'e' || any.val[i] == 'E' || any.val[i] == '+' || any.val[i] == '-' { |
||||
endPos = i + 1 |
||||
continue |
||||
} |
||||
|
||||
// end position is the first char which is not digit
|
||||
if any.val[i] >= '0' && any.val[i] <= '9' { |
||||
endPos = i + 1 |
||||
} else { |
||||
endPos = i |
||||
break |
||||
} |
||||
} |
||||
parsed, _ := strconv.ParseFloat(any.val[:endPos], 64) |
||||
return parsed |
||||
} |
||||
|
||||
func (any *stringAny) ToString() string { |
||||
return any.val |
||||
} |
||||
|
||||
func (any *stringAny) WriteTo(stream *Stream) { |
||||
stream.WriteString(any.val) |
||||
} |
||||
|
||||
func (any *stringAny) GetInterface() interface{} { |
||||
return any.val |
||||
} |
||||
@ -0,0 +1,74 @@ |
||||
package jsoniter |
||||
|
||||
import ( |
||||
"strconv" |
||||
) |
||||
|
||||
type uint32Any struct { |
||||
baseAny |
||||
val uint32 |
||||
} |
||||
|
||||
func (any *uint32Any) LastError() error { |
||||
return nil |
||||
} |
||||
|
||||
func (any *uint32Any) ValueType() ValueType { |
||||
return NumberValue |
||||
} |
||||
|
||||
func (any *uint32Any) MustBeValid() Any { |
||||
return any |
||||
} |
||||
|
||||
func (any *uint32Any) ToBool() bool { |
||||
return any.val != 0 |
||||
} |
||||
|
||||
func (any *uint32Any) ToInt() int { |
||||
return int(any.val) |
||||
} |
||||
|
||||
func (any *uint32Any) ToInt32() int32 { |
||||
return int32(any.val) |
||||
} |
||||
|
||||
func (any *uint32Any) ToInt64() int64 { |
||||
return int64(any.val) |
||||
} |
||||
|
||||
func (any *uint32Any) ToUint() uint { |
||||
return uint(any.val) |
||||
} |
||||
|
||||
func (any *uint32Any) ToUint32() uint32 { |
||||
return any.val |
||||
} |
||||
|
||||
func (any *uint32Any) ToUint64() uint64 { |
||||
return uint64(any.val) |
||||
} |
||||
|
||||
func (any *uint32Any) ToFloat32() float32 { |
||||
return float32(any.val) |
||||
} |
||||
|
||||
func (any *uint32Any) ToFloat64() float64 { |
||||
return float64(any.val) |
||||
} |
||||
|
||||
func (any *uint32Any) ToString() string { |
||||
return strconv.FormatInt(int64(any.val), 10) |
||||
} |
||||
|
||||
func (any *uint32Any) WriteTo(stream *Stream) { |
||||
stream.WriteUint32(any.val) |
||||
} |
||||
|
||||
func (any *uint32Any) Parse() *Iterator { |
||||
return nil |
||||
} |
||||
|
||||
func (any *uint32Any) GetInterface() interface{} { |
||||
return any.val |
||||
} |
||||
@ -0,0 +1,74 @@ |
||||
package jsoniter |
||||
|
||||
import ( |
||||
"strconv" |
||||
) |
||||
|
||||
type uint64Any struct { |
||||
baseAny |
||||
val uint64 |
||||
} |
||||
|
||||
func (any *uint64Any) LastError() error { |
||||
return nil |
||||
} |
||||
|
||||
func (any *uint64Any) ValueType() ValueType { |
||||
return NumberValue |
||||
} |
||||
|
||||
func (any *uint64Any) MustBeValid() Any { |
||||
return any |
||||
} |
||||
|
||||
func (any *uint64Any) ToBool() bool { |
||||
return any.val != 0 |
||||
} |
||||
|
||||
func (any *uint64Any) ToInt() int { |
||||
return int(any.val) |
||||
} |
||||
|
||||
func (any *uint64Any) ToInt32() int32 { |
||||
return int32(any.val) |
||||
} |
||||
|
||||
func (any *uint64Any) ToInt64() int64 { |
||||
return int64(any.val) |
||||
} |
||||
|
||||
func (any *uint64Any) ToUint() uint { |
||||
return uint(any.val) |
||||
} |
||||
|
||||
func (any *uint64Any) ToUint32() uint32 { |
||||
return uint32(any.val) |
||||
} |
||||
|
||||
func (any *uint64Any) ToUint64() uint64 { |
||||
return any.val |
||||
} |
||||
|
||||
func (any *uint64Any) ToFloat32() float32 { |
||||
return float32(any.val) |
||||
} |
||||
|
||||
func (any *uint64Any) ToFloat64() float64 { |
||||
return float64(any.val) |
||||
} |
||||
|
||||
func (any *uint64Any) ToString() string { |
||||
return strconv.FormatUint(any.val, 10) |
||||
} |
||||
|
||||
func (any *uint64Any) WriteTo(stream *Stream) { |
||||
stream.WriteUint64(any.val) |
||||
} |
||||
|
||||
func (any *uint64Any) Parse() *Iterator { |
||||
return nil |
||||
} |
||||
|
||||
func (any *uint64Any) GetInterface() interface{} { |
||||
return any.val |
||||
} |
||||
@ -0,0 +1,12 @@ |
||||
#!/bin/bash |
||||
set -e |
||||
set -x |
||||
|
||||
if [ ! -d /tmp/build-golang/src/github.com/json-iterator ]; then |
||||
mkdir -p /tmp/build-golang/src/github.com/json-iterator |
||||
ln -s $PWD /tmp/build-golang/src/github.com/json-iterator/go |
||||
fi |
||||
export GOPATH=/tmp/build-golang |
||||
go get -u github.com/golang/dep/cmd/dep |
||||
cd /tmp/build-golang/src/github.com/json-iterator/go |
||||
exec $GOPATH/bin/dep ensure -update |
||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in new issue