1 // Go support for Protocol Buffers - Google's data interchange format
3 // Copyright 2010 The Go Authors. All rights reserved.
4 // https://github.com/golang/protobuf
6 // Redistribution and use in source and binary forms, with or without
7 // modification, are permitted provided that the following conditions are
10 // * Redistributions of source code must retain the above copyright
11 // notice, this list of conditions and the following disclaimer.
12 // * Redistributions in binary form must reproduce the above
13 // copyright notice, this list of conditions and the following disclaimer
14 // in the documentation and/or other materials provided with the
16 // * Neither the name of Google Inc. nor the names of its
17 // contributors may be used to endorse or promote products derived from
18 // this software without specific prior written permission.
20 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
21 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
22 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
23 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
24 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
25 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
26 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
27 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
28 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
29 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
30 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
33 Package proto converts data structures to and from the wire format of
34 protocol buffers. It works in concert with the Go source code generated
35 for .proto files by the protocol compiler.
37 A summary of the properties of the protocol buffer interface
38 for a protocol buffer variable v:
40 - Names are turned from camel_case to CamelCase for export.
41 - There are no methods on v to set fields; just treat
42 them as structure fields.
43 - There are getters that return a field's value if set,
44 and return the field's default value if unset.
45 The getters work even if the receiver is a nil message.
46 - The zero value for a struct is its correct initialization state.
47 All desired fields must be set before marshaling.
48 - A Reset() method will restore a protobuf struct to its zero state.
49 - Non-repeated fields are pointers to the values; nil means unset.
50 That is, optional or required field int32 f becomes F *int32.
51 - Repeated fields are slices.
52 - Helper functions are available to aid the setting of fields.
53 msg.Foo = proto.String("hello") // set field
54 - Constants are defined to hold the default values of all fields that
55 have them. They have the form Default_StructName_FieldName.
56 Because the getter methods handle defaulted values,
57 direct use of these constants should be rare.
58 - Enums are given type names and maps from names to values.
59 Enum values are prefixed by the enclosing message's name, or by the
60 enum's type name if it is a top-level enum. Enum types have a String
61 method, and a Enum method to assist in message construction.
62 - Nested messages, groups and enums have type names prefixed with the name of
63 the surrounding message type.
64 - Extensions are given descriptor names that start with E_,
65 followed by an underscore-delimited list of the nested messages
66 that contain it (if any) followed by the CamelCased name of the
67 extension field itself. HasExtension, ClearExtension, GetExtension
68 and SetExtension are functions for manipulating extensions.
69 - Oneof field sets are given a single field in their message,
70 with distinguished wrapper types for each possible field value.
71 - Marshal and Unmarshal are functions to encode and decode the wire format.
73 When the .proto file specifies `syntax="proto3"`, there are some differences:
75 - Non-repeated fields of non-message type are values instead of pointers.
76 - Enum types do not get an Enum method.
78 The simplest way to describe this is to see an example.
79 Given file test.proto, containing
86 required string label = 1;
87 optional int32 type = 2 [default=77];
88 repeated int64 reps = 3;
89 optional group OptionalGroup = 4 {
90 required string RequiredField = 5;
98 The resulting file, test.pb.go, is:
102 import proto "github.com/golang/protobuf/proto"
109 var FOO_name = map[int32]string{
112 var FOO_value = map[string]int32{
116 func (x FOO) Enum() *FOO {
121 func (x FOO) String() string {
122 return proto.EnumName(FOO_name, int32(x))
124 func (x *FOO) UnmarshalJSON(data []byte) error {
125 value, err := proto.UnmarshalJSONEnum(FOO_value, data)
134 Label *string `protobuf:"bytes,1,req,name=label" json:"label,omitempty"`
135 Type *int32 `protobuf:"varint,2,opt,name=type,def=77" json:"type,omitempty"`
136 Reps []int64 `protobuf:"varint,3,rep,name=reps" json:"reps,omitempty"`
137 Optionalgroup *Test_OptionalGroup `protobuf:"group,4,opt,name=OptionalGroup" json:"optionalgroup,omitempty"`
138 // Types that are valid to be assigned to Union:
141 Union isTest_Union `protobuf_oneof:"union"`
142 XXX_unrecognized []byte `json:"-"`
144 func (m *Test) Reset() { *m = Test{} }
145 func (m *Test) String() string { return proto.CompactTextString(m) }
146 func (*Test) ProtoMessage() {}
148 type isTest_Union interface {
152 type Test_Number struct {
153 Number int32 `protobuf:"varint,6,opt,name=number"`
155 type Test_Name struct {
156 Name string `protobuf:"bytes,7,opt,name=name"`
159 func (*Test_Number) isTest_Union() {}
160 func (*Test_Name) isTest_Union() {}
162 func (m *Test) GetUnion() isTest_Union {
168 const Default_Test_Type int32 = 77
170 func (m *Test) GetLabel() string {
171 if m != nil && m.Label != nil {
177 func (m *Test) GetType() int32 {
178 if m != nil && m.Type != nil {
181 return Default_Test_Type
184 func (m *Test) GetOptionalgroup() *Test_OptionalGroup {
186 return m.Optionalgroup
191 type Test_OptionalGroup struct {
192 RequiredField *string `protobuf:"bytes,5,req" json:"RequiredField,omitempty"`
194 func (m *Test_OptionalGroup) Reset() { *m = Test_OptionalGroup{} }
195 func (m *Test_OptionalGroup) String() string { return proto.CompactTextString(m) }
197 func (m *Test_OptionalGroup) GetRequiredField() string {
198 if m != nil && m.RequiredField != nil {
199 return *m.RequiredField
204 func (m *Test) GetNumber() int32 {
205 if x, ok := m.GetUnion().(*Test_Number); ok {
211 func (m *Test) GetName() string {
212 if x, ok := m.GetUnion().(*Test_Name); ok {
219 proto.RegisterEnum("example.FOO", FOO_name, FOO_value)
222 To create and play with a Test object:
229 "github.com/golang/protobuf/proto"
235 Label: proto.String("hello"),
236 Type: proto.Int32(17),
237 Reps: []int64{1, 2, 3},
238 Optionalgroup: &pb.Test_OptionalGroup{
239 RequiredField: proto.String("good bye"),
241 Union: &pb.Test_Name{"fred"},
243 data, err := proto.Marshal(test)
245 log.Fatal("marshaling error: ", err)
247 newTest := &pb.Test{}
248 err = proto.Unmarshal(data, newTest)
250 log.Fatal("unmarshaling error: ", err)
252 // Now test and newTest contain the same data.
253 if test.GetLabel() != newTest.GetLabel() {
254 log.Fatalf("data mismatch %q != %q", test.GetLabel(), newTest.GetLabel())
256 // Use a type switch to determine which oneof was set.
257 switch u := test.Union.(type) {
258 case *pb.Test_Number: // u.Number contains the number.
259 case *pb.Test_Name: // u.Name contains the string.
276 // Message is implemented by generated protocol buffer messages.
277 type Message interface {
283 // Stats records allocation details about the protocol buffer encoders
284 // and decoders. Useful for tuning the library itself.
286 Emalloc uint64 // mallocs in encode
287 Dmalloc uint64 // mallocs in decode
288 Encode uint64 // number of encodes
289 Decode uint64 // number of decodes
290 Chit uint64 // number of cache hits
291 Cmiss uint64 // number of cache misses
292 Size uint64 // number of sizes
295 // Set to true to enable stats collection.
296 const collectStats = false
300 // GetStats returns a copy of the global Stats structure.
301 func GetStats() Stats { return stats }
303 // A Buffer is a buffer manager for marshaling and unmarshaling
304 // protocol buffers. It may be reused between invocations to
305 // reduce memory usage. It is not necessary to use a Buffer;
306 // the global functions Marshal and Unmarshal create a
307 // temporary Buffer and are fine for most applications.
309 buf []byte // encode/decode byte stream
310 index int // read point
312 // pools of basic types to amortize allocation.
317 // extra pools, only used with pointer_reflect.go
324 // NewBuffer allocates a new Buffer and initializes its internal data to
325 // the contents of the argument slice.
326 func NewBuffer(e []byte) *Buffer {
327 return &Buffer{buf: e}
330 // Reset resets the Buffer, ready for marshaling a new protocol buffer.
331 func (p *Buffer) Reset() {
332 p.buf = p.buf[0:0] // for reading/writing
333 p.index = 0 // for reading
336 // SetBuf replaces the internal buffer with the slice,
337 // ready for unmarshaling the contents of the slice.
338 func (p *Buffer) SetBuf(s []byte) {
343 // Bytes returns the contents of the Buffer.
344 func (p *Buffer) Bytes() []byte { return p.buf }
347 * Helper routines for simplifying the creation of optional fields of basic type.
350 // Bool is a helper routine that allocates a new bool value
351 // to store v and returns a pointer to it.
352 func Bool(v bool) *bool {
356 // Int32 is a helper routine that allocates a new int32 value
357 // to store v and returns a pointer to it.
358 func Int32(v int32) *int32 {
362 // Int is a helper routine that allocates a new int32 value
363 // to store v and returns a pointer to it, but unlike Int32
364 // its argument value is an int.
365 func Int(v int) *int32 {
371 // Int64 is a helper routine that allocates a new int64 value
372 // to store v and returns a pointer to it.
373 func Int64(v int64) *int64 {
377 // Float32 is a helper routine that allocates a new float32 value
378 // to store v and returns a pointer to it.
379 func Float32(v float32) *float32 {
383 // Float64 is a helper routine that allocates a new float64 value
384 // to store v and returns a pointer to it.
385 func Float64(v float64) *float64 {
389 // Uint32 is a helper routine that allocates a new uint32 value
390 // to store v and returns a pointer to it.
391 func Uint32(v uint32) *uint32 {
395 // Uint64 is a helper routine that allocates a new uint64 value
396 // to store v and returns a pointer to it.
397 func Uint64(v uint64) *uint64 {
401 // String is a helper routine that allocates a new string value
402 // to store v and returns a pointer to it.
403 func String(v string) *string {
407 // EnumName is a helper function to simplify printing protocol buffer enums
408 // by name. Given an enum map and a value, it returns a useful string.
409 func EnumName(m map[int32]string, v int32) string {
414 return strconv.Itoa(int(v))
417 // UnmarshalJSONEnum is a helper function to simplify recovering enum int values
418 // from their JSON-encoded representation. Given a map from the enum's symbolic
419 // names to its int values, and a byte buffer containing the JSON-encoded
420 // value, it returns an int32 that can be cast to the enum type by the caller.
422 // The function can deal with both JSON representations, numeric and symbolic.
423 func UnmarshalJSONEnum(m map[string]int32, data []byte, enumName string) (int32, error) {
425 // New style: enums are strings.
427 if err := json.Unmarshal(data, &repr); err != nil {
432 return 0, fmt.Errorf("unrecognized enum %s value %q", enumName, repr)
436 // Old style: enums are ints.
438 if err := json.Unmarshal(data, &val); err != nil {
439 return 0, fmt.Errorf("cannot unmarshal %#q into enum %s", data, enumName)
444 // DebugPrint dumps the encoded data in b in a debugging format with a header
445 // including the string s. Used in testing but made available for general debugging.
446 func (p *Buffer) DebugPrint(s string, b []byte) {
455 fmt.Printf("\n--- %s ---\n", s)
459 for i := 0; i < depth; i++ {
464 if index == len(p.buf) {
468 op, err := p.DecodeVarint()
470 fmt.Printf("%3d: fetching op err %v\n", index, err)
478 fmt.Printf("%3d: t=%3d unknown wire=%d\n",
485 r, err = p.DecodeRawBytes(false)
489 fmt.Printf("%3d: t=%3d bytes [%d]", index, tag, len(r))
491 for i := 0; i < len(r); i++ {
492 fmt.Printf(" %.2x", r[i])
495 for i := 0; i < 3; i++ {
496 fmt.Printf(" %.2x", r[i])
499 for i := len(r) - 3; i < len(r); i++ {
500 fmt.Printf(" %.2x", r[i])
506 u, err = p.DecodeFixed32()
508 fmt.Printf("%3d: t=%3d fix32 err %v\n", index, tag, err)
511 fmt.Printf("%3d: t=%3d fix32 %d\n", index, tag, u)
514 u, err = p.DecodeFixed64()
516 fmt.Printf("%3d: t=%3d fix64 err %v\n", index, tag, err)
519 fmt.Printf("%3d: t=%3d fix64 %d\n", index, tag, u)
522 u, err = p.DecodeVarint()
524 fmt.Printf("%3d: t=%3d varint err %v\n", index, tag, err)
527 fmt.Printf("%3d: t=%3d varint %d\n", index, tag, u)
530 fmt.Printf("%3d: t=%3d start\n", index, tag)
535 fmt.Printf("%3d: t=%3d end\n", index, tag)
540 fmt.Printf("%3d: start-end not balanced %d\n", p.index, depth)
548 // SetDefaults sets unset protocol buffer fields to their default values.
549 // It only modifies fields that are both unset and have defined defaults.
550 // It recursively sets default values in any non-nil sub-messages.
551 func SetDefaults(pb Message) {
552 setDefaults(reflect.ValueOf(pb), true, false)
555 // v is a pointer to a struct.
556 func setDefaults(v reflect.Value, recur, zeros bool) {
560 dm, ok := defaults[v.Type()]
563 dm = buildDefaultMessage(v.Type())
565 defaults[v.Type()] = dm
569 for _, sf := range dm.scalars {
570 f := v.Field(sf.index)
576 if dv == nil && !zeros {
577 // no explicit default, and don't want to set zeros
580 fptr := f.Addr().Interface() // **T
581 // TODO: Consider batching the allocations we do here.
589 case reflect.Float32:
594 *(fptr.(**float32)) = f
595 case reflect.Float64:
600 *(fptr.(**float64)) = f
603 if ft := f.Type(); ft != int32PtrType {
605 f.Set(reflect.New(ft.Elem()))
607 f.Elem().SetInt(int64(dv.(int32)))
615 *(fptr.(**int32)) = i
622 *(fptr.(**int64)) = i
628 *(fptr.(**string)) = s
630 // exceptional case: []byte
634 b = make([]byte, len(db))
639 *(fptr.(*[]byte)) = b
645 *(fptr.(**uint32)) = u
651 *(fptr.(**uint64)) = u
653 log.Printf("proto: can't set default for field %v (sf.kind=%v)", f, sf.kind)
657 for _, ni := range dm.nested {
659 // f is *T or []*T or map[T]*T
665 setDefaults(f, recur, zeros)
668 for i := 0; i < f.Len(); i++ {
673 setDefaults(e, recur, zeros)
677 for _, k := range f.MapKeys() {
682 setDefaults(e, recur, zeros)
689 // defaults maps a protocol buffer struct type to a slice of the fields,
690 // with its scalar fields set to their proto-declared non-zero default values.
691 defaultMu sync.RWMutex
692 defaults = make(map[reflect.Type]defaultMessage)
694 int32PtrType = reflect.TypeOf((*int32)(nil))
697 // defaultMessage represents information about the default values of a message.
698 type defaultMessage struct {
699 scalars []scalarField
700 nested []int // struct field index of nested messages
703 type scalarField struct {
704 index int // struct field index
705 kind reflect.Kind // element type (the T in *T or []T)
706 value interface{} // the proto-declared default value, or nil
709 // t is a struct type.
710 func buildDefaultMessage(t reflect.Type) (dm defaultMessage) {
711 sprop := GetProperties(t)
712 for _, prop := range sprop.Prop {
713 fi, ok := sprop.decoderTags.get(prop.Tag)
718 ft := t.Field(fi).Type
720 sf, nested, err := fieldDefault(ft, prop)
725 dm.nested = append(dm.nested, fi)
728 dm.scalars = append(dm.scalars, *sf)
735 // fieldDefault returns the scalarField for field type ft.
736 // sf will be nil if the field can not have a default.
737 // nestedMessage will be true if this is a nested message.
738 // Note that sf.index is not set on return.
739 func fieldDefault(ft reflect.Type, prop *Properties) (sf *scalarField, nestedMessage bool, err error) {
740 var canHaveDefault bool
743 if ft.Elem().Kind() == reflect.Struct {
746 canHaveDefault = true // proto2 scalar field
750 switch ft.Elem().Kind() {
752 nestedMessage = true // repeated message
754 canHaveDefault = true // bytes field
758 if ft.Elem().Kind() == reflect.Ptr {
759 nestedMessage = true // map with message values
765 return nil, true, nil
767 return nil, false, nil
770 // We now know that ft is a pointer or slice.
771 sf = &scalarField{kind: ft.Elem().Kind()}
773 // scalar fields without defaults
774 if !prop.HasDefault {
775 return sf, false, nil
778 // a scalar field: either *T or []byte
779 switch ft.Elem().Kind() {
781 x, err := strconv.ParseBool(prop.Default)
783 return nil, false, fmt.Errorf("proto: bad default bool %q: %v", prop.Default, err)
786 case reflect.Float32:
787 x, err := strconv.ParseFloat(prop.Default, 32)
789 return nil, false, fmt.Errorf("proto: bad default float32 %q: %v", prop.Default, err)
791 sf.value = float32(x)
792 case reflect.Float64:
793 x, err := strconv.ParseFloat(prop.Default, 64)
795 return nil, false, fmt.Errorf("proto: bad default float64 %q: %v", prop.Default, err)
799 x, err := strconv.ParseInt(prop.Default, 10, 32)
801 return nil, false, fmt.Errorf("proto: bad default int32 %q: %v", prop.Default, err)
805 x, err := strconv.ParseInt(prop.Default, 10, 64)
807 return nil, false, fmt.Errorf("proto: bad default int64 %q: %v", prop.Default, err)
811 sf.value = prop.Default
813 // []byte (not *uint8)
814 sf.value = []byte(prop.Default)
816 x, err := strconv.ParseUint(prop.Default, 10, 32)
818 return nil, false, fmt.Errorf("proto: bad default uint32 %q: %v", prop.Default, err)
822 x, err := strconv.ParseUint(prop.Default, 10, 64)
824 return nil, false, fmt.Errorf("proto: bad default uint64 %q: %v", prop.Default, err)
828 return nil, false, fmt.Errorf("proto: unhandled def kind %v", ft.Elem().Kind())
831 return sf, false, nil
834 // Map fields may have key types of non-float scalars, strings and enums.
835 // The easiest way to sort them in some deterministic order is to use fmt.
836 // If this turns out to be inefficient we can always consider other options,
837 // such as doing a Schwartzian transform.
839 func mapKeys(vs []reflect.Value) sort.Interface {
842 // default Less function: textual comparison
843 less: func(a, b reflect.Value) bool {
844 return fmt.Sprint(a.Interface()) < fmt.Sprint(b.Interface())
848 // Type specialization per https://developers.google.com/protocol-buffers/docs/proto#maps;
849 // numeric keys are sorted numerically.
853 switch vs[0].Kind() {
854 case reflect.Int32, reflect.Int64:
855 s.less = func(a, b reflect.Value) bool { return a.Int() < b.Int() }
856 case reflect.Uint32, reflect.Uint64:
857 s.less = func(a, b reflect.Value) bool { return a.Uint() < b.Uint() }
863 type mapKeySorter struct {
865 less func(a, b reflect.Value) bool
868 func (s mapKeySorter) Len() int { return len(s.vs) }
869 func (s mapKeySorter) Swap(i, j int) { s.vs[i], s.vs[j] = s.vs[j], s.vs[i] }
870 func (s mapKeySorter) Less(i, j int) bool {
871 return s.less(s.vs[i], s.vs[j])
874 // isProto3Zero reports whether v is a zero proto3 value.
875 func isProto3Zero(v reflect.Value) bool {
879 case reflect.Int32, reflect.Int64:
881 case reflect.Uint32, reflect.Uint64:
883 case reflect.Float32, reflect.Float64:
884 return v.Float() == 0
886 return v.String() == ""
891 // ProtoPackageIsVersion2 is referenced from generated protocol buffer files
892 // to assert that that code is compatible with this version of the proto package.
893 const ProtoPackageIsVersion2 = true
895 // ProtoPackageIsVersion1 is referenced from generated protocol buffer files
896 // to assert that that code is compatible with this version of the proto package.
897 const ProtoPackageIsVersion1 = true