Merge pull request #41 from Bytom/dev

[bytom/vapor.git] / vendor / github.com / golang / protobuf / jsonpb / jsonpb.go

// Go support for Protocol Buffers - Google's data interchange format
//
// Copyright 2015 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 jsonpb provides marshaling and unmarshaling between protocol buffers and JSON.
It follows the specification at https://developers.google.com/protocol-buffers/docs/proto3#json.

This package produces a different output than the standard "encoding/json" package,
which does not operate correctly on protocol buffers.
*/
package jsonpb

import (
        "bytes"
        "encoding/json"
        "errors"
        "fmt"
        "io"
        "math"
        "reflect"
        "sort"
        "strconv"
        "strings"
        "time"

        "github.com/golang/protobuf/proto"

        stpb "github.com/golang/protobuf/ptypes/struct"
)

// Marshaler is a configurable object for converting between
// protocol buffer objects and a JSON representation for them.
type Marshaler struct {
        // Whether to render enum values as integers, as opposed to string values.
        EnumsAsInts bool

        // Whether to render fields with zero values.
        EmitDefaults bool

        // A string to indent each level by. The presence of this field will
        // also cause a space to appear between the field separator and
        // value, and for newlines to be appear between fields and array
        // elements.
        Indent string

        // Whether to use the original (.proto) name for fields.
        OrigName bool

        // A custom URL resolver to use when marshaling Any messages to JSON.
        // If unset, the default resolution strategy is to extract the
        // fully-qualified type name from the type URL and pass that to
        // proto.MessageType(string).
        AnyResolver AnyResolver
}

// AnyResolver takes a type URL, present in an Any message, and resolves it into
// an instance of the associated message.
type AnyResolver interface {
        Resolve(typeUrl string) (proto.Message, error)
}

func defaultResolveAny(typeUrl string) (proto.Message, error) {
        // Only the part of typeUrl after the last slash is relevant.
        mname := typeUrl
        if slash := strings.LastIndex(mname, "/"); slash >= 0 {
                mname = mname[slash+1:]
        }
        mt := proto.MessageType(mname)
        if mt == nil {
                return nil, fmt.Errorf("unknown message type %q", mname)
        }
        return reflect.New(mt.Elem()).Interface().(proto.Message), nil
}

// JSONPBMarshaler is implemented by protobuf messages that customize the
// way they are marshaled to JSON. Messages that implement this should
// also implement JSONPBUnmarshaler so that the custom format can be
// parsed.
type JSONPBMarshaler interface {
        MarshalJSONPB(*Marshaler) ([]byte, error)
}

// JSONPBUnmarshaler is implemented by protobuf messages that customize
// the way they are unmarshaled from JSON. Messages that implement this
// should also implement JSONPBMarshaler so that the custom format can be
// produced.
type JSONPBUnmarshaler interface {
        UnmarshalJSONPB(*Unmarshaler, []byte) error
}

// Marshal marshals a protocol buffer into JSON.
func (m *Marshaler) Marshal(out io.Writer, pb proto.Message) error {
        writer := &errWriter{writer: out}
        return m.marshalObject(writer, pb, "", "")
}

// MarshalToString converts a protocol buffer object to JSON string.
func (m *Marshaler) MarshalToString(pb proto.Message) (string, error) {
        var buf bytes.Buffer
        if err := m.Marshal(&buf, pb); err != nil {
                return "", err
        }
        return buf.String(), nil
}

type int32Slice []int32

var nonFinite = map[string]float64{
        `"NaN"`:       math.NaN(),
        `"Infinity"`:  math.Inf(1),
        `"-Infinity"`: math.Inf(-1),
}

// For sorting extensions ids to ensure stable output.
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] }

type wkt interface {
        XXX_WellKnownType() string
}

