Source file src/github.com/gogo/protobuf/proto/text.go

Documentation: github.com/gogo/protobuf/proto

     1  // Protocol Buffers for Go with Gadgets
     2  //
     3  // Copyright (c) 2013, The GoGo Authors. All rights reserved.
     4  // http://github.com/gogo/protobuf
     5  //
     6  // Go support for Protocol Buffers - Google's data interchange format
     7  //
     8  // Copyright 2010 The Go Authors.  All rights reserved.
     9  // https://github.com/golang/protobuf
    10  //
    11  // Redistribution and use in source and binary forms, with or without
    12  // modification, are permitted provided that the following conditions are
    13  // met:
    14  //
    15  //     * Redistributions of source code must retain the above copyright
    16  // notice, this list of conditions and the following disclaimer.
    17  //     * Redistributions in binary form must reproduce the above
    18  // copyright notice, this list of conditions and the following disclaimer
    19  // in the documentation and/or other materials provided with the
    20  // distribution.
    21  //     * Neither the name of Google Inc. nor the names of its
    22  // contributors may be used to endorse or promote products derived from
    23  // this software without specific prior written permission.
    24  //
    25  // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
    26  // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
    27  // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
    28  // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
    29  // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
    30  // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
    31  // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
    32  // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
    33  // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
    34  // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
    35  // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    36  
    37  package proto
    38  
    39  // Functions for writing the text protocol buffer format.
    40  
    41  import (
    42  	"bufio"
    43  	"bytes"
    44  	"encoding"
    45  	"errors"
    46  	"fmt"
    47  	"io"
    48  	"log"
    49  	"math"
    50  	"reflect"
    51  	"sort"
    52  	"strings"
    53  	"sync"
    54  	"time"
    55  )
    56  
    57  var (
    58  	newline         = []byte("\n")
    59  	spaces          = []byte("                                        ")
    60  	endBraceNewline = []byte("}\n")
    61  	backslashN      = []byte{'\\', 'n'}
    62  	backslashR      = []byte{'\\', 'r'}
    63  	backslashT      = []byte{'\\', 't'}
    64  	backslashDQ     = []byte{'\\', '"'}
    65  	backslashBS     = []byte{'\\', '\\'}
    66  	posInf          = []byte("inf")
    67  	negInf          = []byte("-inf")
    68  	nan             = []byte("nan")
    69  )
    70  
    71  type writer interface {
    72  	io.Writer
    73  	WriteByte(byte) error
    74  }
    75  
    76  // textWriter is an io.Writer that tracks its indentation level.
    77  type textWriter struct {
    78  	ind      int
    79  	complete bool // if the current position is a complete line
    80  	compact  bool // whether to write out as a one-liner
    81  	w        writer
    82  }
    83  
    84  func (w *textWriter) WriteString(s string) (n int, err error) {
    85  	if !strings.Contains(s, "\n") {
    86  		if !w.compact && w.complete {
    87  			w.writeIndent()
    88  		}
    89  		w.complete = false
    90  		return io.WriteString(w.w, s)
    91  	}
    92  	// WriteString is typically called without newlines, so this
    93  	// codepath and its copy are rare.  We copy to avoid
    94  	// duplicating all of Write's logic here.
    95  	return w.Write([]byte(s))
    96  }
    97  
    98  func (w *textWriter) Write(p []byte) (n int, err error) {
    99  	newlines := bytes.Count(p, newline)
   100  	if newlines == 0 {
   101  		if !w.compact && w.complete {
   102  			w.writeIndent()
   103  		}
   104  		n, err = w.w.Write(p)
   105  		w.complete = false
   106  		return n, err
   107  	}
   108  
   109  	frags := bytes.SplitN(p, newline, newlines+1)
   110  	if w.compact {
   111  		for i, frag := range frags {
   112  			if i > 0 {
   113  				if err := w.w.WriteByte(' '); err != nil {
   114  					return n, err
   115  				}
   116  				n++
   117  			}
   118  			nn, err := w.w.Write(frag)
   119  			n += nn
   120  			if err != nil {
   121  				return n, err
   122  			}
   123  		}
   124  		return n, nil
   125  	}
   126  
   127  	for i, frag := range frags {
   128  		if w.complete {
   129  			w.writeIndent()
   130  		}
   131  		nn, err := w.w.Write(frag)
   132  		n += nn
   133  		if err != nil {
   134  			return n, err
   135  		}
   136  		if i+1 < len(frags) {
   137  			if err := w.w.WriteByte('\n'); err != nil {
   138  				return n, err
   139  			}
   140  			n++
   141  		}
   142  	}
   143  	w.complete = len(frags[len(frags)-1]) == 0
   144  	return n, nil
   145  }
   146  
   147  func (w *textWriter) WriteByte(c byte) error {
   148  	if w.compact && c == '\n' {
   149  		c = ' '
   150  	}
   151  	if !w.compact && w.complete {
   152  		w.writeIndent()
   153  	}
   154  	err := w.w.WriteByte(c)
   155  	w.complete = c == '\n'
   156  	return err
   157  }
   158  
   159  func (w *textWriter) indent() { w.ind++ }
   160  
   161  func (w *textWriter) unindent() {
   162  	if w.ind == 0 {
   163  		log.Print("proto: textWriter unindented too far")
   164  		return
   165  	}
   166  	w.ind--
   167  }
   168  
   169  func writeName(w *textWriter, props *Properties) error {
   170  	if _, err := w.WriteString(props.OrigName); err != nil {
   171  		return err
   172  	}
   173  	if props.Wire != "group" {
   174  		return w.WriteByte(':')
   175  	}
   176  	return nil
   177  }
   178  
   179  func requiresQuotes(u string) bool {
   180  	// When type URL contains any characters except [0-9A-Za-z./\-]*, it must be quoted.
   181  	for _, ch := range u {
   182  		switch {
   183  		case ch == '.' || ch == '/' || ch == '_':
   184  			continue
   185  		case '0' <= ch && ch <= '9':
   186  			continue
   187  		case 'A' <= ch && ch <= 'Z':
   188  			continue
   189  		case 'a' <= ch && ch <= 'z':
   190  			continue
   191  		default:
   192  			return true
   193  		}
   194  	}
   195  	return false
   196  }
   197  
   198  // isAny reports whether sv is a google.protobuf.Any message
   199  func isAny(sv reflect.Value) bool {
   200  	type wkt interface {
   201  		XXX_WellKnownType() string
   202  	}
   203  	t, ok := sv.Addr().Interface().(wkt)
   204  	return ok && t.XXX_WellKnownType() == "Any"
   205  }
   206  
   207  // writeProto3Any writes an expanded google.protobuf.Any message.
   208  //
   209  // It returns (false, nil) if sv value can't be unmarshaled (e.g. because
   210  // required messages are not linked in).
   211  //
   212  // It returns (true, error) when sv was written in expanded format or an error
   213  // was encountered.
   214  func (tm *TextMarshaler) writeProto3Any(w *textWriter, sv reflect.Value) (bool, error) {
   215  	turl := sv.FieldByName("TypeUrl")
   216  	val := sv.FieldByName("Value")
   217  	if !turl.IsValid() || !val.IsValid() {
   218  		return true, errors.New("proto: invalid google.protobuf.Any message")
   219  	}
   220  
   221  	b, ok := val.Interface().([]byte)
   222  	if !ok {
   223  		return true, errors.New("proto: invalid google.protobuf.Any message")
   224  	}
   225  
   226  	parts := strings.Split(turl.String(), "/")
   227  	mt := MessageType(parts[len(parts)-1])
   228  	if mt == nil {
   229  		return false, nil
   230  	}
   231  	m := reflect.New(mt.Elem())
   232  	if err := Unmarshal(b, m.Interface().(Message)); err != nil {
   233  		return false, nil
   234  	}
   235  	w.Write([]byte("["))
   236  	u := turl.String()
   237  	if requiresQuotes(u) {
   238  		writeString(w, u)
   239  	} else {
   240  		w.Write([]byte(u))
   241  	}
   242  	if w.compact {
   243  		w.Write([]byte("]:<"))
   244  	} else {
   245  		w.Write([]byte("]: <\n"))
   246  		w.ind++
   247  	}
   248  	if err := tm.writeStruct(w, m.Elem()); err != nil {
   249  		return true, err
   250  	}
   251  	if w.compact {
   252  		w.Write([]byte("> "))
   253  	} else {
   254  		w.ind--
   255  		w.Write([]byte(">\n"))
   256  	}
   257  	return true, nil
   258  }
   259  
   260  func (tm *TextMarshaler) writeStruct(w *textWriter, sv reflect.Value) error {
   261  	if tm.ExpandAny && isAny(sv) {
   262  		if canExpand, err := tm.writeProto3Any(w, sv); canExpand {
   263  			return err
   264  		}
   265  	}
   266  	st := sv.Type()
   267  	sprops := GetProperties(st)
   268  	for i := 0; i < sv.NumField(); i++ {
   269  		fv := sv.Field(i)
   270  		props := sprops.Prop[i]
   271  		name := st.Field(i).Name
   272  
   273  		if name == "XXX_NoUnkeyedLiteral" {
   274  			continue
   275  		}
   276  
   277  		if strings.HasPrefix(name, "XXX_") {
   278  			// There are two XXX_ fields:
   279  			//   XXX_unrecognized []byte
   280  			//   XXX_extensions   map[int32]proto.Extension
   281  			// The first is handled here;
   282  			// the second is handled at the bottom of this function.
   283  			if name == "XXX_unrecognized" && !fv.IsNil() {
   284  				if err := writeUnknownStruct(w, fv.Interface().([]byte)); err != nil {
   285  					return err
   286  				}
   287  			}
   288  			continue
   289  		}
   290  		if fv.Kind() == reflect.Ptr && fv.IsNil() {
   291  			// Field not filled in. This could be an optional field or
   292  			// a required field that wasn't filled in. Either way, there
   293  			// isn't anything we can show for it.
   294  			continue
   295  		}
   296  		if fv.Kind() == reflect.Slice && fv.IsNil() {
   297  			// Repeated field that is empty, or a bytes field that is unused.
   298  			continue
   299  		}
   300  
   301  		if props.Repeated && fv.Kind() == reflect.Slice {
   302  			// Repeated field.
   303  			for j := 0; j < fv.Len(); j++ {
   304  				if err := writeName(w, props); err != nil {
   305  					return err
   306  				}
   307  				if !w.compact {
   308  					if err := w.WriteByte(' '); err != nil {
   309  						return err
   310  					}
   311  				}
   312  				v := fv.Index(j)
   313  				if v.Kind() == reflect.Ptr && v.IsNil() {
   314  					// A nil message in a repeated field is not valid,
   315  					// but we can handle that more gracefully than panicking.
   316  					if _, err := w.Write([]byte("<nil>\n")); err != nil {
   317  						return err
   318  					}
   319  					continue
   320  				}
   321  				if len(props.Enum) > 0 {
   322  					if err := tm.writeEnum(w, v, props); err != nil {
   323  						return err
   324  					}
   325  				} else if err := tm.writeAny(w, v, props); err != nil {
   326  					return err
   327  				}
   328  				if err := w.WriteByte('\n'); err != nil {
   329  					return err
   330  				}
   331  			}
   332  			continue
   333  		}
   334  		if fv.Kind() == reflect.Map {
   335  			// Map fields are rendered as a repeated struct with key/value fields.
   336  			keys := fv.MapKeys()
   337  			sort.Sort(mapKeys(keys))
   338  			for _, key := range keys {
   339  				val := fv.MapIndex(key)
   340  				if err := writeName(w, props); err != nil {
   341  					return err
   342  				}
   343  				if !w.compact {
   344  					if err := w.WriteByte(' '); err != nil {
   345  						return err
   346  					}
   347  				}
   348  				// open struct
   349  				if err := w.WriteByte('<'); err != nil {
   350  					return err
   351  				}
   352  				if !w.compact {
   353  					if err := w.WriteByte('\n'); err != nil {
   354  						return err
   355  					}
   356  				}
   357  				w.indent()
   358  				// key
   359  				if _, err := w.WriteString("key:"); err != nil {
   360  					return err
   361  				}
   362  				if !w.compact {
   363  					if err := w.WriteByte(' '); err != nil {
   364  						return err
   365  					}
   366  				}
   367  				if err := tm.writeAny(w, key, props.MapKeyProp); err != nil {
   368  					return err
   369  				}
   370  				if err := w.WriteByte('\n'); err != nil {
   371  					return err
   372  				}
   373  				// nil values aren't legal, but we can avoid panicking because of them.
   374  				if val.Kind() != reflect.Ptr || !val.IsNil() {
   375  					// value
   376  					if _, err := w.WriteString("value:"); err != nil {
   377  						return err
   378  					}
   379  					if !w.compact {
   380  						if err := w.WriteByte(' '); err != nil {
   381  							return err
   382  						}
   383  					}
   384  					if err := tm.writeAny(w, val, props.MapValProp); err != nil {
   385  						return err
   386  					}
   387  					if err := w.WriteByte('\n'); err != nil {
   388  						return err
   389  					}
   390  				}
   391  				// close struct
   392  				w.unindent()
   393  				if err := w.WriteByte('>'); err != nil {
   394  					return err
   395  				}
   396  				if err := w.WriteByte('\n'); err != nil {
   397  					return err
   398  				}
   399  			}
   400  			continue
   401  		}
   402  		if props.proto3 && fv.Kind() == reflect.Slice && fv.Len() == 0 {
   403  			// empty bytes field
   404  			continue
   405  		}
   406  		if props.proto3 && fv.Kind() != reflect.Ptr && fv.Kind() != reflect.Slice {
   407  			// proto3 non-repeated scalar field; skip if zero value
   408  			if isProto3Zero(fv) {
   409  				continue
   410  			}
   411  		}
   412  
   413  		if fv.Kind() == reflect.Interface {
   414  			// Check if it is a oneof.
   415  			if st.Field(i).Tag.Get("protobuf_oneof") != "" {
   416  				// fv is nil, or holds a pointer to generated struct.
   417  				// That generated struct has exactly one field,
   418  				// which has a protobuf struct tag.
   419  				if fv.IsNil() {
   420  					continue
   421  				}
   422  				inner := fv.Elem().Elem() // interface -> *T -> T
   423  				tag := inner.Type().Field(0).Tag.Get("protobuf")
   424  				props = new(Properties) // Overwrite the outer props var, but not its pointee.
   425  				props.Parse(tag)
   426  				// Write the value in the oneof, not the oneof itself.
   427  				fv = inner.Field(0)
   428  
   429  				// Special case to cope with malformed messages gracefully:
   430  				// If the value in the oneof is a nil pointer, don't panic
   431  				// in writeAny.
   432  				if fv.Kind() == reflect.Ptr && fv.IsNil() {
   433  					// Use errors.New so writeAny won't render quotes.
   434  					msg := errors.New("/* nil */")
   435  					fv = reflect.ValueOf(&msg).Elem()
   436  				}
   437  			}
   438  		}
   439  
   440  		if err := writeName(w, props); err != nil {
   441  			return err
   442  		}
   443  		if !w.compact {
   444  			if err := w.WriteByte(' '); err != nil {
   445  				return err
   446  			}
   447  		}
   448  
   449  		if len(props.Enum) > 0 {
   450  			if err := tm.writeEnum(w, fv, props); err != nil {
   451  				return err
   452  			}
   453  		} else if err := tm.writeAny(w, fv, props); err != nil {
   454  			return err
   455  		}
   456  
   457  		if err := w.WriteByte('\n'); err != nil {
   458  			return err
   459  		}
   460  	}
   461  
   462  	// Extensions (the XXX_extensions field).
   463  	pv := sv
   464  	if pv.CanAddr() {
   465  		pv = sv.Addr()
   466  	} else {
   467  		pv = reflect.New(sv.Type())
   468  		pv.Elem().Set(sv)
   469  	}
   470  	if _, err := extendable(pv.Interface()); err == nil {
   471  		if err := tm.writeExtensions(w, pv); err != nil {
   472  			return err
   473  		}
   474  	}
   475  
   476  	return nil
   477  }
   478  
   479  var textMarshalerType = reflect.TypeOf((*encoding.TextMarshaler)(nil)).Elem()
   480  
   481  // writeAny writes an arbitrary field.
   482  func (tm *TextMarshaler) writeAny(w *textWriter, v reflect.Value, props *Properties) error {
   483  	v = reflect.Indirect(v)
   484  
   485  	if props != nil {
   486  		if len(props.CustomType) > 0 {
   487  			custom, ok := v.Interface().(Marshaler)
   488  			if ok {
   489  				data, err := custom.Marshal()
   490  				if err != nil {
   491  					return err
   492  				}
   493  				if err := writeString(w, string(data)); err != nil {
   494  					return err
   495  				}
   496  				return nil
   497  			}
   498  		} else if len(props.CastType) > 0 {
   499  			if _, ok := v.Interface().(interface {
   500  				String() string
   501  			}); ok {
   502  				switch v.Kind() {
   503  				case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64,
   504  					reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
   505  					_, err := fmt.Fprintf(w, "%d", v.Interface())
   506  					return err
   507  				}
   508  			}
   509  		} else if props.StdTime {
   510  			t, ok := v.Interface().(time.Time)
   511  			if !ok {
   512  				return fmt.Errorf("stdtime is not time.Time, but %T", v.Interface())
   513  			}
   514  			tproto, err := timestampProto(t)
   515  			if err != nil {
   516  				return err
   517  			}
   518  			propsCopy := *props // Make a copy so that this is goroutine-safe
   519  			propsCopy.StdTime = false
   520  			err = tm.writeAny(w, reflect.ValueOf(tproto), &propsCopy)
   521  			return err
   522  		} else if props.StdDuration {
   523  			d, ok := v.Interface().(time.Duration)
   524  			if !ok {
   525  				return fmt.Errorf("stdtime is not time.Duration, but %T", v.Interface())
   526  			}
   527  			dproto := durationProto(d)
   528  			propsCopy := *props // Make a copy so that this is goroutine-safe
   529  			propsCopy.StdDuration = false
   530  			err := tm.writeAny(w, reflect.ValueOf(dproto), &propsCopy)
   531  			return err
   532  		}
   533  	}
   534  
   535  	// Floats have special cases.
   536  	if v.Kind() == reflect.Float32 || v.Kind() == reflect.Float64 {
   537  		x := v.Float()
   538  		var b []byte
   539  		switch {
   540  		case math.IsInf(x, 1):
   541  			b = posInf
   542  		case math.IsInf(x, -1):
   543  			b = negInf
   544  		case math.IsNaN(x):
   545  			b = nan
   546  		}
   547  		if b != nil {
   548  			_, err := w.Write(b)
   549  			return err
   550  		}
   551  		// Other values are handled below.
   552  	}
   553  
   554  	// We don't attempt to serialise every possible value type; only those
   555  	// that can occur in protocol buffers.
   556  	switch v.Kind() {
   557  	case reflect.Slice:
   558  		// Should only be a []byte; repeated fields are handled in writeStruct.
   559  		if err := writeString(w, string(v.Bytes())); err != nil {
   560  			return err
   561  		}
   562  	case reflect.String:
   563  		if err := writeString(w, v.String()); err != nil {
   564  			return err
   565  		}
   566  	case reflect.Struct:
   567  		// Required/optional group/message.
   568  		var bra, ket byte = '<', '>'
   569  		if props != nil && props.Wire == "group" {
   570  			bra, ket = '{', '}'
   571  		}
   572  		if err := w.WriteByte(bra); err != nil {
   573  			return err
   574  		}
   575  		if !w.compact {
   576  			if err := w.WriteByte('\n'); err != nil {
   577  				return err
   578  			}
   579  		}
   580  		w.indent()
   581  		if v.CanAddr() {
   582  			// Calling v.Interface on a struct causes the reflect package to
   583  			// copy the entire struct. This is racy with the new Marshaler
   584  			// since we atomically update the XXX_sizecache.
   585  			//
   586  			// Thus, we retrieve a pointer to the struct if possible to avoid
   587  			// a race since v.Interface on the pointer doesn't copy the struct.
   588  			//
   589  			// If v is not addressable, then we are not worried about a race
   590  			// since it implies that the binary Marshaler cannot possibly be
   591  			// mutating this value.
   592  			v = v.Addr()
   593  		}
   594  		if v.Type().Implements(textMarshalerType) {
   595  			text, err := v.Interface().(encoding.TextMarshaler).MarshalText()
   596  			if err != nil {
   597  				return err
   598  			}
   599  			if _, err = w.Write(text); err != nil {
   600  				return err
   601  			}
   602  		} else {
   603  			if v.Kind() == reflect.Ptr {
   604  				v = v.Elem()
   605  			}
   606  			if err := tm.writeStruct(w, v); err != nil {
   607  				return err
   608  			}
   609  		}
   610  		w.unindent()
   611  		if err := w.WriteByte(ket); err != nil {
   612  			return err
   613  		}
   614  	default:
   615  		_, err := fmt.Fprint(w, v.Interface())
   616  		return err
   617  	}
   618  	return nil
   619  }
   620  
   621  // equivalent to C's isprint.
   622  func isprint(c byte) bool {
   623  	return c >= 0x20 && c < 0x7f
   624  }
   625  
   626  // writeString writes a string in the protocol buffer text format.
   627  // It is similar to strconv.Quote except we don't use Go escape sequences,
   628  // we treat the string as a byte sequence, and we use octal escapes.
   629  // These differences are to maintain interoperability with the other
   630  // languages' implementations of the text format.
   631  func writeString(w *textWriter, s string) error {
   632  	// use WriteByte here to get any needed indent
   633  	if err := w.WriteByte('"'); err != nil {
   634  		return err
   635  	}
   636  	// Loop over the bytes, not the runes.
   637  	for i := 0; i < len(s); i++ {
   638  		var err error
   639  		// Divergence from C++: we don't escape apostrophes.
   640  		// There's no need to escape them, and the C++ parser
   641  		// copes with a naked apostrophe.
   642  		switch c := s[i]; c {
   643  		case '\n':
   644  			_, err = w.w.Write(backslashN)
   645  		case '\r':
   646  			_, err = w.w.Write(backslashR)
   647  		case '\t':
   648  			_, err = w.w.Write(backslashT)
   649  		case '"':
   650  			_, err = w.w.Write(backslashDQ)
   651  		case '\\':
   652  			_, err = w.w.Write(backslashBS)
   653  		default:
   654  			if isprint(c) {
   655  				err = w.w.WriteByte(c)
   656  			} else {
   657  				_, err = fmt.Fprintf(w.w, "\\%03o", c)
   658  			}
   659  		}
   660  		if err != nil {
   661  			return err
   662  		}
   663  	}
   664  	return w.WriteByte('"')
   665  }
   666  
   667  func writeUnknownStruct(w *textWriter, data []byte) (err error) {
   668  	if !w.compact {
   669  		if _, err := fmt.Fprintf(w, "/* %d unknown bytes */\n", len(data)); err != nil {
   670  			return err
   671  		}
   672  	}
   673  	b := NewBuffer(data)
   674  	for b.index < len(b.buf) {
   675  		x, err := b.DecodeVarint()
   676  		if err != nil {
   677  			_, ferr := fmt.Fprintf(w, "/* %v */\n", err)
   678  			return ferr
   679  		}
   680  		wire, tag := x&7, x>>3
   681  		if wire == WireEndGroup {
   682  			w.unindent()
   683  			if _, werr := w.Write(endBraceNewline); werr != nil {
   684  				return werr
   685  			}
   686  			continue
   687  		}
   688  		if _, ferr := fmt.Fprint(w, tag); ferr != nil {
   689  			return ferr
   690  		}
   691  		if wire != WireStartGroup {
   692  			if err = w.WriteByte(':'); err != nil {
   693  				return err
   694  			}
   695  		}
   696  		if !w.compact || wire == WireStartGroup {
   697  			if err = w.WriteByte(' '); err != nil {
   698  				return err
   699  			}
   700  		}
   701  		switch wire {
   702  		case WireBytes:
   703  			buf, e := b.DecodeRawBytes(false)
   704  			if e == nil {
   705  				_, err = fmt.Fprintf(w, "%q", buf)
   706  			} else {
   707  				_, err = fmt.Fprintf(w, "/* %v */", e)
   708  			}
   709  		case WireFixed32:
   710  			x, err = b.DecodeFixed32()
   711  			err = writeUnknownInt(w, x, err)
   712  		case WireFixed64:
   713  			x, err = b.DecodeFixed64()
   714  			err = writeUnknownInt(w, x, err)
   715  		case WireStartGroup:
   716  			err = w.WriteByte('{')
   717  			w.indent()
   718  		case WireVarint:
   719  			x, err = b.DecodeVarint()
   720  			err = writeUnknownInt(w, x, err)
   721  		default:
   722  			_, err = fmt.Fprintf(w, "/* unknown wire type %d */", wire)
   723  		}
   724  		if err != nil {
   725  			return err
   726  		}
   727  		if err := w.WriteByte('\n'); err != nil {
   728  			return err
   729  		}
   730  	}
   731  	return nil
   732  }
   733  
   734  func writeUnknownInt(w *textWriter, x uint64, err error) error {
   735  	if err == nil {
   736  		_, err = fmt.Fprint(w, x)
   737  	} else {
   738  		_, err = fmt.Fprintf(w, "/* %v */", err)
   739  	}
   740  	return err
   741  }
   742  
   743  type int32Slice []int32
   744  
   745  func (s int32Slice) Len() int           { return len(s) }
   746  func (s int32Slice) Less(i, j int) bool { return s[i] < s[j] }
   747  func (s int32Slice) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }
   748  
   749  // writeExtensions writes all the extensions in pv.
   750  // pv is assumed to be a pointer to a protocol message struct that is extendable.
   751  func (tm *TextMarshaler) writeExtensions(w *textWriter, pv reflect.Value) error {
   752  	emap := extensionMaps[pv.Type().Elem()]
   753  	e := pv.Interface().(Message)
   754  
   755  	var m map[int32]Extension
   756  	var mu sync.Locker
   757  	if em, ok := e.(extensionsBytes); ok {
   758  		eb := em.GetExtensions()
   759  		var err error
   760  		m, err = BytesToExtensionsMap(*eb)
   761  		if err != nil {
   762  			return err
   763  		}
   764  		mu = notLocker{}
   765  	} else if _, ok := e.(extendableProto); ok {
   766  		ep, _ := extendable(e)
   767  		m, mu = ep.extensionsRead()
   768  		if m == nil {
   769  			return nil
   770  		}
   771  	}
   772  
   773  	// Order the extensions by ID.
   774  	// This isn't strictly necessary, but it will give us
   775  	// canonical output, which will also make testing easier.
   776  
   777  	mu.Lock()
   778  	ids := make([]int32, 0, len(m))
   779  	for id := range m {
   780  		ids = append(ids, id)
   781  	}
   782  	sort.Sort(int32Slice(ids))
   783  	mu.Unlock()
   784  
   785  	for _, extNum := range ids {
   786  		ext := m[extNum]
   787  		var desc *ExtensionDesc
   788  		if emap != nil {
   789  			desc = emap[extNum]
   790  		}
   791  		if desc == nil {
   792  			// Unknown extension.
   793  			if err := writeUnknownStruct(w, ext.enc); err != nil {
   794  				return err
   795  			}
   796  			continue
   797  		}
   798  
   799  		pb, err := GetExtension(e, desc)
   800  		if err != nil {
   801  			return fmt.Errorf("failed getting extension: %v", err)
   802  		}
   803  
   804  		// Repeated extensions will appear as a slice.
   805  		if !desc.repeated() {
   806  			if err := tm.writeExtension(w, desc.Name, pb); err != nil {
   807  				return err
   808  			}
   809  		} else {
   810  			v := reflect.ValueOf(pb)
   811  			for i := 0; i < v.Len(); i++ {
   812  				if err := tm.writeExtension(w, desc.Name, v.Index(i).Interface()); err != nil {
   813  					return err
   814  				}
   815  			}
   816  		}
   817  	}
   818  	return nil
   819  }
   820  
   821  func (tm *TextMarshaler) writeExtension(w *textWriter, name string, pb interface{}) error {
   822  	if _, err := fmt.Fprintf(w, "[%s]:", name); err != nil {
   823  		return err
   824  	}
   825  	if !w.compact {
   826  		if err := w.WriteByte(' '); err != nil {
   827  			return err
   828  		}
   829  	}
   830  	if err := tm.writeAny(w, reflect.ValueOf(pb), nil); err != nil {
   831  		return err
   832  	}
   833  	if err := w.WriteByte('\n'); err != nil {
   834  		return err
   835  	}
   836  	return nil
   837  }
   838  
   839  func (w *textWriter) writeIndent() {
   840  	if !w.complete {
   841  		return
   842  	}
   843  	remain := w.ind * 2
   844  	for remain > 0 {
   845  		n := remain
   846  		if n > len(spaces) {
   847  			n = len(spaces)
   848  		}
   849  		w.w.Write(spaces[:n])
   850  		remain -= n
   851  	}
   852  	w.complete = false
   853  }
   854  
   855  // TextMarshaler is a configurable text format marshaler.
   856  type TextMarshaler struct {
   857  	Compact   bool // use compact text format (one line).
   858  	ExpandAny bool // expand google.protobuf.Any messages of known types
   859  }
   860  
   861  // Marshal writes a given protocol buffer in text format.
   862  // The only errors returned are from w.
   863  func (tm *TextMarshaler) Marshal(w io.Writer, pb Message) error {
   864  	val := reflect.ValueOf(pb)
   865  	if pb == nil || val.IsNil() {
   866  		w.Write([]byte("<nil>"))
   867  		return nil
   868  	}
   869  	var bw *bufio.Writer
   870  	ww, ok := w.(writer)
   871  	if !ok {
   872  		bw = bufio.NewWriter(w)
   873  		ww = bw
   874  	}
   875  	aw := &textWriter{
   876  		w:        ww,
   877  		complete: true,
   878  		compact:  tm.Compact,
   879  	}
   880  
   881  	if etm, ok := pb.(encoding.TextMarshaler); ok {
   882  		text, err := etm.MarshalText()
   883  		if err != nil {
   884  			return err
   885  		}
   886  		if _, err = aw.Write(text); err != nil {
   887  			return err
   888  		}
   889  		if bw != nil {
   890  			return bw.Flush()
   891  		}
   892  		return nil
   893  	}
   894  	// Dereference the received pointer so we don't have outer < and >.
   895  	v := reflect.Indirect(val)
   896  	if err := tm.writeStruct(aw, v); err != nil {
   897  		return err
   898  	}
   899  	if bw != nil {
   900  		return bw.Flush()
   901  	}
   902  	return nil
   903  }
   904  
   905  // Text is the same as Marshal, but returns the string directly.
   906  func (tm *TextMarshaler) Text(pb Message) string {
   907  	var buf bytes.Buffer
   908  	tm.Marshal(&buf, pb)
   909  	return buf.String()
   910  }
   911  
   912  var (
   913  	defaultTextMarshaler = TextMarshaler{}
   914  	compactTextMarshaler = TextMarshaler{Compact: true}
   915  )
   916  
   917  // TODO: consider removing some of the Marshal functions below.
   918  
   919  // MarshalText writes a given protocol buffer in text format.
   920  // The only errors returned are from w.
   921  func MarshalText(w io.Writer, pb Message) error { return defaultTextMarshaler.Marshal(w, pb) }
   922  
   923  // MarshalTextString is the same as MarshalText, but returns the string directly.
   924  func MarshalTextString(pb Message) string { return defaultTextMarshaler.Text(pb) }
   925  
   926  // CompactText writes a given protocol buffer in compact text format (one line).
   927  func CompactText(w io.Writer, pb Message) error { return compactTextMarshaler.Marshal(w, pb) }
   928  
   929  // CompactTextString is the same as CompactText, but returns the string directly.
   930  func CompactTextString(pb Message) string { return compactTextMarshaler.Text(pb) }
   931  

View as plain text