Source file src/github.com/golang/protobuf/proto/text_encode.go

Documentation: github.com/golang/protobuf/proto

     1  // Copyright 2010 The Go Authors. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  package proto
     6  
     7  import (
     8  	"bytes"
     9  	"encoding"
    10  	"fmt"
    11  	"io"
    12  	"math"
    13  	"sort"
    14  	"strings"
    15  
    16  	"google.golang.org/protobuf/encoding/prototext"
    17  	"google.golang.org/protobuf/encoding/protowire"
    18  	"google.golang.org/protobuf/proto"
    19  	"google.golang.org/protobuf/reflect/protoreflect"
    20  	"google.golang.org/protobuf/reflect/protoregistry"
    21  )
    22  
    23  const wrapTextMarshalV2 = false
    24  
    25  // TextMarshaler is a configurable text format marshaler.
    26  type TextMarshaler struct {
    27  	Compact   bool // use compact text format (one line)
    28  	ExpandAny bool // expand google.protobuf.Any messages of known types
    29  }
    30  
    31  // Marshal writes the proto text format of m to w.
    32  func (tm *TextMarshaler) Marshal(w io.Writer, m Message) error {
    33  	b, err := tm.marshal(m)
    34  	if len(b) > 0 {
    35  		if _, err := w.Write(b); err != nil {
    36  			return err
    37  		}
    38  	}
    39  	return err
    40  }
    41  
    42  // Text returns a proto text formatted string of m.
    43  func (tm *TextMarshaler) Text(m Message) string {
    44  	b, _ := tm.marshal(m)
    45  	return string(b)
    46  }
    47  
    48  func (tm *TextMarshaler) marshal(m Message) ([]byte, error) {
    49  	mr := MessageReflect(m)
    50  	if mr == nil || !mr.IsValid() {
    51  		return []byte("<nil>"), nil
    52  	}
    53  
    54  	if wrapTextMarshalV2 {
    55  		if m, ok := m.(encoding.TextMarshaler); ok {
    56  			return m.MarshalText()
    57  		}
    58  
    59  		opts := prototext.MarshalOptions{
    60  			AllowPartial: true,
    61  			EmitUnknown:  true,
    62  		}
    63  		if !tm.Compact {
    64  			opts.Indent = "  "
    65  		}
    66  		if !tm.ExpandAny {
    67  			opts.Resolver = (*protoregistry.Types)(nil)
    68  		}
    69  		return opts.Marshal(mr.Interface())
    70  	} else {
    71  		w := &textWriter{
    72  			compact:   tm.Compact,
    73  			expandAny: tm.ExpandAny,
    74  			complete:  true,
    75  		}
    76  
    77  		if m, ok := m.(encoding.TextMarshaler); ok {
    78  			b, err := m.MarshalText()
    79  			if err != nil {
    80  				return nil, err
    81  			}
    82  			w.Write(b)
    83  			return w.buf, nil
    84  		}
    85  
    86  		err := w.writeMessage(mr)
    87  		return w.buf, err
    88  	}
    89  }
    90  
    91  var (
    92  	defaultTextMarshaler = TextMarshaler{}
    93  	compactTextMarshaler = TextMarshaler{Compact: true}
    94  )
    95  
    96  // MarshalText writes the proto text format of m to w.
    97  func MarshalText(w io.Writer, m Message) error { return defaultTextMarshaler.Marshal(w, m) }
    98  
    99  // MarshalTextString returns a proto text formatted string of m.
   100  func MarshalTextString(m Message) string { return defaultTextMarshaler.Text(m) }
   101  
   102  // CompactText writes the compact proto text format of m to w.
   103  func CompactText(w io.Writer, m Message) error { return compactTextMarshaler.Marshal(w, m) }
   104  
   105  // CompactTextString returns a compact proto text formatted string of m.
   106  func CompactTextString(m Message) string { return compactTextMarshaler.Text(m) }
   107  
   108  var (
   109  	newline         = []byte("\n")
   110  	endBraceNewline = []byte("}\n")
   111  	posInf          = []byte("inf")
   112  	negInf          = []byte("-inf")
   113  	nan             = []byte("nan")
   114  )
   115  
   116  // textWriter is an io.Writer that tracks its indentation level.
   117  type textWriter struct {
   118  	compact   bool // same as TextMarshaler.Compact
   119  	expandAny bool // same as TextMarshaler.ExpandAny
   120  	complete  bool // whether the current position is a complete line
   121  	indent    int  // indentation level; never negative
   122  	buf       []byte
   123  }
   124  
   125  func (w *textWriter) Write(p []byte) (n int, _ error) {
   126  	newlines := bytes.Count(p, newline)
   127  	if newlines == 0 {
   128  		if !w.compact && w.complete {
   129  			w.writeIndent()
   130  		}
   131  		w.buf = append(w.buf, p...)
   132  		w.complete = false
   133  		return len(p), nil
   134  	}
   135  
   136  	frags := bytes.SplitN(p, newline, newlines+1)
   137  	if w.compact {
   138  		for i, frag := range frags {
   139  			if i > 0 {
   140  				w.buf = append(w.buf, ' ')
   141  				n++
   142  			}
   143  			w.buf = append(w.buf, frag...)
   144  			n += len(frag)
   145  		}
   146  		return n, nil
   147  	}
   148  
   149  	for i, frag := range frags {
   150  		if w.complete {
   151  			w.writeIndent()
   152  		}
   153  		w.buf = append(w.buf, frag...)
   154  		n += len(frag)
   155  		if i+1 < len(frags) {
   156  			w.buf = append(w.buf, '\n')
   157  			n++
   158  		}
   159  	}
   160  	w.complete = len(frags[len(frags)-1]) == 0
   161  	return n, nil
   162  }
   163  
   164  func (w *textWriter) WriteByte(c byte) error {
   165  	if w.compact && c == '\n' {
   166  		c = ' '
   167  	}
   168  	if !w.compact && w.complete {
   169  		w.writeIndent()
   170  	}
   171  	w.buf = append(w.buf, c)
   172  	w.complete = c == '\n'
   173  	return nil
   174  }
   175  
   176  func (w *textWriter) writeName(fd protoreflect.FieldDescriptor) {
   177  	if !w.compact && w.complete {
   178  		w.writeIndent()
   179  	}
   180  	w.complete = false
   181  
   182  	if fd.Kind() != protoreflect.GroupKind {
   183  		w.buf = append(w.buf, fd.Name()...)
   184  		w.WriteByte(':')
   185  	} else {
   186  		// Use message type name for group field name.
   187  		w.buf = append(w.buf, fd.Message().Name()...)
   188  	}
   189  
   190  	if !w.compact {
   191  		w.WriteByte(' ')
   192  	}
   193  }
   194  
   195  func requiresQuotes(u string) bool {
   196  	// When type URL contains any characters except [0-9A-Za-z./\-]*, it must be quoted.
   197  	for _, ch := range u {
   198  		switch {
   199  		case ch == '.' || ch == '/' || ch == '_':
   200  			continue
   201  		case '0' <= ch && ch <= '9':
   202  			continue
   203  		case 'A' <= ch && ch <= 'Z':
   204  			continue
   205  		case 'a' <= ch && ch <= 'z':
   206  			continue
   207  		default:
   208  			return true
   209  		}
   210  	}
   211  	return false
   212  }
   213  
   214  // writeProto3Any writes an expanded google.protobuf.Any message.
   215  //
   216  // It returns (false, nil) if sv value can't be unmarshaled (e.g. because
   217  // required messages are not linked in).
   218  //
   219  // It returns (true, error) when sv was written in expanded format or an error
   220  // was encountered.
   221  func (w *textWriter) writeProto3Any(m protoreflect.Message) (bool, error) {
   222  	md := m.Descriptor()
   223  	fdURL := md.Fields().ByName("type_url")
   224  	fdVal := md.Fields().ByName("value")
   225  
   226  	url := m.Get(fdURL).String()
   227  	mt, err := protoregistry.GlobalTypes.FindMessageByURL(url)
   228  	if err != nil {
   229  		return false, nil
   230  	}
   231  
   232  	b := m.Get(fdVal).Bytes()
   233  	m2 := mt.New()
   234  	if err := proto.Unmarshal(b, m2.Interface()); err != nil {
   235  		return false, nil
   236  	}
   237  	w.Write([]byte("["))
   238  	if requiresQuotes(url) {
   239  		w.writeQuotedString(url)
   240  	} else {
   241  		w.Write([]byte(url))
   242  	}
   243  	if w.compact {
   244  		w.Write([]byte("]:<"))
   245  	} else {
   246  		w.Write([]byte("]: <\n"))
   247  		w.indent++
   248  	}
   249  	if err := w.writeMessage(m2); err != nil {
   250  		return true, err
   251  	}
   252  	if w.compact {
   253  		w.Write([]byte("> "))
   254  	} else {
   255  		w.indent--
   256  		w.Write([]byte(">\n"))
   257  	}
   258  	return true, nil
   259  }
   260  
   261  func (w *textWriter) writeMessage(m protoreflect.Message) error {
   262  	md := m.Descriptor()
   263  	if w.expandAny && md.FullName() == "google.protobuf.Any" {
   264  		if canExpand, err := w.writeProto3Any(m); canExpand {
   265  			return err
   266  		}
   267  	}
   268  
   269  	fds := md.Fields()
   270  	for i := 0; i < fds.Len(); {
   271  		fd := fds.Get(i)
   272  		if od := fd.ContainingOneof(); od != nil {
   273  			fd = m.WhichOneof(od)
   274  			i += od.Fields().Len()
   275  		} else {
   276  			i++
   277  		}
   278  		if fd == nil || !m.Has(fd) {
   279  			continue
   280  		}
   281  
   282  		switch {
   283  		case fd.IsList():
   284  			lv := m.Get(fd).List()
   285  			for j := 0; j < lv.Len(); j++ {
   286  				w.writeName(fd)
   287  				v := lv.Get(j)
   288  				if err := w.writeSingularValue(v, fd); err != nil {
   289  					return err
   290  				}
   291  				w.WriteByte('\n')
   292  			}
   293  		case fd.IsMap():
   294  			kfd := fd.MapKey()
   295  			vfd := fd.MapValue()
   296  			mv := m.Get(fd).Map()
   297  
   298  			type entry struct{ key, val protoreflect.Value }
   299  			var entries []entry
   300  			mv.Range(func(k protoreflect.MapKey, v protoreflect.Value) bool {
   301  				entries = append(entries, entry{k.Value(), v})
   302  				return true
   303  			})
   304  			sort.Slice(entries, func(i, j int) bool {
   305  				switch kfd.Kind() {
   306  				case protoreflect.BoolKind:
   307  					return !entries[i].key.Bool() && entries[j].key.Bool()
   308  				case protoreflect.Int32Kind, protoreflect.Sint32Kind, protoreflect.Sfixed32Kind, protoreflect.Int64Kind, protoreflect.Sint64Kind, protoreflect.Sfixed64Kind:
   309  					return entries[i].key.Int() < entries[j].key.Int()
   310  				case protoreflect.Uint32Kind, protoreflect.Fixed32Kind, protoreflect.Uint64Kind, protoreflect.Fixed64Kind:
   311  					return entries[i].key.Uint() < entries[j].key.Uint()
   312  				case protoreflect.StringKind:
   313  					return entries[i].key.String() < entries[j].key.String()
   314  				default:
   315  					panic("invalid kind")
   316  				}
   317  			})
   318  			for _, entry := range entries {
   319  				w.writeName(fd)
   320  				w.WriteByte('<')
   321  				if !w.compact {
   322  					w.WriteByte('\n')
   323  				}
   324  				w.indent++
   325  				w.writeName(kfd)
   326  				if err := w.writeSingularValue(entry.key, kfd); err != nil {
   327  					return err
   328  				}
   329  				w.WriteByte('\n')
   330  				w.writeName(vfd)
   331  				if err := w.writeSingularValue(entry.val, vfd); err != nil {
   332  					return err
   333  				}
   334  				w.WriteByte('\n')
   335  				w.indent--
   336  				w.WriteByte('>')
   337  				w.WriteByte('\n')
   338  			}
   339  		default:
   340  			w.writeName(fd)
   341  			if err := w.writeSingularValue(m.Get(fd), fd); err != nil {
   342  				return err
   343  			}
   344  			w.WriteByte('\n')
   345  		}
   346  	}
   347  
   348  	if b := m.GetUnknown(); len(b) > 0 {
   349  		w.writeUnknownFields(b)
   350  	}
   351  	return w.writeExtensions(m)
   352  }
   353  
   354  func (w *textWriter) writeSingularValue(v protoreflect.Value, fd protoreflect.FieldDescriptor) error {
   355  	switch fd.Kind() {
   356  	case protoreflect.FloatKind, protoreflect.DoubleKind:
   357  		switch vf := v.Float(); {
   358  		case math.IsInf(vf, +1):
   359  			w.Write(posInf)
   360  		case math.IsInf(vf, -1):
   361  			w.Write(negInf)
   362  		case math.IsNaN(vf):
   363  			w.Write(nan)
   364  		default:
   365  			fmt.Fprint(w, v.Interface())
   366  		}
   367  	case protoreflect.StringKind:
   368  		// NOTE: This does not validate UTF-8 for historical reasons.
   369  		w.writeQuotedString(string(v.String()))
   370  	case protoreflect.BytesKind:
   371  		w.writeQuotedString(string(v.Bytes()))
   372  	case protoreflect.MessageKind, protoreflect.GroupKind:
   373  		var bra, ket byte = '<', '>'
   374  		if fd.Kind() == protoreflect.GroupKind {
   375  			bra, ket = '{', '}'
   376  		}
   377  		w.WriteByte(bra)
   378  		if !w.compact {
   379  			w.WriteByte('\n')
   380  		}
   381  		w.indent++
   382  		m := v.Message()
   383  		if m2, ok := m.Interface().(encoding.TextMarshaler); ok {
   384  			b, err := m2.MarshalText()
   385  			if err != nil {
   386  				return err
   387  			}
   388  			w.Write(b)
   389  		} else {
   390  			w.writeMessage(m)
   391  		}
   392  		w.indent--
   393  		w.WriteByte(ket)
   394  	case protoreflect.EnumKind:
   395  		if ev := fd.Enum().Values().ByNumber(v.Enum()); ev != nil {
   396  			fmt.Fprint(w, ev.Name())
   397  		} else {
   398  			fmt.Fprint(w, v.Enum())
   399  		}
   400  	default:
   401  		fmt.Fprint(w, v.Interface())
   402  	}
   403  	return nil
   404  }
   405  
   406  // writeQuotedString writes a quoted string in the protocol buffer text format.
   407  func (w *textWriter) writeQuotedString(s string) {
   408  	w.WriteByte('"')
   409  	for i := 0; i < len(s); i++ {
   410  		switch c := s[i]; c {
   411  		case '\n':
   412  			w.buf = append(w.buf, `\n`...)
   413  		case '\r':
   414  			w.buf = append(w.buf, `\r`...)
   415  		case '\t':
   416  			w.buf = append(w.buf, `\t`...)
   417  		case '"':
   418  			w.buf = append(w.buf, `\"`...)
   419  		case '\\':
   420  			w.buf = append(w.buf, `\\`...)
   421  		default:
   422  			if isPrint := c >= 0x20 && c < 0x7f; isPrint {
   423  				w.buf = append(w.buf, c)
   424  			} else {
   425  				w.buf = append(w.buf, fmt.Sprintf(`\%03o`, c)...)
   426  			}
   427  		}
   428  	}
   429  	w.WriteByte('"')
   430  }
   431  
   432  func (w *textWriter) writeUnknownFields(b []byte) {
   433  	if !w.compact {
   434  		fmt.Fprintf(w, "/* %d unknown bytes */\n", len(b))
   435  	}
   436  
   437  	for len(b) > 0 {
   438  		num, wtyp, n := protowire.ConsumeTag(b)
   439  		if n < 0 {
   440  			return
   441  		}
   442  		b = b[n:]
   443  
   444  		if wtyp == protowire.EndGroupType {
   445  			w.indent--
   446  			w.Write(endBraceNewline)
   447  			continue
   448  		}
   449  		fmt.Fprint(w, num)
   450  		if wtyp != protowire.StartGroupType {
   451  			w.WriteByte(':')
   452  		}
   453  		if !w.compact || wtyp == protowire.StartGroupType {
   454  			w.WriteByte(' ')
   455  		}
   456  		switch wtyp {
   457  		case protowire.VarintType:
   458  			v, n := protowire.ConsumeVarint(b)
   459  			if n < 0 {
   460  				return
   461  			}
   462  			b = b[n:]
   463  			fmt.Fprint(w, v)
   464  		case protowire.Fixed32Type:
   465  			v, n := protowire.ConsumeFixed32(b)
   466  			if n < 0 {
   467  				return
   468  			}
   469  			b = b[n:]
   470  			fmt.Fprint(w, v)
   471  		case protowire.Fixed64Type:
   472  			v, n := protowire.ConsumeFixed64(b)
   473  			if n < 0 {
   474  				return
   475  			}
   476  			b = b[n:]
   477  			fmt.Fprint(w, v)
   478  		case protowire.BytesType:
   479  			v, n := protowire.ConsumeBytes(b)
   480  			if n < 0 {
   481  				return
   482  			}
   483  			b = b[n:]
   484  			fmt.Fprintf(w, "%q", v)
   485  		case protowire.StartGroupType:
   486  			w.WriteByte('{')
   487  			w.indent++
   488  		default:
   489  			fmt.Fprintf(w, "/* unknown wire type %d */", wtyp)
   490  		}
   491  		w.WriteByte('\n')
   492  	}
   493  }
   494  
   495  // writeExtensions writes all the extensions in m.
   496  func (w *textWriter) writeExtensions(m protoreflect.Message) error {
   497  	md := m.Descriptor()
   498  	if md.ExtensionRanges().Len() == 0 {
   499  		return nil
   500  	}
   501  
   502  	type ext struct {
   503  		desc protoreflect.FieldDescriptor
   504  		val  protoreflect.Value
   505  	}
   506  	var exts []ext
   507  	m.Range(func(fd protoreflect.FieldDescriptor, v protoreflect.Value) bool {
   508  		if fd.IsExtension() {
   509  			exts = append(exts, ext{fd, v})
   510  		}
   511  		return true
   512  	})
   513  	sort.Slice(exts, func(i, j int) bool {
   514  		return exts[i].desc.Number() < exts[j].desc.Number()
   515  	})
   516  
   517  	for _, ext := range exts {
   518  		// For message set, use the name of the message as the extension name.
   519  		name := string(ext.desc.FullName())
   520  		if isMessageSet(ext.desc.ContainingMessage()) {
   521  			name = strings.TrimSuffix(name, ".message_set_extension")
   522  		}
   523  
   524  		if !ext.desc.IsList() {
   525  			if err := w.writeSingularExtension(name, ext.val, ext.desc); err != nil {
   526  				return err
   527  			}
   528  		} else {
   529  			lv := ext.val.List()
   530  			for i := 0; i < lv.Len(); i++ {
   531  				if err := w.writeSingularExtension(name, lv.Get(i), ext.desc); err != nil {
   532  					return err
   533  				}
   534  			}
   535  		}
   536  	}
   537  	return nil
   538  }
   539  
   540  func (w *textWriter) writeSingularExtension(name string, v protoreflect.Value, fd protoreflect.FieldDescriptor) error {
   541  	fmt.Fprintf(w, "[%s]:", name)
   542  	if !w.compact {
   543  		w.WriteByte(' ')
   544  	}
   545  	if err := w.writeSingularValue(v, fd); err != nil {
   546  		return err
   547  	}
   548  	w.WriteByte('\n')
   549  	return nil
   550  }
   551  
   552  func (w *textWriter) writeIndent() {
   553  	if !w.complete {
   554  		return
   555  	}
   556  	for i := 0; i < w.indent*2; i++ {
   557  		w.buf = append(w.buf, ' ')
   558  	}
   559  	w.complete = false
   560  }
   561  

View as plain text