// marshalObject writes a struct to the Writer.
func (m *Marshaler) marshalObject(out *errWriter, v proto.Message, indent, typeURL string) error {
        if jsm, ok := v.(JSONPBMarshaler); ok {
                b, err := jsm.MarshalJSONPB(m)
                if err != nil {
                        return err
                }
                if typeURL != "" {
                        // we are marshaling this object to an Any type
                        var js map[string]*json.RawMessage
                        if err = json.Unmarshal(b, &js); err != nil {
                                return fmt.Errorf("type %T produced invalid JSON: %v", v, err)
                        }
                        turl, err := json.Marshal(typeURL)
                        if err != nil {
                                return fmt.Errorf("failed to marshal type URL %q to JSON: %v", typeURL, err)
                        }
                        js["@type"] = (*json.RawMessage)(&turl)
                        if b, err = json.Marshal(js); err != nil {
                                return err
                        }
                }

                out.write(string(b))
                return out.err
        }

        s := reflect.ValueOf(v).Elem()

        // Handle well-known types.
        if wkt, ok := v.(wkt); ok {
                switch wkt.XXX_WellKnownType() {
                case "DoubleValue", "FloatValue", "Int64Value", "UInt64Value",
                        "Int32Value", "UInt32Value", "BoolValue", "StringValue", "BytesValue":
                        // "Wrappers use the same representation in JSON
                        //  as the wrapped primitive type, ..."
                        sprop := proto.GetProperties(s.Type())
                        return m.marshalValue(out, sprop.Prop[0], s.Field(0), indent)
                case "Any":
                        // Any is a bit more involved.
                        return m.marshalAny(out, v, indent)
                case "Duration":
                        // "Generated output always contains 3, 6, or 9 fractional digits,
                        //  depending on required precision."
                        s, ns := s.Field(0).Int(), s.Field(1).Int()
                        d := time.Duration(s)*time.Second + time.Duration(ns)*time.Nanosecond
                        x := fmt.Sprintf("%.9f", d.Seconds())
                        x = strings.TrimSuffix(x, "000")
                        x = strings.TrimSuffix(x, "000")
                        out.write(`"`)
                        out.write(x)
                        out.write(`s"`)
                        return out.err
                case "Struct", "ListValue":
                        // Let marshalValue handle the `Struct.fields` map or the `ListValue.values` slice.
                        // TODO: pass the correct Properties if needed.
                        return m.marshalValue(out, &proto.Properties{}, s.Field(0), indent)
                case "Timestamp":
                        // "RFC 3339, where generated output will always be Z-normalized
                        //  and uses 3, 6 or 9 fractional digits."
                        s, ns := s.Field(0).Int(), s.Field(1).Int()
                        t := time.Unix(s, ns).UTC()
                        // time.RFC3339Nano isn't exactly right (we need to get 3/6/9 fractional digits).
                        x := t.Format("2006-01-02T15:04:05.000000000")
                        x = strings.TrimSuffix(x, "000")
                        x = strings.TrimSuffix(x, "000")
                        out.write(`"`)
                        out.write(x)
                        out.write(`Z"`)
                        return out.err
                case "Value":
                        // Value has a single oneof.
                        kind := s.Field(0)
                        if kind.IsNil() {
                                // "absence of any variant indicates an error"
                                return errors.New("nil Value")
                        }
                        // oneof -> *T -> T -> T.F
                        x := kind.Elem().Elem().Field(0)
                        // TODO: pass the correct Properties if needed.
                        return m.marshalValue(out, &proto.Properties{}, x, indent)
                }
        }

        out.write("{")
        if m.Indent != "" {
                out.write("\n")
        }

        firstField := true

        if typeURL != "" {
                if err := m.marshalTypeURL(out, indent, typeURL); err != nil {
                        return err
                }
                firstField = false
        }

        for i := 0; i < s.NumField(); i++ {
                value := s.Field(i)
                valueField := s.Type().Field(i)
                if strings.HasPrefix(valueField.Name, "XXX_") {
                        continue
                }

                // IsNil will panic on most value kinds.
                switch value.Kind() {
                case reflect.Chan, reflect.Func, reflect.Interface:
                        if value.IsNil() {
                                continue
                        }
                }

                if !m.EmitDefaults {
                        switch value.Kind() {
                        case reflect.Bool:
                                if !value.Bool() {
                                        continue
                                }
                        case reflect.Int32, reflect.Int64:
                                if value.Int() == 0 {
                                        continue
                                }
                        case reflect.Uint32, reflect.Uint64:
                                if value.Uint() == 0 {
                                        continue
                                }
                        case reflect.Float32, reflect.Float64:
                                if value.Float() == 0 {
                                        continue
                                }
                        case reflect.String:
                                if value.Len() == 0 {
                                        continue
                                }
                        case reflect.Map, reflect.Ptr, reflect.Slice:
                                if value.IsNil() {
                                        continue
                                }
                        }
                }

                // Oneof fields need special handling.
                if valueField.Tag.Get("protobuf_oneof") != "" {
                        // value is an interface containing &T{real_value}.
                        sv := value.Elem().Elem() // interface -> *T -> T
                        value = sv.Field(0)
                        valueField = sv.Type().Field(0)
                }
                prop := jsonProperties(valueField, m.OrigName)
                if !firstField {
                        m.writeSep(out)
                }
                if err := m.marshalField(out, prop, value, indent); err != nil {
                        return err
                }
                firstField = false
        }

        // Handle proto2 extensions.
        if ep, ok := v.(proto.Message); ok {
                extensions := proto.RegisteredExtensions(v)
                // Sort extensions for stable output.
                ids := make([]int32, 0, len(extensions))
                for id, desc := range extensions {
                        if !proto.HasExtension(ep, desc) {
                                continue
                        }
                        ids = append(ids, id)
                }
                sort.Sort(int32Slice(ids))
                for _, id := range ids {
                        desc := extensions[id]
                        if desc == nil {
                                // unknown extension
                                continue
                        }
                        ext, extErr := proto.GetExtension(ep, desc)
                        if extErr != nil {
                                return extErr
                        }
                        value := reflect.ValueOf(ext)
                        var prop proto.Properties
                        prop.Parse(desc.Tag)
                        prop.JSONName = fmt.Sprintf("[%s]", desc.Name)
                        if !firstField {
                                m.writeSep(out)
                        }
                        if err := m.marshalField(out, &prop, value, indent); err != nil {
                                return err
                        }
                        firstField = false
                }

        }

        if m.Indent != "" {
                out.write("\n")
                out.write(indent)
        }
        out.write("}")
        return out.err
}

func (m *Marshaler) writeSep(out *errWriter) {
        if m.Indent != "" {
                out.write(",\n")
        } else {
                out.write(",")
        }
}

func (m *Marshaler) marshalAny(out *errWriter, any proto.Message, indent string) error {
        // "If the Any contains a value that has a special JSON mapping,
        //  it will be converted as follows: {"@type": xxx, "value": yyy}.
        //  Otherwise, the value will be converted into a JSON object,
        //  and the "@type" field will be inserted to indicate the actual data type."
        v := reflect.ValueOf(any).Elem()
        turl := v.Field(0).String()
        val := v.Field(1).Bytes()

        var msg proto.Message
        var err error
        if m.AnyResolver != nil {
                msg, err = m.AnyResolver.Resolve(turl)
        } else {
                msg, err = defaultResolveAny(turl)
        }
        if err != nil {
                return err
        }

        if err := proto.Unmarshal(val, msg); err != nil {
                return err
        }

        if _, ok := msg.(wkt); ok {
                out.write("{")
                if m.Indent != "" {
                        out.write("\n")
                }
                if err := m.marshalTypeURL(out, indent, turl); err != nil {
                        return err
                }
                m.writeSep(out)
                if m.Indent != "" {
                        out.write(indent)
                        out.write(m.Indent)
                        out.write(`"value": `)
                } else {
                        out.write(`"value":`)
                }
                if err := m.marshalObject(out, msg, indent+m.Indent, ""); err != nil {
                        return err
                }
                if m.Indent != "" {
                        out.write("\n")
                        out.write(indent)
                }
                out.write("}")
                return out.err
        }

        return m.marshalObject(out, msg, indent, turl)
}

func (m *Marshaler) marshalTypeURL(out *errWriter, indent, typeURL string) error {
        if m.Indent != "" {
                out.write(indent)
                out.write(m.Indent)
        }
        out.write(`"@type":`)
        if m.Indent != "" {
                out.write(" ")
        }
        b, err := json.Marshal(typeURL)
        if err != nil {
                return err
        }
        out.write(string(b))
        return out.err
}

// marshalField writes field description and value to the Writer.
func (m *Marshaler) marshalField(out *errWriter, prop *proto.Properties, v reflect.Value, indent string) error {
        if m.Indent != "" {
                out.write(indent)
                out.write(m.Indent)
        }
        out.write(`"`)
        out.write(prop.JSONName)
        out.write(`":`)
        if m.Indent != "" {
                out.write(" ")
        }
        if err := m.marshalValue(out, prop, v, indent); err != nil {
                return err
        }
        return nil
}

// marshalValue writes the value to the Writer.
func (m *Marshaler) marshalValue(out *errWriter, prop *proto.Properties, v reflect.Value, indent string) error {
        var err error
        v = reflect.Indirect(v)

        // Handle nil pointer
        if v.Kind() == reflect.Invalid {
                out.write("null")
                return out.err
        }

        // Handle repeated elements.
        if v.Kind() == reflect.Slice && v.Type().Elem().Kind() != reflect.Uint8 {
                out.write("[")
                comma := ""
                for i := 0; i < v.Len(); i++ {
                        sliceVal := v.Index(i)
                        out.write(comma)
                        if m.Indent != "" {
                                out.write("\n")
                                out.write(indent)
                                out.write(m.Indent)
                                out.write(m.Indent)
                        }
                        if err := m.marshalValue(out, prop, sliceVal, indent+m.Indent); err != nil {
                                return err
                        }
                        comma = ","
                }
                if m.Indent != "" {
                        out.write("\n")
                        out.write(indent)
                        out.write(m.Indent)
                }
                out.write("]")
                return out.err
        }

        // Handle well-known types.
        // Most are handled up in marshalObject (because 99% are messages).
        if wkt, ok := v.Interface().(wkt); ok {
                switch wkt.XXX_WellKnownType() {
                case "NullValue":
                        out.write("null")
                        return out.err
                }
        }

        // Handle enumerations.
        if !m.EnumsAsInts && prop.Enum != "" {
                // Unknown enum values will are stringified by the proto library as their
                // value. Such values should _not_ be quoted or they will be interpreted
                // as an enum string instead of their value.
                enumStr := v.Interface().(fmt.Stringer).String()
                var valStr string
                if v.Kind() == reflect.Ptr {
                        valStr = strconv.Itoa(int(v.Elem().Int()))
                } else {
                        valStr = strconv.Itoa(int(v.Int()))
                }
                isKnownEnum := enumStr != valStr
                if isKnownEnum {
                        out.write(`"`)
                }
                out.write(enumStr)
                if isKnownEnum {
                        out.write(`"`)
                }
                return out.err
        }

        // Handle nested messages.
        if v.Kind() == reflect.Struct {
                return m.marshalObject(out, v.Addr().Interface().(proto.Message), indent+m.Indent, "")
        }

        // Handle maps.
        // Since Go randomizes map iteration, we sort keys for stable output.
        if v.Kind() == reflect.Map {
                out.write(`{`)
                keys := v.MapKeys()
                sort.Sort(mapKeys(keys))
                for i, k := range keys {
                        if i > 0 {
                                out.write(`,`)
                        }
                        if m.Indent != "" {
                                out.write("\n")
                                out.write(indent)
                                out.write(m.Indent)
                                out.write(m.Indent)
                        }

                        b, err := json.Marshal(k.Interface())
                        if err != nil {
                                return err
                        }
                        s := string(b)

                        // If the JSON is not a string value, encode it again to make it one.
                        if !strings.HasPrefix(s, `"`) {
                                b, err := json.Marshal(s)
                                if err != nil {
                                        return err
                                }
                                s = string(b)
                        }

                        out.write(s)
                        out.write(`:`)
                        if m.Indent != "" {
                                out.write(` `)
                        }

                        if err := m.marshalValue(out, prop, v.MapIndex(k), indent+m.Indent); err != nil {
                                return err
                        }
                }
                if m.Indent != "" {
                        out.write("\n")
                        out.write(indent)
                        out.write(m.Indent)
                }
                out.write(`}`)
                return out.err
        }

        // Handle non-finite floats, e.g. NaN, Infinity and -Infinity.
        if v.Kind() == reflect.Float32 || v.Kind() == reflect.Float64 {
                f := v.Float()
                var sval string
                switch {
                case math.IsInf(f, 1):
                        sval = `"Infinity"`
                case math.IsInf(f, -1):
                        sval = `"-Infinity"`
                case math.IsNaN(f):
                        sval = `"NaN"`
                }
                if sval != "" {
                        out.write(sval)
                        return out.err
                }
        }

        // Default handling defers to the encoding/json library.
        b, err := json.Marshal(v.Interface())
        if err != nil {
                return err
        }
        needToQuote := string(b[0]) != `"` && (v.Kind() == reflect.Int64 || v.Kind() == reflect.Uint64)
        if needToQuote {
                out.write(`"`)
        }
        out.write(string(b))
        if needToQuote {
                out.write(`"`)
        }
        return out.err
}

// Unmarshaler is a configurable object for converting from a JSON
// representation to a protocol buffer object.
type Unmarshaler struct {
        // Whether to allow messages to contain unknown fields, as opposed to
        // failing to unmarshal.
        AllowUnknownFields bool

        // A custom URL resolver to use when unmarshaling Any messages from JSON.
        // If unset, the default resolution strategy is to extract the
        // fully-qualified type name from the type URL and pass that to
        // proto.MessageType(string).
        AnyResolver AnyResolver
}

// UnmarshalNext unmarshals the next protocol buffer from a JSON object stream.
// This function is lenient and will decode any options permutations of the
// related Marshaler.
func (u *Unmarshaler) UnmarshalNext(dec *json.Decoder, pb proto.Message) error {
        inputValue := json.RawMessage{}
        if err := dec.Decode(&inputValue); err != nil {
                return err
        }
        return u.unmarshalValue(reflect.ValueOf(pb).Elem(), inputValue, nil)
}

// Unmarshal unmarshals a JSON object stream into a protocol
// buffer. This function is lenient and will decode any options
// permutations of the related Marshaler.
func (u *Unmarshaler) Unmarshal(r io.Reader, pb proto.Message) error {
        dec := json.NewDecoder(r)
        return u.UnmarshalNext(dec, pb)
}

// UnmarshalNext unmarshals the next protocol buffer from a JSON object stream.
// This function is lenient and will decode any options permutations of the
// related Marshaler.
func UnmarshalNext(dec *json.Decoder, pb proto.Message) error {
        return new(Unmarshaler).UnmarshalNext(dec, pb)
}

// Unmarshal unmarshals a JSON object stream into a protocol
// buffer. This function is lenient and will decode any options
// permutations of the related Marshaler.
func Unmarshal(r io.Reader, pb proto.Message) error {
        return new(Unmarshaler).Unmarshal(r, pb)
}

// UnmarshalString will populate the fields of a protocol buffer based
// on a JSON string. This function is lenient and will decode any options
// permutations of the related Marshaler.
func UnmarshalString(str string, pb proto.Message) error {
        return new(Unmarshaler).Unmarshal(strings.NewReader(str), pb)
}

// unmarshalValue converts/copies a value into the target.
// prop may be nil.
func (u *Unmarshaler) unmarshalValue(target reflect.Value, inputValue json.RawMessage, prop *proto.Properties) error {
        targetType := target.Type()

        // Allocate memory for pointer fields.
        if targetType.Kind() == reflect.Ptr {
                // If input value is "null" and target is a pointer type, then the field should be treated as not set
                // UNLESS the target is structpb.Value, in which case it should be set to structpb.NullValue.
                _, isJSONPBUnmarshaler := target.Interface().(JSONPBUnmarshaler)
                if string(inputValue) == "null" && targetType != reflect.TypeOf(&stpb.Value{}) && !isJSONPBUnmarshaler {
                        return nil
                }
                target.Set(reflect.New(targetType.Elem()))

                return u.unmarshalValue(target.Elem(), inputValue, prop)
        }

        if jsu, ok := target.Addr().Interface().(JSONPBUnmarshaler); ok {
                return jsu.UnmarshalJSONPB(u, []byte(inputValue))
        }

        // Handle well-known types that are not pointers.
        if w, ok := target.Addr().Interface().(wkt); ok {
                switch w.XXX_WellKnownType() {
                case "DoubleValue", "FloatValue", "Int64Value", "UInt64Value",
                        "Int32Value", "UInt32Value", "BoolValue", "StringValue", "BytesValue":
                        return u.unmarshalValue(target.Field(0), inputValue, prop)
                case "Any":
                        // Use json.RawMessage pointer type instead of value to support pre-1.8 version.
                        // 1.8 changed RawMessage.MarshalJSON from pointer type to value type, see
                        // https://github.com/golang/go/issues/14493
                        var jsonFields map[string]*json.RawMessage
                        if err := json.Unmarshal(inputValue, &jsonFields); err != nil {
                                return err
                        }

                        val, ok := jsonFields["@type"]
                        if !ok || val == nil {
                                return errors.New("Any JSON doesn't have '@type'")
                        }

                        var turl string
                        if err := json.Unmarshal([]byte(*val), &turl); err != nil {
                                return fmt.Errorf("can't unmarshal Any's '@type': %q", *val)
                        }
                        target.Field(0).SetString(turl)

                        var m proto.Message
                        var err error
                        if u.AnyResolver != nil {
                                m, err = u.AnyResolver.Resolve(turl)
                        } else {
                                m, err = defaultResolveAny(turl)
                        }
                        if err != nil {
                                return err
                        }

                        if _, ok := m.(wkt); ok {
                                val, ok := jsonFields["value"]
                                if !ok {
                                        return errors.New("Any JSON doesn't have 'value'")
                                }

                                if err := u.unmarshalValue(reflect.ValueOf(m).Elem(), *val, nil); err != nil {
                                        return fmt.Errorf("can't unmarshal Any nested proto %T: %v", m, err)
                                }
                        } else {
                                delete(jsonFields, "@type")
                                nestedProto, err := json.Marshal(jsonFields)
                                if err != nil {
                                        return fmt.Errorf("can't generate JSON for Any's nested proto to be unmarshaled: %v", err)
                                }

                                if err = u.unmarshalValue(reflect.ValueOf(m).Elem(), nestedProto, nil); err != nil {
                                        return fmt.Errorf("can't unmarshal Any nested proto %T: %v", m, err)
                                }
                        }

                        b, err := proto.Marshal(m)
                        if err != nil {
                                return fmt.Errorf("can't marshal proto %T into Any.Value: %v", m, err)
                        }
                        target.Field(1).SetBytes(b)

                        return nil
                case "Duration":
                        unq, err := strconv.Unquote(string(inputValue))
                        if err != nil {
                                return err
                        }

                        d, err := time.ParseDuration(unq)
                        if err != nil {
                                return fmt.Errorf("bad Duration: %v", err)
                        }

                        ns := d.Nanoseconds()
                        s := ns / 1e9
                        ns %= 1e9
                        target.Field(0).SetInt(s)
                        target.Field(1).SetInt(ns)
                        return nil
                case "Timestamp":
                        unq, err := strconv.Unquote(string(inputValue))
                        if err != nil {
                                return err
                        }

                        t, err := time.Parse(time.RFC3339Nano, unq)
                        if err != nil {
                                return fmt.Errorf("bad Timestamp: %v", err)
                        }

                        target.Field(0).SetInt(t.Unix())
                        target.Field(1).SetInt(int64(t.Nanosecond()))
                        return nil
                case "Struct":
                        var m map[string]json.RawMessage
                        if err := json.Unmarshal(inputValue, &m); err != nil {
                                return fmt.Errorf("bad StructValue: %v", err)
                        }

                        target.Field(0).Set(reflect.ValueOf(map[string]*stpb.Value{}))
                        for k, jv := range m {
                                pv := &stpb.Value{}
                                if err := u.unmarshalValue(reflect.ValueOf(pv).Elem(), jv, prop); err != nil {
                                        return fmt.Errorf("bad value in StructValue for key %q: %v", k, err)
                                }
                                target.Field(0).SetMapIndex(reflect.ValueOf(k), reflect.ValueOf(pv))
                        }
                        return nil
                case "ListValue":
                        var s []json.RawMessage
                        if err := json.Unmarshal(inputValue, &s); err != nil {
                                return fmt.Errorf("bad ListValue: %v", err)
                        }

                        target.Field(0).Set(reflect.ValueOf(make([]*stpb.Value, len(s), len(s))))
                        for i, sv := range s {
                                if err := u.unmarshalValue(target.Field(0).Index(i), sv, prop); err != nil {
                                        return err
                                }
                        }
                        return nil
                case "Value":
                        ivStr := string(inputValue)
                        if ivStr == "null" {
                                target.Field(0).Set(reflect.ValueOf(&stpb.Value_NullValue{}))
                        } else if v, err := strconv.ParseFloat(ivStr, 0); err == nil {
                                target.Field(0).Set(reflect.ValueOf(&stpb.Value_NumberValue{v}))
                        } else if v, err := strconv.Unquote(ivStr); err == nil {
                                target.Field(0).Set(reflect.ValueOf(&stpb.Value_StringValue{v}))
                        } else if v, err := strconv.ParseBool(ivStr); err == nil {
                                target.Field(0).Set(reflect.ValueOf(&stpb.Value_BoolValue{v}))
                        } else if err := json.Unmarshal(inputValue, &[]json.RawMessage{}); err == nil {
                                lv := &stpb.ListValue{}
                                target.Field(0).Set(reflect.ValueOf(&stpb.Value_ListValue{lv}))
                                return u.unmarshalValue(reflect.ValueOf(lv).Elem(), inputValue, prop)
                        } else if err := json.Unmarshal(inputValue, &map[string]json.RawMessage{}); err == nil {
                                sv := &stpb.Struct{}
                                target.Field(0).Set(reflect.ValueOf(&stpb.Value_StructValue{sv}))
                                return u.unmarshalValue(reflect.ValueOf(sv).Elem(), inputValue, prop)
                        } else {
                                return fmt.Errorf("unrecognized type for Value %q", ivStr)
                        }
                        return nil
                }
        }

        // Handle enums, which have an underlying type of int32,
        // and may appear as strings.
        // The case of an enum appearing as a number is handled
        // at the bottom of this function.
        if inputValue[0] == '"' && prop != nil && prop.Enum != "" {
                vmap := proto.EnumValueMap(prop.Enum)
                // Don't need to do unquoting; valid enum names
                // are from a limited character set.
                s := inputValue[1 : len(inputValue)-1]
                n, ok := vmap[string(s)]
                if !ok {
                        return fmt.Errorf("unknown value %q for enum %s", s, prop.Enum)
                }
                if target.Kind() == reflect.Ptr { // proto2
                        target.Set(reflect.New(targetType.Elem()))
                        target = target.Elem()
                }
                target.SetInt(int64(n))
                return nil
        }

        // Handle nested messages.
        if targetType.Kind() == reflect.Struct {
                var jsonFields map[string]json.RawMessage
                if err := json.Unmarshal(inputValue, &jsonFields); err != nil {
                        return err
                }

                consumeField := func(prop *proto.Properties) (json.RawMessage, bool) {
                        // Be liberal in what names we accept; both orig_name and camelName are okay.
                        fieldNames := acceptedJSONFieldNames(prop)

                        vOrig, okOrig := jsonFields[fieldNames.orig]
                        vCamel, okCamel := jsonFields[fieldNames.camel]
                        if !okOrig && !okCamel {
                                return nil, false
                        }
                        // If, for some reason, both are present in the data, favour the camelName.
                        var raw json.RawMessage
                        if okOrig {
                                raw = vOrig
                                delete(jsonFields, fieldNames.orig)
                        }
                        if okCamel {
                                raw = vCamel
                                delete(jsonFields, fieldNames.camel)
                        }
                        return raw, true
                }

                sprops := proto.GetProperties(targetType)
                for i := 0; i < target.NumField(); i++ {
                        ft := target.Type().Field(i)
                        if strings.HasPrefix(ft.Name, "XXX_") {
                                continue
                        }

                        valueForField, ok := consumeField(sprops.Prop[i])
                        if !ok {
                                continue
                        }

                        if err := u.unmarshalValue(target.Field(i), valueForField, sprops.Prop[i]); err != nil {
                                return err
                        }
                }
                // Check for any oneof fields.
                if len(jsonFields) > 0 {
                        for _, oop := range sprops.OneofTypes {
                                raw, ok := consumeField(oop.Prop)
                                if !ok {
                                        continue
                                }
                                nv := reflect.New(oop.Type.Elem())
                                target.Field(oop.Field).Set(nv)
                                if err := u.unmarshalValue(nv.Elem().Field(0), raw, oop.Prop); err != nil {
                                        return err
                                }
                        }
                }
                // Handle proto2 extensions.
                if len(jsonFields) > 0 {
                        if ep, ok := target.Addr().Interface().(proto.Message); ok {
                                for _, ext := range proto.RegisteredExtensions(ep) {
                                        name := fmt.Sprintf("[%s]", ext.Name)
                                        raw, ok := jsonFields[name]
                                        if !ok {
                                                continue
                                        }
                                        delete(jsonFields, name)
                                        nv := reflect.New(reflect.TypeOf(ext.ExtensionType).Elem())
                                        if err := u.unmarshalValue(nv.Elem(), raw, nil); err != nil {
                                                return err
                                        }
                                        if err := proto.SetExtension(ep, ext, nv.Interface()); err != nil {
                                                return err
                                        }
                                }
                        }
                }
                if !u.AllowUnknownFields && len(jsonFields) > 0 {
                        // Pick any field to be the scapegoat.
                        var f string
                        for fname := range jsonFields {
                                f = fname
                                break
                        }
                        return fmt.Errorf("unknown field %q in %v", f, targetType)
                }
                return nil
        }

        // Handle arrays (which aren't encoded bytes)
        if targetType.Kind() == reflect.Slice && targetType.Elem().Kind() != reflect.Uint8 {
                var slc []json.RawMessage
                if err := json.Unmarshal(inputValue, &slc); err != nil {
                        return err
                }
                if slc != nil {
                        l := len(slc)
                        target.Set(reflect.MakeSlice(targetType, l, l))
                        for i := 0; i < l; i++ {
                                if err := u.unmarshalValue(target.Index(i), slc[i], prop); err != nil {
                                        return err
                                }
                        }
                }
                return nil
        }

        // Handle maps (whose keys are always strings)
        if targetType.Kind() == reflect.Map {
                var mp map[string]json.RawMessage
                if err := json.Unmarshal(inputValue, &mp); err != nil {
                        return err
                }
                if mp != nil {
                        target.Set(reflect.MakeMap(targetType))
                        var keyprop, valprop *proto.Properties
                        if prop != nil {
                                // These could still be nil if the protobuf metadata is broken somehow.
                                // TODO: This won't work because the fields are unexported.
                                // We should probably just reparse them.
                                //keyprop, valprop = prop.mkeyprop, prop.mvalprop
                        }
                        for ks, raw := range mp {
                                // Unmarshal map key. The core json library already decoded the key into a
                                // string, so we handle that specially. Other types were quoted post-serialization.
                                var k reflect.Value
                                if targetType.Key().Kind() == reflect.String {
                                        k = reflect.ValueOf(ks)
                                } else {
                                        k = reflect.New(targetType.Key()).Elem()
                                        if err := u.unmarshalValue(k, json.RawMessage(ks), keyprop); err != nil {
                                                return err
                                        }
                                }

                                // Unmarshal map value.
                                v := reflect.New(targetType.Elem()).Elem()
                                if err := u.unmarshalValue(v, raw, valprop); err != nil {
                                        return err
                                }
                                target.SetMapIndex(k, v)
                        }
                }
                return nil
        }

        // 64-bit integers can be encoded as strings. In this case we drop
        // the quotes and proceed as normal.
        isNum := targetType.Kind() == reflect.Int64 || targetType.Kind() == reflect.Uint64
        if isNum && strings.HasPrefix(string(inputValue), `"`) {
                inputValue = inputValue[1 : len(inputValue)-1]
        }

        // Non-finite numbers can be encoded as strings.
        isFloat := targetType.Kind() == reflect.Float32 || targetType.Kind() == reflect.Float64
        if isFloat {
                if num, ok := nonFinite[string(inputValue)]; ok {
                        target.SetFloat(num)
                        return nil
                }
        }

        // Use the encoding/json for parsing other value types.
        return json.Unmarshal(inputValue, target.Addr().Interface())
}

// jsonProperties returns parsed proto.Properties for the field and corrects JSONName attribute.
func jsonProperties(f reflect.StructField, origName bool) *proto.Properties {
        var prop proto.Properties
        prop.Init(f.Type, f.Name, f.Tag.Get("protobuf"), &f)
        if origName || prop.JSONName == "" {
                prop.JSONName = prop.OrigName
        }
        return &prop
}

type fieldNames struct {
        orig, camel string
}

func acceptedJSONFieldNames(prop *proto.Properties) fieldNames {
        opts := fieldNames{orig: prop.OrigName, camel: prop.OrigName}
        if prop.JSONName != "" {
                opts.camel = prop.JSONName
        }
        return opts
}

// Writer wrapper inspired by https://blog.golang.org/errors-are-values
type errWriter struct {
        writer io.Writer
        err    error
}

func (w *errWriter) write(str string) {
        if w.err != nil {
                return
        }
        _, w.err = w.writer.Write([]byte(str))
}

// Map fields may have key types of non-float scalars, strings and enums.
// The easiest way to sort them in some deterministic order is to use fmt.
// If this turns out to be inefficient we can always consider other options,
// such as doing a Schwartzian transform.
//
// Numeric keys are sorted in numeric order per
// https://developers.google.com/protocol-buffers/docs/proto#maps.
type mapKeys []reflect.Value

func (s mapKeys) Len() int      { return len(s) }
func (s mapKeys) Swap(i, j int) { s[i], s[j] = s[j], s[i] }
func (s mapKeys) Less(i, j int) bool {
        if k := s[i].Kind(); k == s[j].Kind() {
                switch k {
                case reflect.Int32, reflect.Int64:
                        return s[i].Int() < s[j].Int()
                case reflect.Uint32, reflect.Uint64:
                        return s[i].Uint() < s[j].Uint()
                }
        }
        return fmt.Sprint(s[i].Interface()) < fmt.Sprint(s[j].Interface())
}